# v2 git bundle d2d3fbbe24e0575a318fa3959549ca74117c46c6 refs/heads/bundle d2d3fbbe24e0575a318fa3959549ca74117c46c6 HEAD PACK x1O0w'Fq XIv[;}wS`FG6i产jHS&q.]iD}[feN*լƴTVF1 >w&x>]G?B\J6R~mJW1-O6b0S!aSDϔ@_r{s>f c!p^Pb>i`sE`2gՏ rOY*KL5Gl'pe ߋsch6]!ċ_|;UwOx0|z (ͧxAn0D>?@9!D5i!I\Ъryo4q$ޘP"+1+ p.\9Z ۘ±Oi`dƅl+[TBؼ)4i'*cF@ u0  TBC̆1(Vw a 98'X׫Muk=j[^~w ;n>2r>3S ]`l1E`GafU3xR;o0+Z؂dAR$ 4SœŚ"#rRݺ:zKMdz,J[EU9meU]喍hI{ 6eS`E %eTߐiH8?m_m:[ڪR6N^z$!@ 0d8A|]l2(q12^kf()zI1rvi{GH_t\zYFB\'!dA傉sp a& d(C^|C.{ Կ=3Rw#ΎsoHzmBњ}2J|xnR<:xn0 w=,a+%AhlɕWvH'śS̫HBМK)R%MFus*hZs!.9U(E#Lprg&pk3ۺ B\pE3Ʊg7{GĎPG28bևt(YpO.[%7BDRCxM>0ÐzBO_ (&ڔFRO8[;L>.{H?mK&c*C|7ڗ/zڭkq#xR Őn!1`9~IWTJ]ȅ -I>]AnW87ܕ L. p!g٥/,2(*e9L̷r @ӧH_"&LdVL=]*pQV "/$ 倃;:p;s_,e~撕L{<'^`QH0mn%4x#=%srw],DKw(娵8&dDw+Pb 4wD/\6i)zQ|El: &xOo0sk+-Ȱt(S&^ϰ; c7ޛ J&I (ZEK TYCY%0HYIMYSuBն+EVʨK謃7k\ \m|lo +kg1!Ba!/]]68Q{t D¾gɃo;{o_!xpqhБ?Z[ҝ tamhE=I#ll97S w Yxك8~#O8àM`:)?_ k."R!m}.SWwx2E}# 1790153625 -0700 committer Zach Kelling 1790153625 -0700 An interface field is any JSON, not an object schemaOf fell through to {"type":"object"} for an interface, and the projector did the same for the `any` prim, so a field holding a token string or an array was described as an object. The published examples that carried one failed against their own schema — Hanzo's auto.runIn.auth and tool.toolCall.arguments — and every generated client typed the field wrong. An interface is now the unconstrained schema a silent marshaler already gets. Co-authored-by: Hanzo Dev y +xItree 615228a03bcadc0cb0cfbea3616814bff37f7e9e parent 4593f61024082ec989e8719b4bf9eb5fb822357c author Zach Kelling 1789715233 -0700 committer Zach Kelling 1789715233 -0700 Honor ctx cancellation and deadlines on every outbound call Call, remote invokes, proxy hops and CLI commands all called Client.Do, which takes no ctx, so a cancelled or expired caller kept waiting until the transport's own read timeout. zap-proto/http v0.3.11 adds Transport.DoContext; a client that implements the new ContextClient interface is now driven through it, and Call returns an error wrapping context.Canceled or context.DeadlineExceeded. Co-authored-by: Hanzo Dev O9xbtree 16dba398e8c6eace459fdb9e17861c134b2425f5 parent 0156f40d538eee7fe70f2f9b547752bca3c2d3cf author Zach Kelling 1789708189 -0700 committer Zach Kelling 1789708189 -0700 An unresolvable prefix refuses, as the rule above it says routerPrefix promises that an unresolvable router "is an error naming the call, never an assumed empty prefix", and then returned the empty prefix for a group. So a group handed to another function filed its ops at the path after the prefix — an address nothing serves — in the document and the MCP tool alike, which is the silent drop the resolution exists to end. The one shape this hits is a group reached through a parameter: the prefix belongs to the call that made the group, and the call is in another function. The error says so now, rather than leaving the reader to infer it from a path that looks plausible. Co-authored-by: Hanzo Dev q:@KxDtree f6a5186033cbf2b633fd97bf08dc2b6a66984a4b parent 16323edc618eb2dadfdcff0b04f532aa12bf293c author Zach Kelling 1789705012 -0700 committer Zach Kelling 1789705012 -0700 A raw route's prose is reachable by its address cmd/zipdoc files every entry under the package that declared it, raw routes included. A raw route records no registrar — a method, a path and a handler chain is all App.raw keeps — so an address is all anyone can ask by, and the address lookup could not reach a qualified key. A service's whole untyped half therefore documented as silent the moment its generated file was rewritten: 57 of iam's routes at once. So the keys are indexed by address as they are recorded, and only the unqualified lookup reads that index. A caller that names a package asked about that package, and answering it with another's sentence would document one service with another's words. An address two packages describe differently is dropped from the index rather than resolved. One address answers once in one process, so two claims on it are a conflict, and choosing either would be a guess; the qualified lookup still reaches both. Co-authored-by: Hanzo Dev <6xctree d0003c8454dd324126603a39ef76d459feeb64b0 parent f051fd8a08f6e4c2d006790c423fb9af9680a952 author Zach Kelling 1789702447 -0700 committer Zach Kelling 1789702447 -0700 A router named by an alias is still the router A host that re-exports the type writes `type Router = *zip.App` and hands a Router to every plugin. That is the same type, but it arrives as types.Alias, so matching the shape directly saw neither an App nor a Group and the op's prefix could not be resolved — which refuses the whole document rather than filing one path wrongly. Unalias at each place a type is matched by shape, including the In and Out inferred from a handler. A group is also read when var names it, not only :=. The prefix belongs to the Group call; the syntax that binds the result does not change it. Co-authored-by: Hanzo Dev %ǑIxntree cfa2df4a4ed50af4a8c3c2a23a22c5dc08a97bab parent c47944c0f801a81a35882e5d6a8e02b6636c1cc5 author Zach Kelling 1789700529 -0700 committer Zach Kelling 1789700529 -0700 A host can ask whether a definition composes without ending it Cloud composes each plugin as its own definition and asks Declaration for its routes before composing it. A projection of a program that does not compose panics rather than lying, so a plugin whose middleware guards no routes took the host down with it; Build answers instead, but installs a generation and freezes the definition the host is about to compose by reference. Verify is Build's first half and the same call — walk, structural rules, derived rules, rule adoption — and stops there. The host reports which group is wrong and carries on. It answers for the definition as the root of its own walk. Middleware at a served root is exempt, because composition brings it routes later; one level down the same middleware guards a settled subtree. Only the host knows which a definition turned out to be, so both verdicts are right and the tests say so. Co-authored-by: Hanzo Dev 9w3x8tree 0b3124ad082bf973087755fc1cc051bf63203efe parent 8aa1e5089f138a5990fd834149a94c650e8d4fff author Zach Kelling 1789699164 -0700 committer Zach Kelling 1789699164 -0700 Every seam states the address, not just the route v1.37.9 fixed the REST path and the three by-name seams that already looked the op up in the composed registry. Two did not: the graph resolved its ops from that same registry and then invoked them without saying so, and the in-process invoke did the same. So the contract fell back to the declaration — for anything declared on a group, the bare leaf — and a rule reading op.Path governed the REST call while missing the graph call to the SAME operation. A test now asks both seams about one op and requires the same answer. Co-authored-by: Hanzo Dev Cx2tree f1f55b3b50302a8c7adf5bfec0e03425b427ee23 parent f61a1d0df143594fb6678872f51cd2410489ec37 author Zach Kelling 1789698020 -0700 committer Zach Kelling 1789698138 -0700 A rule is handed the operation as served The authorizer and the result hook were given the op as DECLARED: for anything declared on a group, the bare leaf and an id derived from it. So a rule keyed on op.Path governed an address nobody serves — /probe/:id where the route table, the registry and the document all say /v1/crm/probe/:id — and one definition mounted at two prefixes reported a single name for two operations. They now see what the route matched: the composed pattern, and the composed id by the same rule the registry uses, where a declared id is the operation's own name and composition does not get a vote. The concrete address stays off Op, because path parameters are input and the hook is promised the operation and the outcome and never the input; a handler that needs the resolved address asks AddressOf. Co-authored-by: Hanzo Dev r4xEtree 7d67c5a80ae544d8cbc34f2b6c5afcd0e49bd27e parent 72321b16e23c70cfbc926b40ee21b1b5bd02e37f author Zach Kelling 1789684758 -0700 committer Zach Kelling 1789684758 -0700 One handler at two addresses is two registrations Alias existed for one reason, stated in its own doc: a registration made inside a helper is invisible to cmd/zipdoc, so a service that rolled its own alias helper lost the prose for both addresses. That is no longer true — the pass reads Raw on a route table directly, and a fixture now proves two plain Raw calls each carry the handler's sentence. So the abstraction was working around a limitation that no longer exists, and nothing in the estate called it. It goes, with the thirty-odd lines of extractor special case that recognised it. Co-authored-by: Hanzo Dev & )xmtree fffefd89402cb08b1258571c7817421a25eee779 parent 4de3b5fbf0709b7db8107247cbd6c6f96e0183cb author Zach Kelling 1789682623 -0700 committer Zach Kelling 1789682623 -0700 A parameter's value is one segment of the address The address is a URL path, so a value substituted into it has to be escaped as a single segment. A trace id of t1/2 went in raw and read as two, so a service that forwards what AddressOf answers asked its runtime for a route nobody registered: the request arrived at the right operation and the forward went somewhere else. A space did the same thing more quietly. Co-authored-by: Hanzo Dev K^xtree c39af181d0b53a983a94fce5747925cdbc366773 parent 383a33466d982a8adbdf0027d2b4e52ee2ef3fb2 author Zach Kelling 1789672647 -0700 committer Zach Kelling 1789673479 -0700 An address has one spelling, and one place that spells it A pattern never ends in "/" now, the root aside, because the router serves "/x" and "/x/" alike — so two spellings were two keys for one address, and a group could not name its own root at all: declaring "" on it produced the prefix with a trailing slash. That is why a collection root had to be declared at an absolute path on the parent instead, which put the route outside the middleware of the group it belonged to. The rule was also written twice. The router composed a prefix with a leaf and cmd/zipdoc composed the same two things to find that route's prose, so trimming in the router alone would have filed every collection root's sentence under an address the document does not contain — complete document, missing description, no error anywhere. Both copies are gone; internal/addr is the one that spells it. A test registers a trailing-slash pattern — the shape the Sentry-compatible ingest addresses use on purpose — and asserts the route table, the registry, the document's template, and the operation and concrete address a handler reads are all the same string, because a service that resolves its runtime handler by name from that pattern refuses every call if two of them disagree. Co-authored-by: Hanzo Dev S5fx`tree d6ce6195aa35d7228af80ae108460b2ef923dbe3 parent d1ac3e430ecff362fd98d669c327f360b19274cf author Zach Kelling 1789670417 -0700 committer Zach Kelling 1789670417 -0700 A relay is told which resource, not just which operation The pattern says which operation answered; the address says which resource it was asked about. A handler that forwards needs both, and could only get the second by being wrapped in a closure that held the decoded input — which is what put a service's whole surface behind a helper this pass cannot read. The one seam every projection funnels through holds the resolved pattern and the decoded input together, so the address is stated once and correctly for REST, a tools/call, the call plane and an in-process invoke alike, where three of those have no request to read a path from. It is computed on demand: an op whose pattern carries no parameter pays a string compare, one that does pays reflection, and only if something asks. Deliberately not a field on Op. Op is what a rule is handed and what the result hook is told, and both are narrow on purpose — the hook is given the operation and the outcome, never the input. A concrete address carries path parameters, which are input, so putting it there would widen two contracts to serve a third. A test pins what those two see, including that it is still the declared leaf rather than the served pattern: that gap is older than this change and is its own decision to make. No additional allocation over the previous patch, measured on Benchmark_TypedRoute: 63 either way. Co-authored-by: Hanzo Dev =qRx-tree 26b3ec52d1dd82ed141c41e10b760c5a30dbef1f parent cb7c5fb64c0bc2d481cec9cf8e44879cb0611e2e author Zach Kelling 1789660662 -0700 committer Zach Kelling 1789660662 -0700 A handler is told the address it was asked at The address an op answers at is a property of the CALL, not of the declaration: a group's prefix composes at build, and a definition composed under two hosts has two addresses and one handler. So a handler could not learn its own address, and a service that needed one composed it in a wrapper and threaded it in — which made every one of those registrations a call this pass cannot see, and took a whole service's operations out of the document, the tool list and the SDKs. OpOf reads it from the context instead, so the declaration stays the bound method the projections resolve. The seam that knows the occurrence states it: the REST route that matched, and the by-name seams, which looked the op up in the composed registry. Under that, the one contract every projection funnels through states the declaration, so a handler always has an operation to read and a direct call says there is none rather than guessing. Costs two allocations on a typed REST request, measured: 61 to 63 on Benchmark_TypedRoute, with bytes unchanged. Co-authored-by: Hanzo Dev b.7xxtree 7843484dc210ce77a8c6061c562d2bf80ed3210f parent 08eaa4dff73f25ab2268b61dd49e00b62758d23a author Zach Kelling 1789650194 -0700 committer Zach Kelling 1789650194 -0700 The name is checked against what the encoder does The wire is stated in three places that have to agree: the option set, the constant's value, and the comment explaining it. The existing cases fail the moment the options move — and would pass happily while the name went on claiming semantics the encoder no longer has, which is the one an operator reads in a startup line. So the name is now asserted against the bytes: it may say "sorted keys" exactly when a map comes out sorted, and "v1 semantics" exactly when a zero under omitempty is left out. It fails in both directions — options moved, or name moved — and says which disagreed. Co-authored-by: Hanzo Dev 188xttree 8adf611a67d4557c58a7b7c778d0ab500696e80a parent 524d350ac20cf272088d3cad396f4214865921ed author Zach Kelling 1789649973 -0700 committer Zach Kelling 1789649973 -0700 The encoder's name says what it writes Variant said "encoding/json/v2", which reads as v2's semantics — a zero kept under omitempty, a nil slice as [], case-sensitive decoding, a map's keys unsorted. This wire does none of that: the options are v1's, plus sorted keys. Naming only the engine misleads in exactly the direction that matters, and the one moment anyone reads it is a startup line in a log. It is also a declaration rather than a reading of the toolchain. zip marshals through v2 because this package imports it; GOEXPERIMENT=nojsonv2 does not fall back to v1, it fails to compile — so the name cannot describe an encoder the binary is not using. Co-authored-by: Hanzo Dev w41xtree 3c0fed730304dfe2eda158086a1904ad6742b20f parent 34e4cc31c657cd4ffd48bc33934c0dcca6a96700 author Zach Kelling 1789649435 -0700 committer Zach Kelling 1789649435 -0700 An adapted handler is asked for the address the caller named net/http's own server always fills RequestURI, so a handler is written expecting it. Converting a fiber request fills URL and leaves that field empty, and the handlers that read it are the ones that relay — a proxy, an ingest address, anything that forwards what it was asked for. An empty target normalises to "/", so a relay asks its runtime for a path nobody named. The test reads the field rather than the path, because http.ServeMux matches on URL.Path and is green either way. Co-authored-by: Hanzo Dev i >xtree 00f58533893b5b44217c72c97d57f3f763fd10ad parent 13094cd76a6cb7113e1091120c6c02b1a8efc9f3 author Zach Kelling 1789645772 -0700 committer Zach Kelling 1789645772 -0700 A group states the rule over its own ops The authorizer was already per-definition and a group has always been one, so a group could hold a tighter rule than whatever composed it — App.rule asks its own first. What was missing was the way to say so: Authorize existed only on App, and a subsystem that guards its own writes had to assert its group back to the concrete type to reach the field. Without it there are two spellings and both are wrong. The rule on nothing leaves every write there authenticated and unchecked. The rule on the host makes it the HOST's, and that covers every op the host serves — so a sibling subsystem's ops answer to rules written about a principal this guard never attached, and every valid call to it is refused. Co-authored-by: Hanzo Dev OW{!xtree a4fc057e1dd0757c1536d0dd02f1a45933f90b12 parent 5f71d2496bc4dc6aaeee9c242d4ed2f7a16a78ce author Zach Kelling 1789634221 -0700 committer Zach Kelling 1789634358 -0700 The edge's encoder is named once, by the encoder The variant was a literal in the test and a constant in the encoder, and the two spellings of one fact are what drifted when the encoder moved to v2: the suite went red over a name, not over any behaviour. The test now asks the encoder. Co-authored-by: Hanzo Dev mx#tree afd0021f401bbd84eee42d89a58c1c845c968da5 parent 305578f8a9d20b73ba5d5dd80a204f73d81cd23c author Zach Kelling 1789633937 -0700 committer Zach Kelling 1789634357 -0700 The router is three nouns, and every one of them is concrete App, Group, Operation. A group is a prefix and what holds under it, an operation is one typed route declared there, and the verb methods are generic methods — which Go 1.27 allows on a concrete type and still refuses on an interface. So In and Out come from the handler and the caller writes no type arguments: users := app.Group("/v1/users") users.Post("/", api.Create) mint := users.Group("/mint").With(middleware.Mint(gate)) mint.Post("/deposit", api.Deposit) A Group is a CLOSED HANDLE: two unexported fields, and no method that hands back the app, the parent or the fiber underneath. A subsystem given the group at its own prefix cannot reach above it, so confinement is a property of the type instead of a rule something has to police — which is what a host needs in order to hand out a bounded surface and know what comes back. That is bought by giving up the router interface, deliberately. Router and OpTarget are gone, and with them the ability to implement a route table outside this package: a decorator is no longer a router, a gate is middleware on a group, and a bound is a path. The five package-level verb functions go the same way — a registration is a method on the thing it registers into. Raw carries what is not a typed operation: a stream, an upgrade, a probe, a foreign subtree. It names its method, and it is the longer spelling because opting out of the typed model is the exception and should read like one. Co-authored-by: Hanzo Dev \ךKxEtree f8e54fa4a99b5a5b276b8359651b4578d43f3ecf parent a69381ca22f8a00e11deb4aef8a8fa3c60722702 author Zach Kelling 1789633131 -0700 committer Zach Kelling 1789633165 -0700 The wire is stated, and the encoder is v2 zip called encoding/json, which on Go 1.27 is already the v2 engine with v1's options — so the speed was never the question. What was at stake is the semantics: v2 keeps a zero number or false under omitempty, writes a nil slice as [] and a nil map as {}, leaves `<` unescaped, matches field names case-sensitively, and does not sort a map's keys. Selecting the engine by build tag meant a module moving to 1.27 changed what every response said, and this package had gone back to v1 to stop that. Now it calls v2 and says what the wire is: v1's semantics, plus sorted keys, because bytes that vary defeat an ETag, a cache, a signature and a git blob. Each remaining difference is a decision to make here, once, in view of the clients — never a default to inherit. What v2 gives back is its API. Write and Read stream straight to and from the connection with no second copy, and omitzero says what omitempty could not. Co-authored-by: Hanzo Dev "x/tree 486024e5fd8f6de8e7769bb475fa18837a2c4c39 parent e24128f57bcaff513df317470d7b425bf21f1ac3 author Zach Kelling 1789632304 -0700 committer Zach Kelling 1789632304 -0700 A plugin's dying reply is a race, and not the one under test The crash trigger asserted 200, which says the panicking plugin flushed its answer before the process went. Whether it wins that race is a scheduling accident; what the test is for is the sentence after it — the host survives and the plugin comes back. Co-authored-by: Hanzo Dev %(xrtree 39393c3c70f5228ee71ca35e1e44780d2c55140f parent 804158e7685db1ed4a39820e310f92a88daa3835 author Zach Kelling 1789631360 -0700 committer Zach Kelling 1789631360 -0700 The Rust corpus publishes the refusal its document declares Both front ends project through the same projector, so a change to what the document says about refusals reaches the Go side the moment it is written and the Rust side only when its projection is regenerated. The two disagreed by 172 lines — every default response and the problem-details schema — which is the parity test doing exactly its job. Co-authored-by: Hanzo Dev $x@tree c8dd3c966dd0bec6d8fbb6ad18fe228cf32587c7 parent 6c587ded3c94598741d4c7471b5523ef78ef40b1 author Zach Kelling 1789631348 -0700 committer Zach Kelling 1789631348 -0700 A structural miss in the document names the step that is missing A walk over typed structs collapses every miss to the zero value, so a document missing a whole response reads exactly like one whose $ref is empty, and the assertion could only ever report "". It now fails at the first absent step and prints the keys that are there. Co-authored-by: Hanzo Dev u/xtree 94eb4a206eb9cc386ed56bdab14b9d98d98b85cd parent bf9844f9a38266d4a297e37ce9cb58316f58c0db author Zach Kelling 1789631347 -0700 committer Zach Kelling 1789631347 -0700 A request that waits for a process to start gets a deadline that fits fiber's default test deadline is one second, which measures the round trip. A request to a lazy plugin waits for a CHILD PROCESS, and on a busy machine that outlasts a second by itself — so six tests failed on a deadline that was never measuring them, in a different subset every run, which is what made the whole suite's baseline untrustworthy. A generous ceiling weakens no assertion: a served request still returns the moment it is answered. Co-authored-by: Hanzo Dev >;xKtree fd081d421eeb062fcac0dea079bc957641c5d904 parent 97237bc18dd14699a56eea09b18320ca049cecd4 author Zach Kelling 1789629129 -0700 committer Zach Kelling 1789629627 -0700 A registration is filed under the package and the line that wrote it The callsite is recorded by counting frames out to the programmer's line, and a verb method on a scope sits one frame further away than the package-level function does. The count said otherwise, so every conflict, cycle and post-seal write in a scoped service cited a line somewhere above the registration instead of the two lines actually in conflict. Two tests now hold both halves of that attribution — the package an op is filed under and the line it names — across all three forms a registration takes, including a handler another package composed, which is the shape that once published seven ops with no description at all. Co-authored-by: Hanzo Dev dIxHtree adc3ea7bd086d5f2e8fcba43192e3b7f9d37f230 parent 72c91ab2b7238ffac2f69da565dd49aa09e1c0cb author Zach Kelling 1789627226 -0700 committer Zach Kelling 1789627226 -0700 The OpenAPI projection declares each operation's refusal body as its default response Co-authored-by: Hanzo Dev i0xtree 3f02e82419fee4df34ebfc8a06760df1310ec368 parent 39f32050f8e5eec8d43774d89e0f408e754231c1 author Zach Kelling 1789626838 -0700 committer Zach Kelling 1789626839 -0700 a scope registration is documented too The extractor matched one call shape: zip.Get[In,Out](target, path, fn), three arguments with the target first. A scope's verb methods carry two, and the receiver is the target, so every route migrated to scope.Post(path, handler) went silently undocumented — the op still served, and its prose stopped reaching the document and the tool list. Both forms now resolve the same handler selector to the same declaration, and a trailing metadata chain does not hide the call from the walk. Co-authored-by: Hanzo Dev kiGxqtree 16dea98f47ebdbc39bb33333057a416e9e269389 parent 84ae8111ffff473e5039631aab1dce1a18485a0e author Zach Kelling 1789624246 -0700 committer Zach Kelling 1789624246 -0700 A scope declares operations, and the verb methods are generic Go 1.27 allows generic methods on concrete types, so a scope's Get/Post/Put/ Patch/Delete infer In and Out from the handler. A declaration carries no type arguments and reads as what it does: accounts := app.Scope("/v1/accounts").Tag("accounts") accounts.Post("/", api.CreateAccount).ID("accounts.create") Interface methods still may not declare type parameters, which is why these live on the concrete *Scope rather than on Router. The package-level Post and its siblings are unchanged and register through the same path, so the document, the MCP tool, the CLI and the call plane keep reading one registry — the two forms publish byte-identical documents, which is a test. The handler is the bound method, passed directly, so the selector survives in the source and the projections can still resolve a method's doc comment. Co-authored-by: Hanzo Dev (?xtree 3c5aa9093e0a4e961769a730890d2ba416aadd55 parent a175872aab87494d9164401f5fdade360349aec5 author Zach Kelling 1789619137 -0700 committer Zach Kelling 1789619137 -0700 An op is documented by the package that registered it zipdoc files an op's prose under the package whose source holds the registration and the handler's doc comment. zip looked the prose up under the package the HANDLER was declared in, which is the same answer only while the two coincide. A handler composed by a helper elsewhere breaks it. hanzoai/cloud registers every metered op as fare.Paid(s, o.listBuckets) — one decision about money in one place — and under Go 1.27 that closure reports internal/fare, so apps/s3's seven paid ops published no description in the document, the MCP tools or any SDK. Go 1.26 reported the registering package for the same code: whether the closure is inlined is the compiler's business, so the doc key cannot rest on it. Co-authored-by: Hanzo Dev `Y8x{tree 45d99a7836e865b49af31c345fe95e969f4963d3 parent 8ddb60a2d8af82c6c49bb629648869bea9654398 author Zach Kelling 1789612810 -0700 committer Zach Kelling 1789612842 -0700 The wire does not move with the toolchain jsonenc chose encoding/json/v2 on the goexperiment.jsonv2 tag, and Go 1.27 sets that tag by default. Moving a module's go directive to 1.27 therefore changed what every zip service writes: a zero number or false kept under omitempty, a nil slice as [] and a nil map as {}, field names matched case-sensitively, map keys unsorted. hanzoai/cloud went from green to 54 failing wire tests on that bump alone. jsonenc is stdlib encoding/json and nothing else. Since 1.27 that API runs on the v2 engine with v1 semantics, so the speed arrives with the toolchain and the bytes stay put. A test pins the four differences. Co-authored-by: Hanzo Dev m0pxtree c3d02c327ab77344a4baaf0115ac4087ffc205f2 parent a6bd52c72d25600f49454223abc4925ad824ee58 author Zach Kelling 1789602307 -0700 committer Zach Kelling 1789602307 -0700 A plugin evicted the instant it starts never serves anyone hanzo.ai's Slack agent went silent. Messages arrived — 18 event deliveries in six hours — and not one agent run began. Every POST to the events endpoint returned 502 after 43 to 64 seconds, and the host log said this, twice, at the same timestamp: 23:39:31 zip lazy plugin started on first request pid 1017 23:39:31 zip idle plugin evicted reason=idle idle=2h37m58s Started and evicted in the same second, reporting an idleness from before it started. evictIfIdle reads lastUse without the lock, decides, and then calls evict, which takes the lock and swaps the child out. Its comment argued the window is harmless: a request landing in it "is already being served by the instance retire() is about to DRAIN, or it arrives after the swap and starts a fresh child". There is a third case, and it is the one that happens. A request can START the plugin inside that window — target() brings a lazy plugin up with a CAS on p.cur — and the swap then takes down a child that has served nobody. The caller waits out the drain and gets a 502. load.go already stamps lastUse on start "or the next sweep evicts what just started"; the stamp lands, and the sweep that already decided evicts it anyway. So evict re-reads the clock under the lock it is already holding. lastUse moving is precisely the signal that someone used or started the plugin since the decision was taken, which makes the decision stale. Callers pass what they observed; 0 means no idleness is being claimed. Co-authored-by: Hanzo Dev jޑ3x1tree f36038f5b4697fc6b3f419e64babeec1fb9a3e1d parent f728e8fdce785227e892392c5501d482cc4306fc author Zach Kelling 1789602296 -0700 committer Zach Kelling 1789602296 -0700 One identifier, two meanings, one package The package did not build. project_zap.go declared `type idl` while zapread.go, in the same package, imports github.com/zap-proto/go/idl and calls idl.Parse — so every reference to the import resolved to the struct: project_zap.go:65:6: idl already declared through import of package idl zapread.go:52:2: other declaration of idl The package name is the half that cannot move, so the type does. `namer` rather than `naming`, which layout.go already has. Nothing else changes: same fields, same methods, same behaviour. Co-authored-by: Hanzo Dev (3bx*tree b0a504d5f6694907d45e2d349b7347079dcec065 parent fb2b7f6d5c9002cee75eb833ad17b5c174047276 author Zach Kelling 1788726584 -0700 committer Zach Kelling 1789497717 -0700 The description comes from the binary, not from a file a macro left behind Writing the manifest fragments during macro expansion had a failure nobody would see: rustc reuses a cached expansion, so a macro that did not run left its file saying what the source used to say. A rebuild after deleting one fragment recompiled the crate and did not restore it — measured — which means a service could publish a document that quietly disagreed with its own code, the one failure this whole design exists to prevent. So the description is compiled IN. `#[derive(zip::Wire)]` gives a type `stated()`, its manifest entry as a `&'static str`, and `reach()`, which claims its entry and then asks the types of its fields — the graph is walked by the types themselves, because a macro sees only the item it is on. `#[zip::ops]` joins the ops half to whatever the ops reach and hands back `manifest()`. The service prints it on `--manifest`, so what is projected is what this build declared and there is nothing to go stale. That leaves one shape for a manifest instead of two, so zipc reads a document and no longer merges a directory of fragments; what it refused about a directory it now refuses about the document, in Manifest.Check beside the version rule. The example's build script tolerates the documents not existing yet, which is the state of the one build that makes them. )ΜxL tree 1d4f39824cfff7691388917dd3202d67fdb25aae parent 1374598de6611a4554f64e4bf1f603401287a454 author Zach Kelling 1788725919 -0700 committer Zach Kelling 1789497716 -0700 zip declares its ops in Rust, and projects them with the Go one's projector A Rust developer writes Rust handlers, with Rust types and Rust doc comments, and gets every projection from that source — the same deal a Go developer has had. No .zap is written by hand and no Go program declares a Rust service's ops. The split falls on a measured seam. What is native per language is DECLARING an op and RUNNING it; what is shared is the projection logic, driven from a neutral description of the registry. Manifest the registry with the Go taken out: ops, types, fields, wire names, prose. App.Manifest fills one in by reflection; a proc-macro fills one in as a Rust crate compiles. Project* the OpenAPI document, the MCP tool list, the CLI and the ZAP IDL, read off a Manifest. Go's own three now go through them — the whole existing suite is the oracle — so Go keeps no private path for them and the other languages cannot rot. cmd/zipc the build-time projector. It reads a manifest, or the fragments a compiler wrote, and writes the four documents. rust/ zip in Rust: #[zip::ops] on an impl block, #[derive(zip::Wire)] on a type, a router, a JSON binder, an HTTP door and a ZAP door. The wire is generated by zapgen from wire.zap; nothing here spells a byte offset by hand and nothing links Go. The layout rule moved out of the manifest and into the projector, so the offsets in a .zap are derived once for all three languages rather than three times; TestProjectZAPMatchesRegistry pins that derivation against the layout the Go encoder actually writes. One service, written twice — corpus/info in Go and rust/examples/info in Rust, fourteen ops each — is the gate. The OpenAPI document, the MCP tool list and the CLI command tree come out byte-identical, and the ZAP schema agrees on every struct, type and offset; it differs only where a field carries the declaring language's own case convention and where the ledger names a type the way the person who must change it would grep for it. ?`RxTˎ7W4| leAqI|-G kO|a$i|9j(BfY6ͦfZ֛m{hoeSajQ|&Zڦnke\nw|u=4F܅HtG'>/\vnK_՛L|j׬vRU ^&>M( ,qJ3\UuBq&N2gQ8^ 񄘢5J/f1IgN uy)SZ=|;&BryHorIԳ`B| ɽv.SShϣ1z3O:@~s"%.vQU(۔hPؙq*9Ơk14='PgeOݻ_6!Br_\ȧi=μRrz DuHr"5 DX:XCGgM?Z TR`H}vcOfW:Q؞mتr\}i)?Ŕ-Y*Co ?b3:3N?OV¶lߟuv B XV640!0ȬfU#؀A KQTU 3 _(#>!\n]l1Ӭ%>U3 |RuO|,[[@N@4鲗w}:ڈۗKĤG8/ۄ>^ HRLx?tree a3292371059f334a4aea650c993be62c989168a2 parent 4bba90f0d797344b9297b2b147d142358e768c00 author Zach Kelling 1789148174 -0700 committer Zach Kelling 1789148174 -0700 A README to build a service from, and examples/local-service The README gave no version to install and no service to run, never mentioned zipdoc, Described, ErrorHandler, the call plane's field-order rule, zipgen, CommandsFromSpec, Authorize or the MCP door's limits, and named APIs that do not exist (app.Add, app.Mount, a zip.Load that takes a prefix first). It now takes one service through REST, MCP, OpenAPI and the CLI with output from real runs, then covers each projection, the error format and the release that introduced it, and the security model. examples/local-service is that service: one SQLite-backed operation, doc comments run through zipdoc, a .mcp.json for Claude Code, and a test that checks every operation against every projection. It is a module of its own so the SQLite driver stays out of zip's graph. CI runs zipdoc -check and its tests. LLM.md is now a map of the code, the test commands, the release steps and the invariants that hold today. Co-authored-by: Hanzo Dev ̜ʑ%xQtree fe86b8a57f59337476e64cd7beb6a47e9040660e parent 60001fc32b36338479e99f4472341020309fd6df author Zach Kelling 1789148174 -0700 committer Zach Kelling 1789148174 -0700 contract: record zap-proto/go v1.8.3, which zip requires zip's go.mod requires github.com/zap-proto/go v1.8.3, and contract/go.mod still listed v1.3.0, so `go test ./...` in contract/ stopped at "updates to go.mod needed" before compiling anything. That is CI's go-test-collector step. go mod tidy changes only that requirement and its go.sum lines. Co-authored-by: Hanzo Dev F`;xAtree 7df415b9942fd80a1e45e560d40120f4215f0750 parent 46a0a196f69269241d67da5357a203694c078b6d author Zach Kelling 1789148174 -0700 committer Zach Kelling 1789148174 -0700 Answer initialize in the revision the client asked for initialize always answered 2026-07-28. The official TypeScript client (SDK 1.30.0) and Python client (SDK 2.2.0) ask for 2025-11-25 and refuse an answer in a revision they did not request and do not know, so neither could connect to /mcp. The MCP lifecycle's version negotiation answers in the requested revision when the server supports it. This door serves 2025-06-18 and 2025-11-25 as written (the same Streamable HTTP transport and tool methods, and no batches), so those are echoed. Anything else is answered in 2026-07-28, as before. With the change both clients connect, list the tools and call one, the Python client in its default auto mode as well. Co-authored-by: Hanzo Dev [:Hxwtree fc4ad99246f091a1a4f2b8d3f76897b7a778f868 parent 4f5f5a34a401fddd493d2d96438d56b67fdea35b author Zach Kelling 1789148174 -0700 committer Zach Kelling 1789148174 -0700 Declare each operation's refusal body as its default response Every non-2xx a typed op answers is an RFC 9457 problem document, or RFC 6749's error pair at an OAuth address, and the document declared neither, so SDK generators typed errors as unknown. Each operation now carries a default response that points at a problem-details or an oauth-error schema. The OAuth addresses come from composeOAuth over the same walk the error handler is built from. Neither schema name can be a Go type's name. Neither schema writes a boolean additionalProperties: CommandsFromSpec parses schemas as objects, and a boolean failed it. TestTheDocumentDeclaresTheRefusal checks the declaration at both kinds of address, and that the refusal on the wire carries every member the schema requires. The ErrorHandler and MarshalJSON comments still described the old envelope and a written instance member; they describe what is written. Co-authored-by: Hanzo Dev 8%Axtree f1713102de2aa0fa5b0fb8cfc3c2ba6cc0eed97f parent 8993ea96da9a3574995c01643e024c8b1d8659dd author Zach Kelling 1789148174 -0700 committer Zach Kelling 1789148174 -0700 Doc comments reach a service whose handlers are in package main zipdoc files an operation's prose under its package's import path. At run time pkgOf read the package off the handler's function name, and a built binary names package main's functions "main.", so the lookup missed: the document, the tool list and the CLI help carried no prose. Under go test the package keeps its import path, so every test passed. pkgOf now reads "main" as the build info path, which is the import path zipdoc wrote. TestProseReachesAServiceInPackageMain runs zipdoc over a package main service, builds it and reads the document the binary writes. It fails without the change. gofmt realigns one struct field in typed.go, and the WithStatus comment names the problem document instead of the envelope it replaced. Co-authored-by: Hanzo Dev Tsg8x=tree f3c070e5ddcdf693584bf5f7b3cab3384586f7d9 parent cda55906cfa4a6231a21a78559c64d768d2d5b77 author Zach Kelling 1789148174 -0700 committer Zach Kelling 1789148174 -0700 Remove three stray files from the root 2f5a387 added origin, rebase and 26ab3688408b38db62d9a92e46eba140d421db23. Each holds a single Co-authored-by line: the output of a mistyped shell command, not source. Co-authored-by: Hanzo Dev =+xOtree cfd0a46f260e99a84cc69924bbb95c6b74d5db6d parent 1175f459b76a41c6570ff42de1904d1615df0581 author Zach Kelling 1789086843 -0700 committer Zach Kelling 1789086848 -0700 Call the generator Layouts, not Codecs A codec is a runtime encode/decode step, which is the thing ZAP removes: a field IS its offset, and a read is a pointer into the bytes that arrived. Nothing here runs on the served path — Layouts reflects at BUILD time and emits constant offsets. Naming it for the layer it exists to delete told readers the opposite of what it does. LayoutOf already names one type's shape; this emits those as source. Co-authored-by: Hanzo Dev 8_xtree af882b205a3301d91c76981a5223b15b794f956c parent ff3a1fd2182e8410df9ebd989ddb09461cad371f author Zach Kelling 1789081695 -0700 committer Zach Kelling 1789081695 -0700 OnResult: the counterpart to Authorize, told what happened Authorize is ASKED before a handler and may refuse. Nothing is TOLD after one, which leaves a gap that no middleware can close: everything a middleware records is recorded about a REQUEST, and an in-process invoke is not one. An operation reached that way runs with no trace of having run — no trail entry, no metric, no span — and it is the door an operator on a pod uses. So the hook sits at the same seam, which is the one place every projection funnels through, and is told about all of them. A refusal is told about as surely as a success, because Deny returns through the same error it reads. It is told the operation and the outcome and NOTHING else. Not the output: a hook that could see the value would be a way for a response body to reach whatever the hook writes to, and every recorder in this estate promises it never reads bodies. Not the input either — Authorize already sees that, before the handler, where a decision belongs. Named returns made that possible and cost one bug on the way: binding the handler's result to the `any` return wraps a nil *Out in a non-nil interface, so a void op stopped answering 204. opstatus_test.go caught it, the result stays typed, and the comment says why. Co-authored-by: Hanzo Dev 2'xwtree d634a19b5232deb01d136c26f153dbd936db670d parent 264d3c25780daa012bd0b77dc71ae6e07e753ec5 author Zach Kelling 1789081685 -0700 committer Zach Kelling 1789081685 -0700 Darwin has no syscall.FcntlInt, so main did not build on a Mac The descriptor-passing change reached for syscall.FcntlInt, which exists in x/sys/unix and not in Darwin's syscall package, so every build on a Mac has failed since it landed. The last tag builds; main does not, which is the shape that gets noticed late. x/sys/unix is already required, so this adds nothing but the import. Co-authored-by: Hanzo Dev d;xitree da0c4c0b468ce14440c3d7a41191cbafee5b77bf parent 02f2e3da976ee03352a5609182fcfeb7a8780d5a author Zach Kelling 1788937414 -0700 committer Zach Kelling 1788937414 -0700 one runner label, one go toolchain The label names the platform, not the org, and the toolchain is 1.26.8 everywhere. Co-authored-by: Hanzo Dev s r?xtree d26006ad4ff42be4e30586e9d6bf9226d21c1078 parent 731d498dad1ab0def34863ed8f2f77d3c2efea63 author Zach Kelling 1788937020 -0700 committer Zach Kelling 1788937052 -0700 Carry file descriptors over unix connections A descriptor is not data: its number is an index into a table the peer does not share, so a byte stream cannot hand over a pipe, a console, or an already-open file. SCM_RIGHTS is the kernel doing that translation, and it rides the same unix connection peerOf already reads SO_PEERCRED from. Needed to carry a sandbox control plane. gVisor's urpc passes Files on 20 of its 22 call sites — exec's stdio, checkpoint restore, the memory file — so a transport without this cannot replace it at all. Refuses rather than half-delivering: an empty body would let the kernel discard a control-only message and lose the descriptors while the call reports success, and a non-unix connection would deliver the bytes without the files. Co-authored-by: Hanzo Dev _Fzx^tree 940402034d7f4eac6af2cc2921e3fd0976df4669 parent 88b93b8fae6039a683ab8a9a3f964b884983e5ff author Zach Kelling 1788818804 -0700 committer Zach Kelling 1788818812 -0700 Verify every plugin binary, and run the bytes that were verified A plugin host is where a service becomes an arbitrary-code-execution vector: whatever it starts runs with the host's authority — verifying blocks, signing, serving. Sum existed but only gated URL, so the case that looked dangerous was checked and the case that is was not. A binary read off disk is not more trustworthy than a downloaded one; it is the same bytes with the download already done by somebody else. Now every source takes the same path, and the check is worth something because what runs is what was checked: - The binary is COPIED into a directory only the host can write, and the copy is hashed and executed. Verifying in place and then running leaves whoever can write that file free to change it afterwards, and starting a plugin is an observable event, so they get to choose when. - Holding a descriptor to the original would not have closed that, which the test proves rather than assumes: a rename swaps the inode, but a WRITE keeps it, and a write is visible through an already-open descriptor. Only the copy puts the bytes out of reach. - The copy is executed through its own descriptor (/proc/self/fd on Linux), so no path is resolved a second time. It is reopened read-only first — Linux refuses to execute a file anyone holds open for writing. - A mismatch refuses. A host that logs and carries on has performed the check and kept the risk. What this cannot decide is where a trustworthy Sum comes from. A digest in the same config an attacker just edited proves nothing, so the anchor has to be something they do not control. For a network that already agrees on things by construction, that is consensus. L@Axdtree bb4c788b1dd3a73b41786fe08238cc53fdbadcdd parent bf40e7b3d632f38c4a10ee5b4970647d9edff1a1 author Zach Kelling 1788718499 -0700 committer Zach Kelling 1788718499 -0700 zipgen reads the schema it was refusing to project from The registry a projection reduces over came from Go declarations, so zipgen — which links no service — had an empty one, and every SDK, MCP server, CLI and docs page it wrote was empty. It refused rather than write those, and named a missing connection: a .zap schema, read into a registry. zip.ReadZAP is that connection. It parses with github.com/zap-proto/go/idl, which is the parser cmd/zapgen has always used and which is a package rather than a command as of that repository's v1.8.3; there is one grammar, not a second one written here to agree with the first until it did not. It answers with one app per declared interface, each carrying one op per method, which is the exact inverse of ZAPSchema taking any number of apps and writing them as one interface each. A file read and projected back is the same text, and there is a test that closes that loop over this package's own output. Two things stood between a declaration and an op. Go makes no named types at run time, so a struct built from a declaration carries the name it was declared under in a decl tag on its fields, and typeName is now the one place any projection asks a type for its name — without that, Ping and Pong of identical shape intern to a single reflect type and a method declared to answer Pong answers Ping. And a .zap field states an offset while LayoutOf derives one: every field is compared and any disagreement is refused, naming all of them. That refusal earns its place immediately, because the IDL assigns offsets by packing and this layout aligns each slot to its own width, so a hand-written schema with an i32 before a wider field describes a wire this process does not speak. An op read from a schema knows what it takes and what it answers and refuses to run, because a schema states a contract and the implementation of it is somewhere else. Co-authored-by: Hanzo Dev ʚ/xtree 879036c84293698702e8e9bcfcde9ca651543634 parent ddc11c181c6a2528a14c8f36698e14fafc94def1 author Zach Kelling 1788715778 -0700 committer Zach Kelling 1788715778 -0700 zipgen refuses to project an empty registry zipgen builds its app from flags alone, so the typed-op registry is empty and every projection of it is empty too: an SDK with no methods, an MCP server with no tools, a docs page whose operations table has no rows. Each of those was written out and reported as a success. It now refuses, and says what is missing. A registry comes from Go declarations today; reading one from a .zap schema, which zap-proto/go/idl already parses, is the connection that does not exist yet. Co-authored-by: Hanzo Dev 7KxBtree c7bc3e3321415329a316a791398a0fbfea5f14a1 parent b2a8053b8a769ec1f0e462bd9c6c2abe5de85de6 author Zach Kelling 1788644004 -0700 committer Zach Kelling 1788644004 -0700 Emit the ZAP runtime for C++ instead of porting it per chain ZAP decides what the bytes mean, so a second hand-written codec in a second language is a second answer to what a frame is. The C++ chains had two of them — one per chain, already drifted — because zip could emit an RPC client SDK from a schema but not the runtime that SDK reads and writes bytes with. CppZap renders that runtime: the reader, the builder, and the arithmetic, in one namespace-parameterised C++23 header. Its constants are imported from github.com/luxfi/zap rather than retyped, and its accessors are that runtime name for name, so the two can be checked against each other line by line. The promise it makes is the bytes, and the promise is a test result: TestCppZapKeepsTheWire compiles the emitted header and diffs its buffers against the Go runtime's over seventeen shapes — scalars, tails, growth, backward pointers, every list kind, flags, both versions — and TestCppZapReadsWhatGoWrote closes the loop the other way. A_Bxtree d4fbd011fb32e5cb0aa273a5c1bf51c991ea1b21 parent a9223189d5d1210fb8179940672b5e2a2683956b author Zach Kelling 1788557699 -0700 committer Zach Kelling 1788557744 -0700 feat(zipgen): add Rust and C++ CLI, SDK, MCP, and docs generator suite LP`xtree 5f8c75c3add08885dea1dd84253ddc4b25987b2d parent 478e06d1d4233d2ec98cb9d70177c5f3abaf47e8 author Zach Kelling 1788507425 -0700 committer Zach Kelling 1788507425 -0700 Give a ZAP socket the mode its config named SocketMode reached only the http:// transport. A bare address is ZAP — so the canonical SocketPath socket every plugin and peer is reached on went through zap-proto/http.Server, which takes an address, calls net.Listen, and never learns what mode was asked for. net.Listen creates a socket 0777 masked by the process umask, so that socket came up 0755 under the usual 022 whether the config said 0600 or 0666: a server that meant to shut the door was serving anyone on the host, and one that meant to open it to an attested peer was refusing them. A socket carries a mode only because something chmods it, and now one function does. bindSocket clears a stale socket, binds, and sets the mode, and both transports bind through it, so the fasthttp spelling that was already doing this for http:// and the ZAP one that was doing nothing become the same fact. The umask is the alternative and it is the wrong instrument: it is process-wide, so narrowing it around one bind changes the answer for every file the program writes. The window between bind and chmod is closed by the directory makeSocketDir creates 0700. An abstract socket is a name in the kernel rather than a file, so it has no leftover to clear and no mode to carry, and takes neither. Co-authored-by: Hanzo Dev &zxRtree af2a8f7266c47f8f8d955b706260443d4dafd644 parent 4d74af5e3d46108675cfa19e79744120879dddd2 author Zach Kelling 1788506197 -0700 committer Zach Kelling 1788506197 -0700 Authorization can hold an op, not only allow or refuse it The hook answered allow-or-error, so an operation that needs a person to sign it off had nowhere to go but a refusal. A caller told 403 stops; a caller told the request is held waits, and those are different futures. An Authorizer now answers a Decision — Allow, Deny or Approve, with the clause that reached it and the reason a person reads — resolved ONCE in the run() contract that op.invoke and op.direct both funnel through. The projections only render it, so all six agree without a branch in any of them: REST answers 403 or 202, the call plane the same two over ZAP, MCP carries the held body as content rather than an error because nothing failed, the CLI prints it, the graph reports it beside the field it was selected for, and a Go caller reads it off the error lane with HeldOf. An Approval has no Out and never will have one — the handler did not run — which is the whole reason it does not travel the value lane there. Clause, not rule. This package already spells an Authorizer "the rule" — App.rule, adopt, "two rules that disagree" — so the token naming which part of it fired needs its own word, and a rule has clauses. The error return survives for a genuine failure of the CHECK: an authority that cannot be reached has not decided anything, and answering 503 rather than 403 is what lets a client retry. The op carries the question rather than the app, because they differ. A composed child answers to whatever included it, and a mounted op has no local rule at all — so the document publishes the held body exactly where the seam would produce one, and a gated service's OpenAPI reads as the pair a generated client needs. Co-authored-by: Hanzo Dev r)xatree 8b717afc3df8794810226d254e24e2112ca7f338 parent 113e3df8a78ddf4f77769a923e8b7aeb4450b7a6 author Zach Kelling 1788476870 -0700 committer Zach Kelling 1788488162 -0700 feat(zip): support native Rust, C++, and Go self-documenting SDKs, MCPs, and @hanzo/docs - Add App.RustSDK() for full ZAP-native self-documenting Rust SDK with rustdoc - Add App.CppSDK() for modern C++20 self-documenting SDK with Doxygen - Add App.RustMCP() and App.CppMCP() for native Model Context Protocol tools & servers - Add App.DocsMarkdown() for @hanzo/docs MDX pages with Go/Rust/C++ tabbed snippets - Add cmd/zipgen CLI tool for sdk, mcp, and docs generation ׂxtree a0b6c70f90c1efcbd279ef76bf6594eac55b07b5 parent 95ecc97864c85fcff6d729de46f8a4a5a75b86da author Zach Kelling 1788479568 -0700 committer Zach Kelling 1788479568 -0700 Name the local-call test's types after the test M$xCtree 10d9ecdb3457c7e19f18ea888ae5d7c601d1ae6b parent 2b28d9af703654980ef451a2c6276045950db0b0 author Zach Kelling 1788479504 -0700 committer Zach Kelling 1788479504 -0700 Let a server open its socket and tell a local call from a peer A server that scopes every read by what the kernel says about the peer needs two things the 0600 socket used to do for it: a mode it can open, because the attestation is now the boundary and the mode is only the door, and a way to tell a call the process makes to itself from one that arrived with no peer to read. 7Sx:tree 57658347e63801a2d5a89fed9a0da6c269c68f09 parent 5bf4dd35faddd64669f370345c2279262f8aa4ae author Zach Kelling 1788479199 -0700 committer Zach Kelling 1788479199 -0700 Attest the pod a unix peer runs in SO_PEERCRED names the process; the kubelet's cgroup names the pod it was placed in. A server on a socket shared across pods needs the second to scope what the first may read, and neither is a value the caller states. *x-tree 61f814f62697c0ee14de48fd32582de4ce3a0a8e parent b91ba940b536b05d2270a613f6e22d1c98207a71 author Zach Kelling 1788338732 -0700 committer Zach Kelling 1788338732 -0700 chore: symlink AGENTS.md + GEMINI.md + CLAUDE.md -> LLM.md Co-authored-by: Hanzo Dev Y=wxztree 552142e39c526c18a8b6fee79298a52603860fe2 parent fe4bc7dce8ae9d70862b54b6ae8f7aaafcc93764 author Zach Kelling 1788292559 -0700 committer Zach Kelling 1788292732 -0700 An id crosses in the Go SDK, on the codec the SDK writes for it The reflective encoder refuses bytes_fixed[N] — an ids.ID is [32]byte — so that an id forces its type to state its own wire. The SDK read that refusal as a fact about the op and reported a gap. It is a fact about the ENCODER: the layout is right, and Codecs already writes the two methods that carry an id inline from those same offsets. So the SDK writes one. Not a second emitter — the same one, asked for names through a seam, because two emitters would be two wires and the second would be spoken by nobody. The restatement is the declared struct field for field and in order, so its layout IS the declared layout; the codec states the declared offsets against this package's names. Which types get one is not all of them. Wire is checked at the root of Marshal and Unmarshal only, so a parent encoded reflectively reflects over its children too. That makes the set closed upward, and a codec calling MarshalZAP on what it nests makes it closed downward. One id under an op's In or Out states the wire for that tree; a tree with no id keeps the derived wire it had, and its generated source does not move. Two guards, because a wrong offset is worse than a gap: the restatement is checked against the layout it claims — same fields, same order — and a mismatch is a gap, never a guessed layout; and spell preserves reflect.Kind, which is what makes the widths identical. Over node's nine apps: 43 of 94 ops reachable in Go, now 91. The three left are an interface, which names no type. Every op is still a method XOR a gap. The document, the tool list, the command tree and both HTTP clients are byte- identical across the change. |]x/tree 77d24a56b65367bfd527436b6277459c79a71ef5 parent 158735fcf08ac496419267fc1ddb9544f3b37abf author Zach Kelling 1788289084 -0700 committer Zach Kelling 1788289084 -0700 A refusal travels up, instead of being written as an empty struct This projection promises that an op whose value cannot cross gets no method, because a client that compiles and lies is worse than one that says the operation is out of reach. Three ways it broke that promise, all found generating clients for node's ninety-four ops: A field whose own type had no wire form was replaced by struct{} and the op kept its method. The call succeeded and the payload was gone. node's admin, info and platformvm all had []struct{} where a value should be. A field that cannot cross now refuses the type holding it, which refuses the op, reported once at the field. On an EMBEDDED field that substitute is not Go — an embedded field must be a name — so the package did not parse, SDK returned an error, and the service got no client at all. One op of xvm's ten has that shape. And the memo that remembers a refused type answered "no" and said nothing, so the SECOND op reaching it had no method and no gap; the only way to notice was to count. platformvm's get_tx_rewards vanished exactly that way. The refusal is remembered with its reason and reported again against each op that meets it. Two causes join the vocabulary: nested, and embedded. Co-authored-by: Hanzo Dev ܚOxtree 4f98ac4c952d22dc51b96171d800e814cb17bb97 parent add82e60863acfe42ffb4577eb07c895265a9113 author Zach Kelling 1788288569 -0700 committer Zach Kelling 1788288569 -0700 A path parameter arrives as the caller wrote it A URL carries a segment percent-encoded — it has to: a space, a slash, a percent or anything outside the unreserved set has no other spelling between two slashes. The router matched on the raw text and handed that same text on, so a handler addressed at /v1/secrets/café was given "caf%C3%A9" and looked up a name nobody has. Measured against a live listener before this: every path parameter carrying such a character arrived encoded, in the typed binder and in Ctx.Param alike. Every client encodes, because there is no other way to write those characters, so no client could make such a value round-trip and the address was unusable for anything but a bare identifier. Text that is not valid encoding is passed through rather than refused: a lone percent is a malformed URI, but the address it names is still the address the router matched, and failing here would turn a lookup that finds nothing into a 500. Found by running a generated HTTP client against a real service. Co-authored-by: Hanzo Dev c$Hxptree 871742637322428a8cc21577130e14507d3e4d62 parent 33ebd6abcadde0f5da37de6aaa9f55a4283df030 author Zach Kelling 1788070991 -0700 committer Zach Kelling 1788070991 -0700 An optional id is read back, instead of panicking on the nil it was The generated codec two directions disagreed about a POINTER to a fixed array. The writer guarded the nil and wrote nothing; the reader emitted copy(x.F[:], …) regardless — through a pointer on a value that had just been allocated, so it was always nil. Every read of a type carrying an optional id panicked at the far end of the plane, which is where a panic is a dropped connection and not a stack trace anyone sees. The P-Chain L1 validator is exactly that shape: validationID is a *ids.ID, so get_validator and the L1 arm of get_validators could not be read at all. An inline slot has no null — the writer leaves an absent pointer bytes zeroed — so all-zero is what absence looks like coming back. That is already the rule the pointer SCALARS read by (a zero u64 reads as absent), and reading it here is what makes the two directions symmetric rather than adding a second convention. ˅TRx,tree 64c90d1a6300d84709ac48180bf1370563da379c parent 8c16a7df62fd9031f38ab97b83b6db079d94cb05 author Zach Kelling 1788070562 -0700 committer Zach Kelling 1788070562 -0700 Prose is filed under the package that declared it The documentation map is one map for a whole process, keyed by an address — and an address is unique only within the app that serves it. A node runs twelve chains on one binary and the P-Chain and the X-Chain both answer GET /height, GET /block, GET /tx, GET /utxos, GET /balance and POST /tx: six addresses where whichever init() ran last published its prose for the other chain routes. Nothing failed. The document and the MCP tool carried the wrong sentence for the right route, which is why it survived every test until someone read the output — and renaming a path to dodge it would have been the wrong repair twice over, since the mount already tells the chains apart and every future chain would inherit the dodge. So the key carries the declaring package, read off the handler itself at registration. It is the namespacing the schema registry already does for named types: who declared a thing is a property of the code. An unqualified key is still read, so a generated file written before this is still correct for the single-app process it was written for. ʢDxKtree afa867a069574b662c4c5891a962497f7fcacd08 parent 9d277517b9f83efe64d8d439dd242f05e67600b5 author Zach Kelling 1788069751 -0700 committer Zach Kelling 1788069751 -0700 The query a client writes is the one the binder reads queryOf was the third copy of one rule and it had drifted the same way the document had. It rendered a JSON object one level deep and verbatim, so a list went out as ?ids=["a","b"] and a record as ?start={"utxo":...} — neither of which bindURL reads. The CLI and every caller built on Remote sent arguments that arrived empty, and the op answered 200 about nothing. It is now the binder inverse: a list is comma-joined, a record leaves are named through it, an absent value is left out rather than written as the four characters of null. Exported as Query, because a client should not have to know any of that — the spelling is derived from the op own In, which is the point of having the In. The test is a ROUND TRIP through a live op rather than an assertion about a string, so a change to either half that breaks the other fails here. muYMx-tree a3f27f281e5d2b6fd4aa76bd3e294b936ba64594 parent 42e50d17b9a0ed22482c50428495c7eae8910fd7 author Zach Kelling 1788069139 -0700 committer Zach Kelling 1788069139 -0700 The type decides how a URL value is read, before its kind does A written form is usually carried by a NUMERIC kind, and deciding by kind first put the rule out of reach of exactly the values that need it. A P-Chain height is a u64 whose reserved value is spelled "proposed"; an encoding is a u8 spelled "json". Both met ParseUint, both failed, and both left the field at zero — so a request for the proposed height was served as height 0 and a request for JSON was served as hex, each with a 200 on the answer. Asking the type first is also encoding/json own precedence: a named string with an UnmarshalText is decoded through it and not by assignment. Matching that is what lets a URL and a JSON body on the same struct read one word one way, rather than a field meaning two things depending on which side it arrived from. So a type that states how to read itself from text gets that reading, and what is left is decided by kind. The default branch goes with it: nothing reaches the switch that has a written form to ask about. 0Ux]tree 46d9860265dd7d965515352a16c2b6733c95e41c parent 3fff376dfd2443e2d9cc4bda303b6671aafdf279 author Zach Kelling 1788066933 -0700 committer Zach Kelling 1788066933 -0700 A record's leaves are named through it, and a URL can write them A pagination cursor is one field holding two — an address and a utxo id — and a URL had no spelling for it, so a read whose input nests a record could not be served on a safe method at all. The choice was a GET that silently dropped the cursor or a POST, and a POST is a read that has to be authorized. A leaf is written under its record's name: `?startIndex.utxo=`. Only under it — a bare `?utxo=` still binds a top-level utxo and never a nested one, so an input that nests a record names its target explicitly and an authorizer reads the target the caller wrote rather than one guessed out of a sub-struct. urlFields walks the same way, so the document publishes every dotted name the binder fills and no name it does not. A struct with a written form of its own is not a record here: a time and an id are one word in a URL, and urlSchema already says so. A pointer record is allocated only where the URL named something inside it, so a cursor nobody sent stays absent rather than arriving empty. The descent stops at the keys a caller wrote, which is what bounds it on a self-referential input. .gוWxutree 2a7d30a8b93272635d9d6b42ead397b6f09bbe33 parent 8e4f5975b24c96f1d79bbbfc4cd047246ed0c835 author Zach Kelling 1788066671 -0700 committer Zach Kelling 1788066671 -0700 A repeated argument rides a URL, and the document names what the binder fills Two halves of one rule, and the second is what made the first safe to rely on. A URL carries one value per name, so a repeated argument is written as one value with commas — style: form, explode: false, the spelling the document already publishes for it. The binder had no case for a slice, so an op taking a list of ids answered 200 about an empty list. Each element is written by setScalar, so a list of ids says nothing about ids a second time, and a []byte is not a list here: encoding/json spells it as one base64 string. urlFields had the kind switch written a SECOND time, and the second one drifted the moment setText taught the binder to read an id. The binder filled a parameter the document did not name, which is the same disagreement as before with the sides swapped — a caller reading the document had no way to know the argument existed. Both now read urlSchema, so what is published and what is bound are one answer. A type that reads itself from text is a string there, whatever it is made of: describing an id by its 32 bytes published an array of integers for a value nothing spells that way. VⓔExTtree f0f68e6045c16c52600143457e1f77d48dbc7514 parent 6e88437944e45fb5b507d101586e5c6914aa9d9c author Zach Kelling 1788066168 -0700 committer Zach Kelling 1788066168 -0700 A value that reads itself from text can ride a URL An id is an array of bytes and a URL carries characters, so the binder's kind switch had nothing to convert into: a route addressing a resource by its id published a query parameter, bound nothing, and ran the handler on a zero id. A wrong answer with a 200 on it. The type had already answered the question. encoding.TextUnmarshaler is precisely "here is how to read me from the characters a URL can carry", so the binder asks, for the kinds nothing else could carry. The basic kinds are decided first, so a named string that also reads text keeps the reading it has always had, and what is left after both is a record rather than a value — a slice, a map, a struct with no text form — which stays untouched. Reading is all-or-nothing: the value is built beside the field and moves onto it on success only, the same contract the numeric cases keep. {z#x3tree c7febb1604c627031ef492d37ccc5e38df5a2193 parent a8d7e86e0c6063a03bcb1c96394d1e962e996590 author Zach Kelling 1788055299 -0700 committer Zach Kelling 1788055299 -0700 A codec says whether its types already answer for themselves A generator writing into one module reads types from several. The ones it cannot write to are only a problem while they are still silent, so a Codec now reports whether every type in it already states its wire — which is what tells "another module has to release" from "another module already did". (g&(xztree 303da0d24f9331a8825eb6ff4e619ef9e16653fa parent 7f532960b454c3eefd2bf27e3f9fc3be503d644f author Zach Kelling 1788054954 -0700 committer Zach Kelling 1788054954 -0700 The emitted file declares no name of its own A generator cannot know which identifiers a package has free, and github.com/luxfi/utxo imports a package called wire. So the assertion is an inline interface literal, and the two helpers a codec needed are now block-local: the empty object builds where it is written, and a narrow list element is zero-extended in the loop that reads it. Same bytes, held against the reflective encoder as before. 5xtree 32245e28f3f15f5cf80b9007575c47f37bf794f1 parent e8fced4a1116c52ce765006c6813b3410dd121aa author Zach Kelling 1788054738 -0700 committer Zach Kelling 1788054738 -0700 A message with no field to read still parses An EmptyReply has no slot, so its decoder read nothing and Go refused the root it had taken and never used. Take the root only where a field reads it; keep the parse either way, because an unreadable message is an error and not an empty value. pN&*xRtree 57726b15986a9d52b0b3fe0bcbbee478fecc50f4 parent 3f982c4a0b3e011d69a0bc9a059fb996296842d7 author Zach Kelling 1788054567 -0700 committer Zach Kelling 1788054567 -0700 A pointer to a list, and an import only where a name is spelled Two shapes the fleet's own types hold that the fixtures did not. A *[]PrimaryDelegator is an optional list — absent means the caller did not ask for delegators, and its length cannot be asked for through a nil pointer. And a message whose only field is an id spells no type name at all, so taking the import for it left one unused and the file would not build. Both held byte for byte against the reflective encoder. Q+xItree e91ecd4f4c66e3782115906fd29fcb940b5b2ca9 parent 17589a6d6d8e781c7830fc9b3c5193ec8cd505d0 author Zach Kelling 1788054428 -0700 committer Zach Kelling 1788054428 -0700 A value with no slots crosses as bytes, not as a method time.Time and netip.AddrPort have no exported field, so the layout gives them no slot and the reflective encoder writes a complete empty object for them. A generated parent cannot reach for a method there — the type is in a module nobody here can add one to — so it writes the same bytes inline. Held byte for byte against the reflective encoder, inline and as a list element, so the wire is the same one either side of the change. 4eAxtree f52b92fa984ca5edc75f58b0c2af620765a6eb8e parent 08bcbd9b43e613ad943de16602cc3837f8280e7d author Zach Kelling 1788054044 -0700 committer Zach Kelling 1788054044 -0700 A type can state its own ZAP wire, so an id can cross zip.Codecs renders MarshalZAP/UnmarshalZAP from LayoutOf — the third reader the derivation's doc already named, after the plane that encodes against it and the .zap schema that states it. bytes_fixed[N] is refused by the reflective encoder on purpose: an id is the case that should force a type to declare its own wire. Until it does, a reply holding an ids.ID cannot cross the plane at all. Wire is consulted at the root of Marshal and Unmarshal only, so the emitted set is closed downward and a parent reaches each nested value by its method. The emitted file restates Wire rather than importing zip, so a leaf module states its wire on the ZAP builder alone. The bytes are held equal to the reflective encoder's, field for field, which is what lets a codec roll out one pod at a time. gY_xtree 948409ed95ffbff1f6c367e0579da37cc58bfc0f parent c8388b60b70e5f759aa0104b922a26310d03eed9 author Zach Kelling 1788052264 -0700 committer Zach Kelling 1788052286 -0700 The ZAP door says who is at it MCPConfig.Source and MCPConfig.Addr were each complete and did not compose. serveMCP handed zapmcp.Server the bare App.MCP, so nothing on that path ever stated a caller; App.list returned early on CallerOf(ctx).Org == "" and served only the build-time bytes. The tools a Source exists to supply were absent on exactly the transport that has no HTTP request to carry a gateway assertion. It presented as success. Measured on a live host composing an Open plugin: the HTTP door answered four tools for X-Org-Id: acme and ran acme_own; the ZAP door, same process and same second, answered three and refused acme_own as an unknown tool — while logging per-caller: true and probing healthy. MCPConfig.Identify is this deployment's answer to who is on the connection. It composes rather than configures: zapDoor is App.MCP with WithCaller bound in front, the same wrapper a deployment writes by hand around a zapmcp.Server of its own, so there is still one door and one way to say who is at it. The caller comes off the connection (zapmcp.Conn) and never off the frame, which the caller wrote. Addr over a per-caller half with no Identify is refused at Listen, before anything binds. A door that serves half its tools while every signal it emits reads healthy is not a configuration to accept quietly. Ub@xtree 7bfe6729934c0a2b2c71b19f54153c9e8506fc53 parent 392b30b6315ccaee38107816091294a1a644a405 author Zach Kelling 1788051820 -0700 committer Zach Kelling 1788051820 -0700 v1.36.21 is retracted: it does not compile mcp.go calls networkOf, which was staged in a file the commit left behind. It built locally because the working tree held both halves — which is the whole lesson, and the same one a mis-cut tag taught earlier today: verify the commit, not the directory it came from. The tag is NOT moved. A version is a permanent address and a consumer that already resolved to it must keep getting the same bytes. Retract is how a Go module says "published in error" without rewriting history: the resolver stops choosing it, `go list -m -versions` stops offering it, and anyone pinned to it is told rather than silently carried somewhere else. v1.36.22 is the re-cut. Verified: a throwaway module requiring .21 fails with `mcp.go:817:33: undefined: networkOf`; the same module on .23 builds clean. ^Ixotree a431f8c57e2f0e60b669e69e1172b2ac43705e71 parent ca57a831ffb490855c9ba26238d6ea151fe3bfff author Zach Kelling 1788051333 -0700 committer Zach Kelling 1788051333 -0700 A right layout is not the same as a value that crosses App.SDK asked LayoutOf whether a type had a wire form and took yes for an answer. A fixed array passes that check — it has an offset and a width, and the schema states it correctly — and the reflective encoder still refuses it, because the type is expected to declare its own wire. So the generated client offered the method and the call failed on the wire, which is precisely the failure this projection exists to remove. It covers most of a chain node's surface: ids.ID is [32]byte and ids.NodeID is [20]byte, so nearly every reply is in this class. It is not fixable by generating harder. The declared type's MarshalZAP lives in the service's package, and restating the field as [32]uint8 here restates the bytes and not the codec. The op is out of reach until the type declares its wire, and saying so is the whole answer — the same fact Schema.Coded already reported, now read from the same layout. (0?xtree 86a721cd10769092c1144e05c373acf7e5b6a833 parent 5381d52993d211258eb34cf6c74a30cd9517207f author Zach Kelling 1788051178 -0700 committer Zach Kelling 1788051178 -0700 The doc said five projections and no generated client There are eight, and one of them is a generated Go client — so the paragraph arguing that a generated client is always the wrong answer was sitting one directory from the generator. It was right about the case it was written for and wrong as a general rule. Inside the fleet a caller imports the op's In and Out and Call is the answer. A published SDK's users cannot: they do not link the service, and linking it to reach three types drags in its whole dependency graph. Both are now stated, with the line between them. Also records why that generator reads the registry rather than the document: field order, json:"-" and embedded structs are three shapes a Go type has on the JSON edge and does not have on this wire, and each one moves a field without failing. c]3'x{tree 2cd89321f45bb9f4f73846e84f351838b9262c6c parent 17dca3077e3ac6035995ffd2e3dbf59bf20edae2 author Zach Kelling 1788050647 -0700 committer Zach Kelling 1788050647 -0700 Finish the rename at the call site that was left behind NetworkOf was exported and every caller updated in the working tree, but only transport.go was staged, so main shipped a package that does not compile: mcp.go still calls networkOf, which no longer exists. The local build passed because the local tree held both halves. What was pushed was never built — the check has to run on the commit, not on the directory it came from. L*x[tree a93ba91ecd4f832f7c9be36f170127d0ea727b19 parent 158ce60ada9a4d45d9b3d8bcd0b144e0a23e0ed9 author Zach Kelling 1788039578 -0700 committer Zach Kelling 1788039578 -0700 Reading a network off an address is a rule, not a detail A filesystem path is a unix socket and anything else is host:port. That reading was unexported, so a client outside zip that dials one of these addresses had to make it again — and zapmcp.Dial wants the network as a value, so anything reaching an app's MCP door needed exactly that. A second copy of the rule is a place where a socket path becomes a hostname. One name, exported, and every internal caller uses it. j7qxtree 8c804aa1e72dadd720d889f691015b9d39c55a94 parent db714565fc7d6ac0d5a5ce8f76a2298f8a47a991 author Zach Kelling 1788039081 -0700 committer Zach Kelling 1788039404 -0700 The registry renders the client that calls it A hand-written client sends a method string somebody typed and a struct somebody kept in step, and neither is checked: the Lux SDK addresses eleven X-chain methods the node does not serve and sends chainID where the node reads netID, with go build and go test both exiting 0. So the registry renders it. App.SDK(pkg) is the eighth projection: one method per op, calling over the op-call plane, with the op's own id as the address. The name cannot be wrong because it is not written down. It reads the REGISTRY and not the document, and that is the whole design decision. A Go type has three shapes on the JSON edge it does not have on the ZAP wire — properties have no order where a layout is declaration order, json:"-" is absent from one and a slot on the other, and an embedded struct is flattened by one and nested by the other — so a client generated from the document lays its fields somewhere else and reads every value after the first from the wrong offset. The generated struct is therefore the declared struct, field for field, in order, with only the type names changed; the layout is identical by construction rather than by a rule to maintain. An op whose In or Out has no wire form gets NO method, and says so in Gaps. A client that could be called and could never succeed is worse than one that reports the operation as out of reach. A number in the document now states its width and sign as well as its type. "integer" alone made every generated field a guess, and a guessed width is not a mis-printed value, it is four bytes where eight were laid. \xbx tree 682327137acf569fe2e08a92afdda5f62a27d9cb parent 7cc9e8fdc86c5a26c2f3fd7195631fa8b45d0b84 author Zach Kelling 1788038983 -0700 committer Zach Kelling 1788039038 -0700 An op kept out of the contract is kept out of the tool list Undeclared promises a route serves "and so in none of the projections built from it: the OpenAPI document, the MCP tool list, the CLI commands, the by-name call plane." The MCP half did not hold. composeTools reads the registry, which is every op that registered, while the undeclared fact rides the route entry — so a TYPED op registered through Undeclared was still offered to an agent. It is the projection where the miss costs most. A document nobody reads listing a dead address is untidy; a tool list is what an agent CALLS. Undeclared's own comment names the danger from the other side — "an address that DOES something and hides is a door nobody can find and nobody reviews" — and this was the inverse: an address that asked to be hidden and was handed out. Invisible until now because the only test covered an UNTYPED handler, which never reaches the registry at all. The new one registers both kinds on one app and asserts the declared tool is present and the undeclared one is not. Read from the plan rather than from Declaration(), which calls prepare(), and prepare is what installs this door — asking it here hangs. The fact lives on the route entry either way, which is what lets it survive composition, so this reads the same entries Declaration reads and stops one step earlier. }#JxStree 09eec7c942f6adb6227ccedf32f1b60745c1d350 parent 4b3ce47431e26d492119f91685bfc85e241fcf25 author Zach Kelling 1788038861 -0700 committer Zach Kelling 1788038861 -0700 A list element keeps the width it was declared with A field of type [N]byte lays out as bytes_fixed[N] and the schema states N. The same type as a LIST element stated bytes_fixed[0]: sliceElemOf copied the element's kind and its nested layout but not its length, and LayoutOf then spelled the element with a literal zero. Nothing failed — the layout was accepted and the schema was published — so what a peer read was a contract to take no bytes per element, and a codec generated from it would have done exactly that. This is the shape every chain reply is full of: a list of ids. It is seven ops on a Lux node alone. The refusal in that position was wrong too. Reflection does not carry bytes_fixed anywhere, on purpose — an id is the case that should make a type declare its own wire — and a field says so, naming MarshalZAP. An element instead reported that a kind had no wire form, which is true of nothing and tells the reader nothing. It now gives the same answer a field does. A+=x-tree 4f79430e93617c22ecdeac780d85677690fba2fb parent dc49d56131949ac2720cd39610fdb6085b8d00f0 author Zach Kelling 1788037553 -0700 committer Zach Kelling 1788037553 -0700 A number in the document states its width and its sign "integer" does not say whether a field is one byte or eight, or whether it is signed. JSON survives that ambiguity because a number is self-delimiting, and the document was written when JSON was the only thing generated from it. It is not any more. One of the clients generated from this document speaks ZAP, where a field IS an offset and a width — so a generated type that reads a uint32 as an int64 does not merely mis-print a value. It takes eight bytes where the service laid four, and every field after it is read from the wrong place. The failure is silent and total, and it starts in the document. The names are OpenAPI's own where it registers them (int32, int64) and the obvious extension where it does not. FXL-TxMtree 566e36437d86ff314e9baa52551822a9a7003703 parent f06eb609cf19d55dc36a5bf1680dcb019586f72c author Zach Kelling 1788034952 -0700 committer Zach Kelling 1788034952 -0700 The schema states what it does not carry The projection tracked five registers of cost — blocked, dropped, opaque, coded, renamed — and rendered none of them. So the file was true about every op in it and silent about the ones that were not, which is the failure the design was written to avoid: a reader learns the contract and not the cost. They are written into the same file rather than beside it. A second artifact is a second thing to keep in step, and the point is that the cost arrives in the same breath as the schema. Ordered by how quietly each one hurts. `dropped` is first because it is the expensive one: the field is in a type the layout accepts and its VALUE does not cross, and nothing fails. `blocked` is loud — the op is simply absent — and therefore cheap. Then `opaque`, which crosses and arrives without its name; `coded`, which this schema states correctly and the reflective encoder will not carry; and `renamed`, where the IDL's lexer cannot spell the id every other surface uses. On the fleet this immediately named a real one the schema had been hiding: a list whose element type crosses as an unnamed nested message. fhxvtree ed65029ff73acaad3b3c2c11b33eccd8f08c0411 parent b58ef92b16cb2015a60449ee50a9b435450176c1 author Zach Kelling 1788034572 -0700 committer Zach Kelling 1788034572 -0700 A type that contains itself is refused, not fatal layoutOf stores its answer AFTER deriving it, so a type reached from its own field asked for a layout it was in the middle of computing and recursed until the stack ended. Four fleet apps carry one — agents, amqp, kafka and zen — and each killed the describe with `fatal error: stack overflow` rather than saying what was wrong. A deeper stack would not have helped. A ZAP field IS an offset and a width, so a type containing itself has no bounded width and there is no layout to derive. The remedy is the one this package already applies to a map or an interface: refuse, and name the type. The cold path is now guarded — the in-progress set is reached only when the answer is not cached, so a served call never takes the lock. It is a lock rather than a plain map because derivation happens on many goroutines at once and a shared map would be a concurrent write; the tests run under -race, and one of them derives from 32 goroutines. Three properties the tests pin, each of which was a way to get this wrong: the refusal is REPEATABLE (a failed derivation must not leave the in-progress set dirty, or the second caller gets a different answer); a refused type does not poison the ones beside it; and the reason is the cycle rather than whatever error the recursion happened to end on. Removing the guard turns the first test from `ok` into `stack overflow`, which is how I know it is the guard doing the work. G}x/tree 05c2d3cd8dfb9e1e07b798897e5d4a2d5fa2af1f parent a8d7dbbea3fdef75abd4bb8e1e67d04625f4e0ec author Zach Kelling 1788034155 -0700 committer Zach Kelling 1788034155 -0700 The ZAP schema is a projection, and the only one that can refuse The typed-op registry already produces the REST routes, the OpenAPI document, the MCP tool list, the CLI, the op-call plane and the GraphQL schema. This adds the seventh: the .zap IDL a peer needs in order to speak the binary wire without holding a copy of these Go types. It is different from the other six in one way that matters. Every other projection can describe anything — JSON Schema has `{}`, GraphQL has a JSON scalar, the CLI has a string flag. Each of those is a way to write down "I do not know what this is" and carry on. ZAP has no such word: a field IS an offset and a width, so a value the IDL cannot name is a value that cannot cross. So this projection answers with two things, the schema and the list of ops that are not in it and why. A projection that emitted the struct with the awkward field quietly dropped would publish a contract the wire does not honour. Offsets come from LayoutOf — the encoder's own derivation — and not from a second computation here. That is not a preference: a first draft computed them independently and disagreed with the live wire on two counts, packing where the encoder aligns and four bytes where it writes eight. plane.Txn.CreatedAt is at @40 and the draft said @36. A schema is worth nothing if it describes a wire nobody speaks, so there is one derivation and the emitters consume it. The prose is the handler's own doc comment, read from the registry cmd/zipdoc fills — the same sentence the OpenAPI operation and the MCP tool description carry. One sentence, written once, in every projection of it. The interface takes the app's name. An ordinal survives only where it is the truth: several unnamed apps in one file, which is a fleet compose and not a subset. ̺3pxtree 0fab60fc4f7b15d9399ae2cdf2b900e6c4c06cd5 parent a94cfe4208896b98dba89a84e0cc16ed9fa7441f author Zach Kelling 1788018863 -0700 committer Zach Kelling 1788018863 -0700 The layout is derived once, and a schema and a generator can read it Three things need to know which offset a field takes: the encoder, a .zap schema generated from these types, and a code generator emitting the MarshalZAP a type declares. Derived three times they describe three wires and only one is spoken. LayoutOf exports the derivation the encoder already runs, so the other two read it instead of re-deriving it. Two details a second derivation gets wrong, and both were measured on live types before this was written: offsets are ALIGNED, not packed. A field begins at a multiple of its own width, so a bool at 0 puts the string after it at 8, not at 1. a nested value is EIGHT bytes and its IDL type is `bytes`. writeStruct carries it through SetBytes as a complete ZAP message in an {offset,length} slot, not through SetObject's four-byte relative offset. Four moves every field after it — on plane.Txn, CreatedAt goes from 40 to 36. TestTheLayoutIsWhatMarshalEncodes is the gate, and it compares the layout to the BYTES rather than to a table: it encodes a value and reads every field back at the offset the layout states, so a wrong derivation cannot pass by agreeing with a second wrong one. bytes_fixed[N] is now laid out and still not encoded. The layout is what a schema and a generator need; the reflective codec refuses it in both directions, with a message naming the remedy. Making reflection more capable is the wrong direction here — an id is exactly the case that should force a type to declare its own wire, and a type that has done so never reaches that line. ڧsxItree 6c7df06551238288f7dcdbda5403531601de87e0 parent 413d9863cbc3165e7749c066171717c6b4ccc0af author Zach Kelling 1788018504 -0700 committer Zach Kelling 1788018504 -0700 A type that owns its wire is not reflected over zapenc caches the LAYOUT and re-derives nothing, but it copies the fields by reflection on every call: reflect.ValueOf, a builder sized by guess at lay.size+256, and a walk of the struct. The answer to all of that was fixed the moment the type was declared. So a type may state its own wire form — MarshalZAP/UnmarshalZAP, the two methods a hand-written ZAP codec is — and Marshal and Unmarshal take that answer before they reach for reflect. Both methods are required together: one alone would encode from generated offsets and decode by reflection, two answers to where the layout lives, and they would disagree the first time a field moved. Measured here, on a page of a hundred rows read back: reflective 9842 ns/op 5136 B/op 103 allocs/op view 154 ns/op 48 B/op 2 allocs/op and the shape matters more than the ratio — the reflective decode is O(rows) because it materialises every one whether the caller reads it or not (1003 allocs at a thousand rows), while a view is 2 at every size. On a three-field value the write goes 147->103 ns and 440->200 B; the remaining allocations are the shared builder's, not this package's. It is also the only way to carry an id. A fixed-size array is refused outright here, so bytes_fixed[32] — an ids.ID, in nearly every reply the Lux platform chain gives — cannot cross this plane at all today. A type implementing Wire writes it inline through SetBytesFixed and reads it back as a slice of the buffer that arrived. That refusal is also the proof. The test encodes a value carrying [32]byte and [20]byte through Marshal and back: reaching reflect would fail, so arriving at the far side is the assertion, and the control is the identical field list with the methods removed, which still fails. TestTheTwoPathsWriteTheSameBytes is the other half — the generated bytes are the reflective bytes, so a type that gains a codec does not gain a new wire and a rolling deploy reads one message. ULtx@tree 69604e6bea7dbd4ddd74a267eec9b580a28160ec parent 67f15f7a4141c52b08c74ff6b084dd63848fca3b author Zach Kelling 1787990576 -0700 committer Zach Kelling 1787990601 -0700 A type that writes its own JSON can state its own shape schemaOf refuses to describe a marshaler by its fields, and it is right to: the fields are not the wire form. json.RawMessage proved that. But the only thing it could then say was `{}`, and `{}` is true and useless — every such field reaches a generated client as an untyped value. time.Time was the exception, hardcoded here, because its output shape is documented. The generalisation is to let the type say it. The bytes and the schema are the same fact about the same type, so they are declared together, next to MarshalJSON, rather than guessed in this package or kept in a table this package would have to maintain. type SchemaDescriber interface{ JSONSchema() map[string]any } Checked on the value and on the pointer, since MarshalJSON is usually written on the pointer. A nil answer is not a shape and falls back to `{}`. The map is copied before it is returned: the document is assembled by mutation, and a shared map would leak one field's description into every other field of that type — the test asserts exactly that. The case this exists for: Lux node's platform and xvm replies carry 236 fields whose types write their own JSON — quoted decimals (a JSON number is a float64, so a uint64 above 2^53 does not survive one), ids, encodings. All 236 publish as `{}` today, so the document is not yet worth generating an SDK from. Those types can now say `{"type":"string","pattern":"^[0-9]+$"}` once, at the declaration, and every field of that type is described everywhere. time.Time keeps its existing answer, and a marshaler that states nothing keeps `{}`. Full suite green. ڀYx`tree 49b47b06eec9f1c51228f8c36a2c34f2845ef0e1 parent 301d946ff9802eff7b2603daa38029c7af6d6035 author Zach Kelling 1787984524 -0700 committer Zach Kelling 1787984524 -0700 a plugin that will not start says why Running=false means "deployed but down" and Disabled separates a maintenance stop from a crash. Neither can say WHY, and for a LAZY plugin that was the only trace there was. An eager plugin that will not boot fails at Load, in front of the caller. A lazy one cannot: its mount succeeds with no process behind it — that is what Lazy means — so the start happens on the first request, inside the child, long after anyone was watching. The host logged one line and kept nothing, and the route answered 503 "no instance running" for that request and every later one. So Running=false could not be read: a lazy plugin nobody has asked for yet reports exactly what one whose every start dies reports. A host could answer {"status":"ok"} with nine of its surfaces permanently 503, which is what api.hanzo.ai did. Status.Error is that missing fact. It is DERIVED against cur rather than cleared on success — an instance becomes current in three places, and a clear that must be remembered at all three is a clear that will be forgotten at one. A plugin that has never been asked still reports nothing, because cold is not an error and must not read as one. Co-authored-by: Hanzo Dev I[xNtree ca436ff5b45bb5d44efc8f3a91a4c858fd1e61d2 parent e30283cb0583d46984f0329a5b50ea1b65b2af23 author Zach Kelling 1787684448 -0700 committer Zach Kelling 1787684632 -0700 Static serves a byte range, and Content is that answer on its own Static advertised no Accept-Ranges and answered every Range with the whole file, so a caller that needed one had to leave Static behind and re-implement file serving to get it. One range per request: 206 with Content-Range for a span the file has, 416 for a span it does not, and the whole file for anything it declines -- absent header, an unknown unit, or a multi-range request, all of which RFC 9110 14.2 lets a server answer in full. If-Range is honoured, and a 304 still outranks a range because the client already holds the bytes. Content is the same answer over an already-open representation, exported because Static cannot be the only way to reach it: a handler that negotiates a precompressed sibling, or names its own cache class, needs the conditional and the range without Static's content-type guess. The caller owns Content-Type there -- a .br beside main.css is still text/css, and guessing from the stored name would call it brotli. A source that cannot seek is served whole, so no fs.FS loses an answer it used to give. Measured on both fixtures: embed.FS and os.DirFS both seek, and embed carries no modification time, so If-Range can only match on the directory one. 0}Mx#tree d68d1a10036d2c11b6970b3c563f86c2f4d708d2 parent 3abb36a5b2be16fd7e0fc2e02998175abfe4f003 author Zach Kelling 1787609223 -0700 committer Zach Kelling 1787609223 -0700 A + capture is +1, and fiber counts each marker on its own sequence pathParams named every wildcard's router key "*N" off one shared counter. Fiber does neither: it keeps the marker in the key and counts each separately — measured against the router, `/p/+/q/*` matches under `+1` and `*1`, and `/p/+/q/+` under `+1` and `+2`. So a `+` route's capture was named "*1", which binds nothing. Both halves of the previous change then failed on it at once: the field fell through to the query list, because the suppression looked under a key fiber does not use, and the path variable stayed undeclared. One wrong character, both symptoms. The document's name is a SEPARATE sequence and stays positional, because that is what Template writes into the path and what a declaration is looked up by. The two counters are why a pathParam carries both names rather than deriving one from the other. TestTheRouterKeyIsFibersOwn reads the keys off the router for six patterns — a fact about fiber, not about zip, so it is measured rather than argued. )>Qxtree 1c00024ab1ad8837f7b27c65cc278098afc5abba parent 9db2563483efb381f8513193ccccf1c87dc14952 author Zach Kelling 1787608859 -0700 committer Zach Kelling 1787608859 -0700 A parameter's prose comes from the field it binds, not from its URL name zipdoc files a field's description under the name it carries on the WIRE; a path parameter was looked up under the name the ROUTER matches on. The two coincide for every `:name` segment and differ for a wildcard, whose router key is fiber's *N — so the one parameter that IS the address was the one parameter with nothing said about it. urlField carries the wire name beside the URL name and docKey joins them, so the lookup asks under the name the prose was filed under. The example lookup keeps asking under the wire name it was always keyed by: the two are separate arguments now rather than one doing both jobs, which is what made the first attempt at this silently drop every parameter example. The description is not asserted in this package's tests and cannot be — zipdoc indexes declared source, not _test.go, so a fixture here carries no prose whatever the lookup does. What is asserted here is the half that can be: the wildcard is declared as a path parameter and its router key does not leak into the query. 'ĕixmtree 03bdb16c4c4d52a6880d23d4fcfedca755a94501 parent f0003b31bfe29cca3868cb623383ca1c21f918d0 author Zach Kelling 1787608469 -0700 committer Zach Kelling 1787608469 -0700 Declare the wildcard segment, do not only spell it Template names a wildcard {wildcardN} and the document builder writes that into the path, but colonParams — which derives the parameter declarations — read `:name` alone. So the path carried a template variable nothing declared, and the field binding it was described as a QUERY parameter under fiber's capture key. A client generated from that has no argument for the address, sends the braces literally, and is answered 404 by the route it was generated for. Spelling the segment without declaring it is worse than refusing the op, which is what this did before. pathParams replaces colonParams and carries both names a segment goes by: the document's, which a parameter must be declared under because the path uses it, and the router's, which is what an input's `url:` tag binds against. Every reader takes the one it means, so neither can be mistaken for the other — declared under the router's key the document would name a parameter no path contains; bound under the document's the input would bind nothing. It also carries the segment's index, which is the only substitution that works for a wildcard: remote replaced `:name` by spelling, and a wildcard's segment is `*`, matching no name. TestAWildcardIsDECLAREDAndNotJustSpelled asks the document for both halves — the declaration present, and the capture key absent from the query — because the missing declaration showed up as the phantom query parameter. PSMx!tree d6d8e02565b2fc389205502dc733b6da1e52039f parent 6aea844918f82292bcc1df844a534f28f6bc8874 author Zach Kelling 1787606842 -0700 committer Zach Kelling 1787606842 -0700 The document builder asks Template, instead of translating on the way past buildOpenAPI carried its own translation — replace "/:" with "/{", then repair a missing brace by calling Template anyway — so the rule lived in two places and the shortcut answered for two shapes it was never asked about. A wildcard has no "/:", so it never reached Template and "*" was published verbatim: a path no template can mean, and one a consumer reading the route table names {wildcardN}, so the two resolve as different operations rather than as one address spelled twice. A path carrying a parameter AND a literal "}" satisfied the repair's guard without being repaired, and published "{name" unclosed. Template is the rule and is now the only copy of it; closeColonParams, which was that name with an extra hop, is deleted. TestTheSpecSpellsAWildcardTheDocumentsWay asks the DOCUMENT rather than the function, which is the half a Template test cannot see — fixing the rule and fixing its caller were two changes, and only the second one shows here. R: Cx5tree 1bc37b5a2c2699e02d31b526d371445a67fc64bb parent 1868cc1355e50ede6e22b5bb509a7f81de7419b3 author Zach Kelling 1787606494 -0700 committer Zach Kelling 1787606494 -0700 Template spells a wildcard the way ID already does Template returned "*" and "+" verbatim, so a typed op registered on a wildcard published a path no document template can mean — and a caller reading the route table named that address {wildcardN} while one reading the registry named it *. A consumer holding the two resolves them as different operations rather than as one address spelled twice, which reads as "no such operation". It is not a new name: ID already spells a wildcard segment wildcardN, numbers it in path order, and its own comment calls {…} "the document's spelling of what paramName reads in the router's". Template simply never implemented that half. TestTemplateAndIDSpellAWildcardTheSameWay is the property, so the two cannot drift into naming one address two things. Only a segment that IS the marker converts; a literal containing one is a name. UuE*x^tree bc9c58c823151227aa137d0545e87d1074d8a881 parent cf6b285b164db800b710fb077438d5bb9bba1f70 author Zach Kelling 1787553964 -0700 committer Zach Kelling 1787553964 -0700 build against the ci release that lets this repo's gate run The gate reached 28 of 29 steps and died on the GHCR login: this repo publishes binaries and no image, and the fallback sign-in refused rather than warned. hanzoai/ci v1.0.91 fixes that branch. v1 still points at v1.0.89, so asking for v1 would keep failing. Pinning to a version rather than waiting on the floating tag, which is what hanzoai/ci does for its own gate. Co-authored-by: Hanzo Dev xLtree 0b5c7cd0f3adfbcc7deb05e6b4d71f9b8752018e parent c9f4346ac42b72579f66661c91f507ba51ed99b3 parent 3f916ff70062871858436c6a0d0ffa692d3c3abb author Zach Kelling 1787544608 -0700 committer Zach Kelling 1787544608 -0700 Merge remote-tracking branch 'github/main' Co-authored-by: Hanzo Dev { fAxtree e1f6ff8b90ef3baa99a7d2cc653076bb9ced43e6 parent baaa8fe606370ee4dac63a8e6b0e85fe77bd8888 author Zach Kelling 1787542250 -0700 committer Zach Kelling 1787544527 -0700 An app's rule covers every op it serves Authorize declares a rule at the op-invoke seam — the one point REST, MCP, the call plane, the graph and the CLI all funnel through. Which ops it covers is decided by composition, not by registration, so adopt settles it over the walk at build: the rule over a definition is the nearest one declared above it on the path the walk took to reach it. One traversal answers for a group and for a definition composed by Use, because those are one mechanism here. A definition that declares its own rule keeps it; declaring none falls through to whatever composed it, so composing can add a rule and never drop one. A definition composed under two rules that disagree is refused at Build, naming both. Its ops are one closure and one closure answers to one rule. Co-authored-by: Hanzo Dev IhJ?x tree 94760d9f2513e0942c92b25c50843bd82d9c1a65 parent ba62c0e45f8956b7b1d06fbfe84134141c56a82b author Zach Kelling 1787539733 -0700 committer Zach Kelling 1787539733 -0700 build on the pool that exists This repo asked for runner zap-proto-build-linux-amd64. No runner carries that label: the fleet's org-prefixed labels are hanzo, hanzoai, lux, zoo, pars, zen and luxfi, and zap-proto is not among them. So both runs this repo has ever had were created and then sat queued with started_at unset while 27 of 30 runners were idle — the gate looked absent rather than blocked, which is why a stale contract/go.mod survived in main. Dropping the override takes the default, hanzo-build-linux-amd64, which 28 of the 30 carry and which zap-proto/http — the sibling in this org with no override — already completes on. If zap-proto should have its own pool, the fix is a label on the fleet rather than a request for one that is not there. Co-authored-by: Hanzo Dev Zl(x{tree 9195352c2ea94ae11b26e557f70f1f764244fc85 parent c9a6319f2a8c377798c1d2e34f4402b6059e5c4c author Zach Kelling 1787538771 -0700 committer Zach Kelling 1787538771 -0700 carry the sums for the requirements the previous commit named The tidy moved contract/go.mod to zap-proto/http v0.3.5 and zap-proto/mcp v1.0.5 and I committed only the go.mod, so main briefly named two requirements it recorded no sum for and `cd contract && go test ./...` could not verify them. Eight lines: the two modules plus the fasthttp/websocket and savsgio/gotils that come with http v0.3.5. Co-authored-by: Hanzo Dev lH?xtree 50fbf7ab2cd493b7e70de62d8f41efed5aa43645 parent 790ad19bf8f7b84ffd97d126fd10c5d82f32983f author Zach Kelling 1787538729 -0700 committer Zach Kelling 1787538729 -0700 tidy the contract module against the dependencies the root already moved `cd contract && go test ./...` is the third of this repo's three gates and it does not run: go refuses under -mod=readonly, which is the default, with "updates to go.mod needed". The root module took zap-proto/http v0.3.5 and picked up zap-proto/mcp; contract/go.mod still named http v0.3.1 and neither. go.sum needed no line, so nothing new is being trusted here — the sums were already present and only the requirement list was behind. This has never been caught because this repo has never produced a CI run: the Actions unit was off while it was pushed to, and there has been no push since it was turned on. All three gates pass locally now — go vet clean, go test 7 packages ok, contract ok. Co-authored-by: Hanzo Dev C\kLx6tree b66fec2959c2ebe5f15d4a29d84973f72319ef51 parent 35b62a9b8635df2a0cc51d83479bd3092191d256 author Zach Kelling 1787450827 -0700 committer Zach Kelling 1787450845 -0700 the upgrade sibling names the limit it broke, not the errno An app listening on a unix socket also listens on a DERIVED one — the same address plus ".http" — because a websocket upgrade cannot cross ZAP framing. The five bytes that suffix adds are not something the caller chose and not something it can see, so a path that fits can still put its sibling over Darwin's 103-byte sun_path limit. It failed inside the transport as "bind: invalid argument", which names neither the limit nor the length and reads like a broken socket rather than a long path. It cost a real afternoon to read once already, in a test whose own NAME was the 49 bytes that pushed it over. load.go has asked exactly this question of exactly this address since the plugin loader learned it. This is the other half of that one rule, asked in listenOn where an error can still be returned rather than in plainSibling, which has no way to report one and would otherwise have to disable upgrades silently. Co-authored-by: Hanzo Dev 1&xjtree 2fd608caca3b6aed254ead5e2480fea14f37d004 parent 790ad19bf8f7b84ffd97d126fd10c5d82f32983f author Zach Kelling 1787447009 -0700 committer Zach Kelling 1787447029 -0700 The CORS test asserts the route was reached It checked headers only. A middleware that answered instead of chaining would set every header the file inspects and still be broken, and all three tests would have passed — which is the shape of assertion this repo has been finding elsewhere all day. Verified by mutation: replacing the chain call with a bare return fails two of the three, and putting it back passes. ѯ5xVtree f269b8a60ce7baa0ce667a8f5c1fe986a27fa847 parent b8a846ea4a1570bc6ce19be99e349590a796de46 author Zach Kelling 1787446826 -0700 committer Zach Kelling 1787446826 -0700 Read the credential a caller presented A service that reaches another on this caller's behalf needs what the caller presented, and CallerOf deliberately does not carry it: Caller is the identity a request was resolved TO, and handing that back would let a service mint its own answer to the question it was supposed to ask. zip.Header reads one header of the request behind a handler's context, and answers "" when there is no request behind one — a ZAP frame, a command, a background job. That honesty is the same one headerOf already gives the invoke seam; this only lets a caller outside the package ask. Co-authored-by: Hanzo Dev W5#TxNtree eaebb088849b54f20b4ab58a75fdc844cb1a1c00 parent 381e91f11361696442dacd6e93f1ec9e6caf3d3a author Zach Kelling 1787446605 -0700 committer Zach Kelling 1787446605 -0700 A host can serve a graph it does not own A deployment that answers with many processes has one surface and no single registry that holds it. Describing that surface as a graph meant either a second GraphQL implementation in the host, or a schema naming fields nothing could run. So the resolver becomes an input. MountGraphFor takes a schema function and a Resolver; the parsing, variables, fragments, directives and projection are the same code a local graph runs, and only the answer to "what is this field" comes from elsewhere. The resolver is told the operation kind as well as the field, because there is no registry entry here to check a write against — the rule that a write is not reachable as a read still has to be enforceable, so it is enforceable where the knowledge is. A value with no Go type behind it is projected by its own keys, and a field absent from it is null rather than an error: with a type, an absent field and a misspelt one are distinguishable and the misspelt one is still named; without one there is nothing to name it against, and inventing an error would refuse valid answers. Co-authored-by: Hanzo Dev 'Ex_tree 760627f9a17c0e001cab4be870825de6c78439cf parent 83496cfbe4f521b8ba74ae1bd4ab39cea2af0576 author Zach Kelling 1787446373 -0700 committer Zach Kelling 1787446373 -0700 CORS names one origin, and Max-Age counts seconds Access-Control-Allow-Origin carries exactly one origin. The middleware joined the whole allowlist into it, which a browser rejects outright and which also publishes the list to every caller. It now checks the request's Origin against the allowlist and echoes the match, adds Vary: Origin because the answer depends on it, and sends nothing at all for an origin that is not listed — no header beats a wrong one. "*" still answers "*", except beside credentials, where the spec forbids it and the echo is the only value a browser will accept. Max-Age is documented as seconds and was rendered through time.Duration, whose String() reads nanoseconds: a MaxAge of 3600 went out as "3.6µs", which is not a number and caches nothing. Found migrating playground off a fiber CORS it had reached for precisely because this one could not express a multi-origin allowlist. ށЙExYtree c282d5ff62d950be30a1e6be8cb52cda87da452a parent 4d8253d963fe7884e017c838a8379ad8d503ba84 author Zach Kelling 1787442445 -0700 committer Zach Kelling 1787442445 -0700 An adapted net/http handler gets net/http's content sniffing The stdlib finalises a response head at the FIRST BODY WRITE, not at WriteHeader, and that is not an implementation detail — it is what lets it sniff a Content-Type the handler never set. The adapter released the head on WriteHeader, so there was never a body in hand to sniff, and every adapted handler that relied on the stdlib's rule answered text/plain. Found by bumping docdb: its debug index writes an HTML page and sets no header, which is ordinary stdlib code. The page arrived as text/plain and a browser showed the markup. WriteHeader now records the status and nothing else; the head commits at the first write, or at the handler's return if it wrote nothing. A Content-Type that is present but EMPTY still suppresses sniffing, which is also the stdlib's rule and the one a caller reaches for when it refuses to characterise the bytes. ȟ7xtree ffec928c880a0489d6f098810609d5005c36e8c0 parent 39f87c747c62d757f46ec938c5c6b412a2890265 author Zach Kelling 1787434606 -0700 committer Zach Kelling 1787434606 -0700 An answer names itself whether or not the app describes itself self is true of every answer — it is the path the request arrived on, and nothing has to be installed for it to be so. Only the description relations depend on a document existing. Those two rode one condition, and it cost more than the description: installOpenAPIRoutes returns early for an app with an empty registry, so an app serving plain routes named nothing at all, not even itself. Measured across the estate: six services register zero typed ops, so bumping their pin would have changed nothing about what they emit. Whether an app happens to use typed ops is not a statement about whether its answers have addresses. >5՞>xtree 19ddff9a87a6b1a345d4e88c8f93b6c760d46146 parent a4b09c74b88ab3f9bd3c18ba5ac9232d2e6e6a8b author Zach Kelling 1787376812 -0700 committer Zach Kelling 1787376832 -0700 An answer that already names itself is not named again Measured on api.hanzo.ai: one answer carried three self links. Two were this middleware, running on both sides of a proxy hop — the far end serves the request and writes its links INTO THIS RESPONSE, so by the time the near side runs they are already there. The third is cloud's own index layer, which is a separate question. The far end is the app that actually served, so its account is the true one and the near side leaves it alone. An answer this app served itself is unaffected, which the test pins in both directions. The check reads the header rather than keeping a flag beside it: the header is the thing that must not be written twice, and a flag would be a second account of it that could disagree across the very hop this exists for. \EY5xItree 82ad7f4d677e246de2ff369f99ba900b25660efb parent 5610321dba6db2fbdfd189d8d9c6d65f7dc0839c parent 39b66219d8d2a9bfe7bc4a9bb7d2dac6e48daced author Zach Kelling 1787376160 -0700 committer Zach Kelling 1787376160 -0700 Merge commit '78792b54' into forge-sync Co-authored-by: Hanzo Dev +e2.xtree 82ad7f4d677e246de2ff369f99ba900b25660efb parent 26eb786d45ed18a50535f29048ee521875dc9ff6 author Zach Kelling 1787375845 -0700 committer Zach Kelling 1787376042 -0700 Let a host mount the graph at its own address zip serves the projection where its control plane lives; a product serves /v1. That is already how the OpenAPI document works, so MountGraph makes the split explicit: what the projection answers is not the host's to change, where it answers is. The schema now renders per request rather than being captured at mount, so a host may mount before it finishes registering and the document still describes the registry as it stands when someone asks. Co-authored-by: Hanzo Dev 4Rrx(tree 6d886966c2ce1f7957a81d5de015b974c6b361ed parent d99aec8a0d265f289545c95c1b91f67fca52ead6 author Zach Kelling 1787375411 -0700 committer Zach Kelling 1787376041 -0700 Serve the graph projection: GET the schema, POST a query GraphQLSDL published what the ops describe; nothing ran it. This adds the executor and mounts both halves on one path. The resolver is op.direct, so a field runs the contract the REST route runs: validate, authorize, handler. Two properties are enforced rather than merely published, and each has a test that fails when the enforcement is removed: - A query operation resolves names against GET ops only. A mutating op is absent from the index a query searches, so it cannot be invoked by one. - A `header:` field is ambient. The schema does not publish it as an argument, an argument naming it is refused, and its value is bound from the request after the arguments — what the gateway sets, a client cannot supply. The projection carries the Go type alongside the decoded value, which is what separates a field absent because it was empty (null) from a field absent from the type (an error). Without it every misspelling silently answers null. The reader is hand-written: a dependency here is a dependency in every service that links zip, to read a grammar whose executable half is six token kinds and five productions. It takes operations, variables, aliases, fragments, inline fragments and @skip/@include. Subscriptions and introspection are refused by name — no op is a stream, and the schema is published whole at GET. Also corrects the schema walk to use wireFields, so an embedded struct's promoted fields appear, and renders time.Time as String rather than by fields that never cross the wire. Co-authored-by: Hanzo Dev }x tree 1351eda3a995e656846cc76b5bf6d05a0753b50c parent c5116818c5b3dcf3e522b7d1db99d3af4b4b2e9e author Zach Kelling 1787345360 -0700 committer Zach Kelling 1787376041 -0700 GraphQL, the sixth projection The registry that already produces the REST routes, the OpenAPI document, the MCP tool list, the CLI and the op-call plane produces a GraphQL schema too, from the two types an op has always declared: In becomes the field's arguments, Out becomes its result. Nothing new is declared. There is no schema file and no resolver map — a field exists because an op exists and disappears when the op does, which is the whole reason to derive a projection rather than maintain a second description that can drift from the first. GET ops are Query fields and the rest are Mutation fields, because the method is the only signal an op gives about whether it changes anything. It is the split OpenAPI already publishes, so a reader who knows one knows both. The arguments are FLATTENED rather than wrapped in an input object: an op's In IS its argument list, and wrapping it would make the GraphQL call read differently from the same call over REST or the CLI. Types are named in PascalCase, which openapi's sanitize cannot do — it lower-cases, correct for a component key and wrong for a type. A map or an interface becomes JSON rather than an invented shape a client would then rely on, and a struct with no exported fields becomes JSON too, because `type X {}` is not valid SDL. Six tests, including the two that would otherwise be found in production: a self-referential struct terminates (the cycle guard is separate from the emitted set, because a type is reached again while its own definition is still being written), and a POST never appears as a Query — a write reachable as a read is a write behind a cache. No graph database is involved and none is needed. GraphQL is a query language over resolvers; whatever backs the op is untouched by this file. Co-authored-by: Hanzo Dev x|%xVtree 817c886fbc13a0bfcb38000c5731183f3a2a7d47 parent c1686783180cc1e04fde595413094b2d6eab2e2b author Zach Kelling 1787334813 +0000 committer Zach Kelling 1787376040 -0700 Put the pipeline where the forge looks for it Workflows are collected from the first workflow directory that exists in the pushed commit, and a reusable is resolved under the same allowlist. A caller under .github/workflows naming .github/workflows/build.yml was therefore neither collected nor resolvable: no run, no queued job, no error. hanzoai/ci publishes build.yml at .hanzo/workflows only. xn]tree 6862bee7cca7a0e3aa31326e2deb4f36cb48281b parent 41925ad262e774ce4f4f83ac642341bf38d5d3e4]_5845 M xm]tree c3484cbb39a61b5eac89cd1ff0fec8739b47122e parent 0ed925bfd0d4d718c7e0f20137d6e2437fd328c5]_541i xtree 575881af1de5f8abf966c39e4e6dac858b60565d parent 4c560e19b9c61fac2a7f96a674a173bb99ab4aa1 author Zach Kelling 1787347236 -0700 committer Zach Kelling 1787347236 -0700 A host can ask whether the app declares an address A document is built from the ROUTER, which carries more than the contract: zip own control routes, and anything registered through Undeclared. Declares is how a host tells those apart without keeping a second list of what to skip. ʰxtree aed14e930441aeeb5eeaffb883ccc6e084ae604f parent 8d7ea07e469c9a15564334aaec45c3e3a7f8cb2d author Zach Kelling 1787347015 -0700 committer Zach Kelling 1787347015 -0700 Undeclared takes an OpTarget, like OAuth does Both mark a property of an address and return a Router to register it on, so both are reached the same way — and a caller holding a Group rather than the App can use either. It was a method, which the one caller that needed it could not reach. Yxitree 95168d1227a9b80d62f622502a8633988d5a1f2c parent 40773485bc6d1094db33ba54e0f2268a934b6eef author Zach Kelling 1787346910 -0700 committer Zach Kelling 1787346910 -0700 A route can serve without being in the contract Declaration is what every projection is built from — the OpenAPI document, the MCP tool list, the CLI commands, the by-name call plane. Until now an app's route was in it or was not served at all, and a retirement needs neither. A retired address answers 410 and names its successor for EVERY method, because 410 is a statement about the target resource and a caller who sent the wrong verb still needs the successor. Published, that is one operation per method per address — for hanzoai/iam's 42 retired addresses, 210 operations, most of them calls that never existed. A contract that lists dead endpoints is one nobody can read, and it took that repo's untyped-operation budget from 87 to 276 when the whole point of retiring the surface was to make it fall. App.Undeclared returns a Router whose routes serve and are skipped by Declaration. The fact rides the route entry beside oauth, so it survives composition: a service composed under a host stays undeclared at its new path. It returns a Router rather than taking a path deliberately. An address that DOES something and hides is a door nobody reviews; grouping them keeps the ones that use it visible in one place. -`hxo]tree 8e5ff53a9de90bb17565854cdf12ecb3fa175a48 parent f0613d2cb098214a3188d48eecd0851202cd3cc0]^453602{D JxRtree 750a9e1a132ff875616c2025d9ef6b8787eb0e33 parent c59a9b9b94f9ecb23a0f8056a89384c0b07cfa93 author Zach Kelling 1787344906 -0700 committer Zach Kelling 1787344906 -0700 Leave the occurrence out of a problem document `instance` (RFC 9457 §3.1.4) is optional and was filled with the request path — which the caller supplied and already holds, so it told them nothing. What it did do is make two addresses refuse with different bodies. The property worth asserting about a refusal is that a real resource and a fabricated one produce the SAME answer, so nothing can be asked which names exist. Comparing those bodies is the natural way to assert it, and echoing the path turns that comparison into one that can only pass by being loosened. Four such tests met it across iam and cloud, each a name-existence check, each of which would have had to weaken to go green. So the member is gone and the comparison stays strict. TestTwoAddressesRefuseIdentically drives two addresses that refuse for one reason and asserts the answers are equal and name no occurrence — it fails if the member returns. problem() loses its parameter: nothing chooses an occurrence now. '`;x@tree 3660fbc31965602bd61f5a3bd277277d95702d67 parent 3dd01043ec011708eaa6205ed89a289b0517c7af author Zach Kelling 1787343084 -0700 committer Zach Kelling 1787343084 -0700 Stop naming a verb that no longer exists Graft was deleted when the op registry became a lazy projection over a walk, but its name stayed in 40 places: eleven test names, a helper, a godoc link to the removed symbol, and prose describing composition as grafting. The rationale those comments carry is still true and still worth reading, so it stays — reworded to describe the old design rather than to name a symbol a reader cannot look up. graft_test.go is nest_test.go; its helper serves an app in memory and is called probe, which is what distinguishes it from get (a real socket) and from wireGET (package zip, not zip_test). One comment also described a pathless app.Use as an authentication seam. It is authentication; the extra noun said nothing. 'Ipxtree 8a766e24e5320741f3a60c2b228b5c533006e607 parent 3d65856061f1906661fd5f0810e2c22e754ed925 author Zach Kelling 1787341677 -0700 committer Zach Kelling 1787341677 -0700 Answer refusals as RFC 9457 problem documents; OAuth keeps its own vocabulary A refusal now leaves by one door and is written in the vocabulary of the address it happened at. HTTPError loses its struct tags and becomes a plain value; MarshalJSON is the single place that says what it looks like. Its three members already mapped onto both standards exactly, so no field was added: Status is `status`, Msg is `detail`, Code is an extension member (RFC 9457), and the same value reads as `error` / `error_description` under RFC 6749 §5.2. With() members still merge at the top level per §3.2, with the document's own written last. zip.OAuth(r) returns a Router whose routes answer the OAuth vocabulary. The fact rides the route entry rather than a table of addresses, so it survives composition, and it is a property of the address rather than of the returned value — which is what makes it reach the refusals no handler wrote (Bind, validation, panics). A verb the endpoint does not serve is the router refusing, and answers a problem document with Allow. middleware.Recover wrote its own 500 body with c.JSON, a second error surface that spoke only the default vocabulary; it now returns the error so the one handler renders it. group() copies oauth beside wrap, so a nested scope keeps the vocabulary. Allow on 405 comes from the fiber fork's router and was already correct; TestAWrongVerbSaysWhichVerbsWork now pins it in both directions so an error handler edit cannot drop it. Consumers reading `body.error` read `body.detail` now. Each repo takes the change when it moves its own pin. Vrixltree 3cb03a7c8e3d70a06302f6acecc6f63ebf3890a8 parent 50fedcc04be79f876e6caf85b7d4a2c08e51e080 author Zach Kelling 1787334880 -0700 committer Zach Kelling 1787334880 -0700 every answer says where to learn what else this API serves An API a client can only use by reading documentation kept somewhere else is one whose callers hard-code addresses, and a hard-coded address is what turns a rename into a breakage. zip already served both halves of the answer — /.well-known/openapi.json for a machine, /docs for a person — and nothing said so, so a client had to already know they existed in order to find them. RFC 8288 is the standard way to say it and RFC 8631 registers the two relations an API needs: service-desc for the description, service-doc for the page. Both ride as headers rather than in the body, because a body shape belongs to the resource — one app answers a bare array, another an envelope — so writing links into it would mean zip choosing a representation for every handler that pins it. Beside the representation, this covers a JSON object, a byte stream and a 404 alike. Installed at materialise, next to the report and for the same reason: an app says where its description lives by being BUILT, so there is no call to forget and no order to get wrong. Two properties, both mutation-checked. A link never names an address this app does not serve — the condition is the same map that installs the route, not a second guess at it, and the test FOLLOWS each link rather than matching its text. And Link is a list header, so a handler's own next/prev survive: setting instead of adding would drop a page's paging silently. K"xs]tree ce4d74ec2e0cf24714edb3708f7e49162abff370 parent 0408d1b48cc263079925c315c63528c5b814f3d5]^ 34813 +00Ē0 vxktree 36a3994251b32f3085133468a098ae97fe1c4e70 parent 550e1fe23074c1bc52b9609962888a924ece0032 author Zach Kelling 1787329629 -0700 committer Zach Kelling 1787329629 -0700 a refusal can carry its detail A typed op's only way to refuse is to RETURN an error, and an HTTPError could carry a status, a code and a sentence. So any route whose non-2xx answer has a SHAPE could not be a typed op at all — and six subsystems in one consumer are untyped for exactly that reason, each losing its schema, its prose, its MCP tool and its CLI command to it: a prepaid gate answers 402 naming the cap, the spend and the ledger a plugin build answers 422 carrying the diagnostics that say why it failed a degraded probe answers 503 carrying the report that says what is degraded Three separate envelopes were hand-rolled downstream to carry a body BESIDE an error that could not carry one. That is one missing capability wearing three costumes, so it is answered once, here. Detail is an extension in the RFC 9457 sense — the members a problem document may carry beyond its own. It MERGES rather than nests, so a reader sees one object instead of a body filed under a key it must know to look in. THE ENVELOPE IS WRITTEN LAST, and that is the half worth the test rather than the feature: a domain key called `status` silently overwriting the refusal's own is how a 402 reads as a 200. Mutation-checked — writing the envelope first lets a detail key displace it, and the guard says so by name. ADDITIVE, deliberately. Twelve repositories render errors through this type; a refusal carrying no detail marshals byte-identically to what they read before, which is pinned rather than asserted. ErrPaymentRequired and ErrUnprocessable join the shortcuts because they are the two statuses that most need a body and had none. Co-authored-by: Hanzo Dev ͍Nxtree 56f38097966f0c3c85917065e0683c607f39d98f parent 8e689ef9a52184274d224f42ebdf640a800618ba author Zach Kelling 1787300723 -0700 committer Zach Kelling 1787300723 -0700 a mounted handler streams instead of being collected AdaptNetHTTP handed the stdlib handler fiber's adaptor writer, which gathers the whole body and copies it out when the handler returns. For an ordinary reply that is only a buffer. For server-sent events it is the difference between a stream and one delivery at the end — a caller watching tokens arrive sees nothing until the answer is already complete, which looks exactly like a slow model and is why "streaming works" could be true and useless at the same time. The handler now runs against a pipe, and the pipe is synchronous: a Write does not return until the reader has taken the bytes, which is what makes Flush honest rather than a stub. Status and headers are read from the handler's first act and applied before the body streams, because fasthttp writes them once and cannot revise them afterwards. Tested over a real socket, not the in-memory helper — that helper collects the whole response, so it cannot tell a stream from a buffer. Co-authored-by: Hanzo Dev fuJxWtree 03dd7a4b2abcdbdcd92cc7a245ad861ccf0ea88c parent 5112db48a92fa787bb46bbdc4ca84a13a539c8dd author Zach Kelling 1787299352 -0700 committer Zach Kelling 1787299352 -0700 attest unix peers on darwin, where the kernel has an answer peerOf was implemented for Linux and stubbed everywhere else, and the stub says the host "does not hand us a peer credential" — which is not true of Darwin. It reports the same thing SO_PEERCRED does, split across two socket options: LOCAL_PEERCRED carries the user and groups, LOCAL_PEERPID the process. The consequence was quiet. A caller identity is either attested by the kernel or asserted by the caller, and every Mac silently had only the second kind, so a check that fails closed on a developer's machine passes in CI for a reason unrelated to the code under test. A credential without a group is refused whole rather than reported with GID 0, for the same reason the stub returns nil instead of an empty Peer: every field of a non-nil Peer came from the kernel. x/sys was already in the module graph and is now a direct requirement at the version it was already resolved to. Co-authored-by: Hanzo Dev Amx.tree 778e84360bedac2ca2a3eb33b00518de05b3cc40 parent 3d25e579f59872c019e58b67bc3b2c85a918f1bb author Zach Kelling 1787299350 -0700 committer Zach Kelling 1787299350 -0700 a socket path that cannot bind says so, instead of dying as EINVAL sun_path is a fixed field holding a terminated string, so a unix address has 103 usable bytes on Darwin and 107 on Linux. Over that the kernel refuses the bind with EINVAL, which surfaces as "invalid argument" and names neither the length nor the path — the plugin child exits 1 and the host reports "exited before listening", which reads like a timing bug and is not. The limit now lives in internal/sock beside the path shape, since both are properties of the same address: minting one is not enough, it also has to be bindable. start() checks the longest address in play — the child's .sock.http upgrade listener — and refuses to launch rather than watching it die. 103 is measured, not read off a header: on Darwin a 103-byte path binds and a 104-byte one does not. The first cut of this used 104 and let through a path that was exactly one byte too long. The private instance directory also stops repeating the plugin's name. The binary and the socket inside it are already named for the plugin, so the copy in the directory spent len(name)+1 of a 103-byte budget saying it twice, and that was what pushed a long name over. Four idle tests and the status test built their Plugin.Dir from t.TempDir, which spends 89 bytes on the test's own name; sockDir has existed for exactly this reason. shortDir was a third copy of sockDir in the same test package, written from a comment that blamed sockDir for t.TempDir's length. Co-authored-by: Hanzo Dev Zוxetree 73a2c46d71bab0cca862ba479feec85045cd2bdc parent 64f34af08138db7e58a767bb5c799b4a999a8d54 parent 8b04e2a276ddcfa8af8499c06f7693273ce12eac author Zach Kelling 1787296933 -0700 committer Zach Kelling 1787296933 -0700 Merge remote-tracking branch 'origin/main' # Conflicts: # load.go Co-authored-by: Hanzo Dev \;mbx tree ea08c480cb87c065637433af37e84b2aecb8c7c7 parent f3d763a0502f9c87759dea6b3a52e110857628c2 author Zach Kelling 1787296820 -0700 committer Zach Kelling 1787296820 -0700 a lazy start publishes by compare-and-swap, so a restart cannot be orphaned startOnDemand held p.mu, checked that no instance was current, started a child and published it with a plain Store. p.mu does not exclude the supervisor: a restart swaps its own instance in without taking that lock, holding it only long enough to read closed and spec. So between the check and the Store the current instance can become non-nil, and the Store overwrites a LIVE child. The overwritten one is then referenced by nothing — no cur, no supervise loop that can reach it, nothing to stop it on Unload or Shutdown. It keeps running, keeps its socket, and keeps writing whatever per-process state it owns. Measured in production before this change: 15 live `ai` children in one pod, accumulated over two hours, every one appending to the same audit chain and racing for its sequence. The audit gate fails closed on that, correctly, so audited POSTs were refused fleet-wide — chat completions, alert delivery and inbound webhooks among them. The restart path already published by compare-and-swap and stopped the loser. This does the same, so the two agree about who is current. Losing is not an error: the winner is a started, supervised instance of this same plugin, so the loser stops the child it opened and serves from the winner. Co-authored-by: Hanzo Dev $&B/x tree 11d273c06bea6c60ba09accd582e23467c5e5623 parent 0408d1b48cc263079925c315c63528c5b814f3d5 author Zach Kelling 1787269221 -0700 committer Zach Kelling 1787269221 -0700 track the name agents read, so a clone documents itself LLM.md is the source and stays the source; CLAUDE.md is a symlink to it, so there is one file and it cannot drift from itself. What changes is that the link is committed rather than left for each checkout to recreate. Left untracked, the doc was conditional on a step outside the repo: a fresh clone had no CLAUDE.md, nothing loaded LLM.md, and an agent worked here having never read what this repo already explains. Most of the estate already tracks theirs; this is the rest agreeing with them. Rjnxtree 29037de4115dac3f057a242de24320b299b62329 parent cd8a5ff3baec01e96d941ff0f6e84228e532a770 author Zach Kelling 1786809045 -0700 committer Zach Kelling 1786809045 -0700 hold the plugin ceiling at the start, not on a ticker Warm was an argument to Evict, so the count was TRIMMED once a minute rather than held. That is a bound only while starts arrive slower than the sweep, and the thing that starts fastest is exactly the thing that needs bounding: a host whose fan-out door asks every subsystem at once started ~100 children inside 90 seconds, held all of them until the next sweep, stopped answering its own liveness probe, and was killed. The ceiling appeared only in the logs of a container that was already gone. So Warm is Config now and makeRoom applies it in startOnDemand, before another process exists: if the host is at its ceiling, the least recently used evictable plugin is stopped to make room. Age keeps its own sweep — steady state and burst are different bounds and both belong to the same policy. Adoption is what makes it possible. A plugin's `app` is the definition that Load'ed it, which for a composed service is a sub-app holding one plugin and no ceiling, so asking it "how many are running" answers 1 and "what is the budget" answers 0 — measured, and the reason a first attempt at this was inert. The root of a composition is known in exactly one place, where the generation computes its hosts, so that is where every plugin learns its owner. Both halves are proven necessary by mutation: dropping the start-path call, or dropping the adoption, each turns the burst test from peak 4 into peak 12 against a ceiling of 4. Race-clean over two runs; full suite green. Co-authored-by: Hanzo Dev Ȝkdx@tree 946b1e2ae80117cef3f7b4913f8578b7e41ee22f parent b53ddda13cb469ca6aa01fbd2dfce569c8483ee4 author Zach Kelling 1786774030 -0700 committer Zach Kelling 1786774030 -0700 measure the wrapper's allocation, not the request's TestServePathAllocsAreChainDepthInvariant asserted a TOTAL of one allocation per request and has been red for as long as the history shows, reporting 34 at every chain depth — which is the invariant it is named for PASSING while the bound fails. A bound nothing can satisfy gates nothing; it teaches a reader to skip a red line. A total counts everything a request pays and the wrapper owns almost none of it. Replacing the logger with luxlog.NewNoOpLogger leaves 32, so the access log is 2, and an alloc profile attributes the remaining 32 to telemetry: zip.describe with its strings.Builder (~47% of objects, cumulative), the metric library's labelsKeyFromLabels (~27%), the hex trace and span ids, net.IP.String and one strconv.FormatInt. Per-request metrics and spans are a feature, so no arrangement of the wrapper reaches one. The claim in the doc comment is about DEPTH — the wrapper allocates per request, not per handler — so that is what this measures now: five middlewares must cost what none costs. The total is kept as a ratchet with a small margin for sync.Pool's pinSlow, which the profile also shows. Both assertions were watched failing before being trusted: an escaping allocation in one middleware reports +1 at depth 1 and +5 at depth 5, and a ceiling of four reports the 34. Co-authored-by: Hanzo Dev .qxtree 7ef9504d9a543e14da4373e3cae48940b934cb30 parent 8533a1f75807c673b9f2316667a737f1fab37d1c author Zach Kelling 1786765303 -0700 committer Zach Kelling 1786765303 -0700 bound how many plugin processes run at once IdleAfter bounds the steady state and cannot bound the burst: it only reclaims a plugin that has already been quiet for its whole window, so in the minutes after a cold start — when every prefix that gets a request starts a child and none is old enough to be idle — it reclaims nothing. Measured on a host of this shape, 37 children at ~152MiB each in steady state and an OOM kill six minutes after boot, well before anything was 15 minutes idle. Evict now takes that bound: age first, then, while more than warm plugins are still running, the least recently used. The plugin that has gone longest without a request is the one whose restart is least likely to be paid for by a caller waiting. Zero is unbounded, which is what every existing host passes. warm is an argument rather than a field because the number of processes a host may hold is a fact about its memory budget, which the host knows and a library cannot. Reap takes it for the same reason it takes its cadence. A plugin with IdleAfter unset is exempt from both bounds, and still COUNTS toward this one — it holds the same memory, and counting only the evictable ones would authorise the budget twice. When the exempt alone exceed the bound this reclaims what it can and stays over it, because a host is better over budget than deprived of the identity service every other call goes through. EvictIdle and ReapIdle are gone rather than kept beside these: two names for one sweep is how the two policies come to disagree about how a child is taken down. Co-authored-by: Hanzo Dev n|v:xPtree c6f49ed806940aeffa24de82b206a2180f4b610c parent 9f72f4c1399a0bf22ea46d4dd4c0466bde97f93c parent f49059dad23ed6590cd906888fcaba36db72ef52 author Zach Kelling 1786764603 -0700 committer Zach Kelling 1786764603 -0700 reconcile the forge copy with the canonical line This copy's main had been cut from a stale base: it was missing the v1.27.1 through v1.28.4 range and carried the idle-eviction work re-applied on top, which is how a release cut from here published a tag that silently reverted thirteen commits. The tree is now github.com/zap-proto/zip's verbatim. Nothing is lost: idle.go, idle_test.go and load.go were already byte-identical, and the one file that differed, idle_bench_test.go, is BETTER upstream — it waits for the reap instead of asserting residency the instant Running clears, which is a race that passed on one machine and failed on the next. Co-authored-by: Hanzo Dev ?}wx{tree c6f49ed806940aeffa24de82b206a2180f4b610c parent e0c30f6485f0fc6fa9c6a65f8f31335d9092ecee author Zach Kelling 1786749661 -0700 committer Zach Kelling 1786749661 -0700 idle eviction, on v1.28.4 — v1.29.0 was cut from a stale base v1.29.0 IS BROKEN AND THIS REPLACES IT. It was tagged from the forge mirror, whose tags stop at v1.27.0, so it silently reverted v1.27.1..v1.28.4 — including the zipdoc operation-id work — for anyone who took it. Cloud's gate caught it immediately (operation ids came back as get_v1_* instead of get_*, and openapi.yaml stopped being the weave of its apps). The tag stays where it is; published versions are immutable, and this is the patch above it. The feature itself is unchanged: IdleAfter stops a lazy plugin nothing has asked for, and the next request starts it again through startOnDemand. Every subsystem is its own process, so without this a host pays for the SIZE OF ITS CATALOG rather than its traffic — measured on the fleet, 24 children at ~150MiB of live heap each, ~4.4GiB, which is what evicted the pod and took its API down. Safe against the supervisor by construction: it detects a deliberate stop by CAS-ing cur to nil, and eviction clears cur before the child dies, so the CAS fails and no restart storm follows. The benchmark measures the claim from the kernel — six children warmed, VmRSS read per pid, evicted, every pid asserted gone. It had to learn to WAIT: retire is asynchronous by design, so Running goes false before the child is reaped, and checking residency at that instant tests the scheduler. It passed on one machine and failed on the next until it polled. Verified on this base: idle suite green x3, 0 races in 5 -race stress runs. TestServePathAllocsAreChainDepthInvariant fails identically with these changes stashed — pre-existing on v1.28.4, unrelated. Co-authored-by: Hanzo Dev ȹ@xtree 288bdf943cd9c74d807738eecff2bd3c5f1cc0c5 parent 288b8472df79b526916a72a0249c4481f1093f35 author Zach Kelling 1786749163 -0700 committer Zach Kelling 1786749163 -0700 measure what eviction reclaims, from the OS The idle tests assert a plugin stopped and came back. Neither says the thing eviction is FOR: that the memory went away. An implementation that dropped the instance pointer and leaked the child would pass every one of them. So this warms six plugins, reads VmRSS from /proc for each child, evicts, and asserts every one of those pids is gone — zero resident, from the kernel rather than from a counter the host keeps about itself. Then it serves a route again, because eviction that took the catalog down would be a teardown. Measured here: 68.1 MiB across 6 children, all of it reclaimed, 11.4 MiB each. Those are trivial test plugins; the fleet's are ~150MiB apiece, which is the number that makes a 100-surface catalog impossible to keep warm. Co-authored-by: Hanzo Dev 6.aLxtree a8b16c663209c1e4c9050273902db14b76337ad8 parent 98c206f05497db6138c70261d84b8c867e14a7dc author zooqueen 1786748310 -0700 committer zooqueen 1786748310 -0700 transport: say what the body ceiling does, not what it did @Jx7 tree fc13be6e15deb67d3ff45f8ffa3cfe550931a787 parent 4d8d856b6fe7eaa6be3ea3950b5808e409ea8525 author Zach Kelling 1786733433 -0700 committer Zach Kelling 1786733433 -0700 idle eviction: the other half of Lazy Lazy defers the first start and nothing has ever stopped a plugin, so a host pays for every service it has EVER served, forever. Resident memory tracks the size of the catalog rather than the traffic. Measured on a host running two dozen subsystems: 24 children, ~150MiB of live heap each, ~4.4GiB resident, while three of them sat at 12-20MiB. The catalog was the bill, and it is what stops that host adding the other seventy services it wants. IdleAfter stops a lazy plugin that has not served for that long; the next request starts it again through startOnDemand, which already exists. Zero means never, which is both the historical behaviour and the right setting for an identity or config plugin every other call goes through — nobody should pay a cold start for auth. Safe against the supervisor by construction: it restarts a child whose process exits and detects a deliberate stop by CAS-ing cur from the instance it watches to nil. Eviction clears cur BEFORE the child dies, so that CAS always fails and no restart storm follows — the same contract Reload and Unload use, minus the disabled flag, because coming back is the point. Two defects the checks caught before this shipped, both worth naming: - stop() from ReapIdle signalled and returned, so a sweep could still be running when the host began shutting down. That is a real data race (evictIfIdle reads App state shutdown writes) and the detector found it. stop() now waits for an in-flight sweep. - TestIdle_EagerIsNeverEvicted passed for the wrong reason: with no request served, lastUse stays zero and evictIfIdle returns on that check before it ever consults Lazy. Deleting the eager guard did not fail the suite. The test now serves a request first, and that mutation fails it. Verified: 0 races in 10 -race stress runs; the eager, zero-means-never and comes-back-with-a-new-pid guards each fail when their rule is removed. (TestServePathAllocsAreChainDepthInvariant fails identically on this commit's parent — pre-existing, unrelated, 34 allocs on the serve path.) Co-authored-by: Hanzo Dev `8œLx3tree 08712b22e067f999e1483cb5022322dc323c8981 parent c2d8cf970f21b7887d025f258502117bf64ba685 author zooqueen 1786724552 -0700 committer zooqueen 1786724595 -0700 the body ceiling reaches the socket, not just the Config The HTTP transport builds a bare fasthttp.Server, so Config travels to the wire only through applyConfig. It carried ReadBufferSize, WriteBufferSize and Concurrency and left BodyLimit behind: fiberConfig sets fiber's own BodyLimit, which fiber pushes onto MaxRequestBodySize only when fiber owns the listener, and here the transport does. The socket kept fasthttp's 4 MiB default whatever the App declared. Measured on a deployment configured for 100 MiB: 4,194,304 bytes answered, 4,194,305 answered 400 "Error when parsing request" — fasthttp refusing before any handler runs, in a voice that reads as a malformed payload rather than a size cap. That capped every request body on the edge, so a site publish over 4 MiB and a full-context prompt (~4.3 MB of JSON for 1M tokens) failed alike. The regression test drives a real socket in both directions, because the assertion that passed throughout was a config-level one: the value was set correctly and never left the struct. BG_:x]tree 0a4f9408bd7c2588580b494a619c5deb25d8331a parent 2ba02d0c1502ce9bea7ff67202f9a5059a0ad46b author Zach Kelling 1786669788 -0700 committer Zach Kelling 1786669788 -0700 transport: listen plain HTTP beside a unix socket, so an upgrade lands plain() derives the sibling address the host dials for an upgrade, but nothing ever listened there: the dial was the only caller. A websocket through a unix mount therefore failed the handshake against a socket no process had created. Listen now starts that listener for every unix address, next to the ops, peer and MCP siblings it already brings up. The address stays derived, so a mount is still one address. The existing test passed the sibling address by hand and called that the shape production runs. Production passes one address, so the test could not fail. It now calls Listen the way a plugin main does, which is what makes it cover the wiring. ?UxWtree be4a914921543bb8aa2caae1c8c8d29a6785a6bd parent 3ab8d5e9be963d5d07ba9db02b91287555b536ea author Zach Kelling 1786587317 -0700 committer Zach Kelling 1786587317 -0700 mcp: answer server/discover, and say 2026-07-28 MCP 2026-07-28 made the protocol stateless, and zip already was — there is no Mcp-Session-Id anywhere in mcp.go, nothing is remembered between requests, and tools/list answers without a preceding initialize. So the door met the new revision's central requirement before the revision existed and went on announcing the old one, which is the version a client negotiates against. What was actually missing is one method. The new spec drops the mandatory handshake, so `initialize` stops being a lifecycle step and becomes one more way to ask "what are you"; `server/discover` is the name the spec gives that question. It is optional, which is exactly why it has to be answered — a client that uses it to inspect a server before committing got `method not found` from a door that is otherwise fully stateless, and reads the whole thing as pre-2026. Both names now return the same payload, and `initialize` stays for every client still speaking the older revision. Nothing needs a migration window: roots, sampling, logging and the HTTP+SSE transport are what this revision deprecates, and zip never had any of them. ASx:tree c849c56fc43afc5aefde3c92240a9e2545f309e6 parent 268afe79146c16b0d6edd2dcb756717f27f82a5c author Zach Kelling 1786584843 -0700 committer Zach Kelling 1786584852 -0700 the version every address shares is not part of its name /v1 is on 2,026 of this estate's 2,473 operations, which is to say it tells none of them apart. A segment earns its place in an id by distinguishing two operations; this one is a constant, and it rode four surfaces at once — the OpenAPI operationId, the MCP tool name an agent reads on every turn, the by-name call key, and the CLI's spelling — so the constant was paid for four times, most expensively in a tool list where every token is context not spent on the question. ID drops it, and only it: the leading segment, only when it is the default. A later version is the EXCEPTION and keeps its segment, which is both how it stays honest and how it stays unique — get_agents is /v1/agents and get_v2_agents is /v2/agents, so the two cannot collapse onto one name the walk would then refuse to publish. The default is implicit; a departure from it is not. The pinned names in the suite move with the rule, because they were pinning the rule. TestServePathAllocsAreChainDepthInvariant fails here and on the base commit alike — 34 allocs either way, unrelated to naming. -8,x?tree 1a08aa312a80b9a8d551e9d53e8d0f061d198ca5 parent d8b7f009a08182ecacbdbb7b67c2f2a67db1f69f author zooqueen 1786429119 -0700 committer zooqueen 1786429119 -0700 http: a path is a socket here too The relay reaches a plugin's plain-HTTP leg over a unix socket, and the built-in HTTP transport could only bind tcp — so that address was read as a host named /var/lib/cloud/run/… and never listened. A path names a socket on this transport for the same reason it does on ZAP: the shape of the address says what kind of place it is. The test now runs the production shape end to end — a zip child on ZAP plus its HTTP sibling, a real wsx socket echoing through a real mount. j?xtree f5f101e558412e97aa484135138bdfdfa40a1ed4 parent f3d763a0502f9c87759dea6b3a52e110857628c2 author zooqueen 1786429022 -0700 committer zooqueen 1786429022 -0700 mount: relay an upgrade instead of parsing what follows it A plugin's socket carries ZAP frames — one request, one reply — and an upgraded connection is neither. The host wrote the 101 through and then kept parsing HTTP, so the first frame the client sent arrived at the header parser as nonsense and the connection died: "error when reading request headers", first byte 0x81. Every websocket behind a mounted plugin failed on its first message, and the session the plugin meant to run after the handshake never started. An upgrade now goes to the plugin's plain-HTTP leg, a sibling of the socket it already listens on, and past the switch the hop stops reading and moves bytes. A plugin that declines to switch still answers its own reply, because refusing a socket before it opens is how an unauthorized one is refused. `Vxtree 28451a1af56bb42d3b315da2fb33755a2bacc34d parent 78b2cfe76709ce8ba3eb8d14aa5208f392f32dba author Zach Kelling 1786408234 -0700 committer Zach Kelling 1786408234 -0700 say it once Co-authored-by: Hanzo Dev M^*xXtree f0b08d38959e6bf4ee72a31a30f3cb64c66d6be2 parent 890d5c6538ce8810f4b6b0e18d7f38423f77b54a author Zach Kelling 1786403983 -0700 committer Zach Kelling 1786403983 -0700 the transport imports as http, unaliased zap-proto/http is package http now (v0.3.5) — the last element of its own module path, which is the name Go resolves an unaliased import to. My v1.27.4 called it zap, and that was wrong twice: it did not match the module path, and this package imports zap, the wire format, so one word meant two things in the same file. No file here imports net/http, so the transport needs no alias at all. Co-authored-by: Hanzo Dev „xtree 495cfe122332cc25eda9fb94dbeecc198ac16db6 parent f63305da8bf6eb2c92fd60e2ec997f3c271234f4 author Zach Kelling 1786401591 -0700 committer Zach Kelling 1786401591 -0700 the transport is zap, not zaphttp zap-proto/http renamed its package (v0.3.3): the module path already says http, so zaphttp said it twice and built a compound word into every file that touched the wire. This module imports it under its own name now. Co-authored-by: Hanzo Dev Lx0tree d80a90607f2864d5c99720742077b71b349229cd parent e7a4b06a6cfc40c6b9d6d0b67125ab1efb82346f author Zach Kelling 1786400382 -0700 committer Zach Kelling 1786400382 -0700 the brand Host reaches a mounted child, end to end Two halves of one path, and fixing only the first is why the last attempt looked right and changed nothing. forward() overwrote the Host header with the child's dial address. A client dials its own address and never reads that header to find the far end, so the value was routing nothing — it was destroying the one fact a callee needs to serve more than one brand. zap-proto/http then dropped it again: the encoder excluded Host from the headers slot as "frame-owned" while nothing in the frame carried a host, and the decoder reconstructed it from the very header the encoder had removed. Every request over the ZAP wire arrived with an empty Host. Fixed in v0.3.2, required here. TestMountedChildSeesTheCallersHost goes through a REAL mount rather than a stubbed client, which is what the earlier unit test missed: it built its own request, so it never met the serialization the server path takes. It fails on either half alone. Co-authored-by: Hanzo Dev x[ tree 3f44973756bee1324a4e13405a53050509bf222f parent 4d8d856b6fe7eaa6be3ea3950b5808e409ea8525 author Zach Kelling 1786386019 -0700 committer Zach Kelling 1786386019 -0700 the caller's Host survives the plugin hop, so a child can answer as the brand it was asked as forward() overwrote the Host header with the DIAL ADDRESS on every proxied request. A client dials its own address — HostClient.Addr, zaphttp.Dial(addr) — and never reads this header to find the far end, so that value was not routing anything. It was destroying the one fact a child needs to serve more than one brand: which host was asked. hanzoai/iam is where it showed. It serves every brand from one instance and resolves each brand's OIDC issuer from the request Host, so mounted as a plugin child it was asked as "/var/lib/cloud/run/iam.sock", matched no brand, and fell back to its single default — lux.id and zoolabs.id minting tokens claiming iss=hanzo.id, which their own relying parties reject. Config could not reach it: the brand map was in the child's environment and the Host never arrived. The dial address stays the fallback for a request carrying no Host of its own (the MCP hop builds a fresh one), because HTTP/1.1 requires the header. Read through req.Header.Host() rather than req.Host(): the latter goes through the URI, which parses on first touch — 34 allocations on a hop that is meant to cost none, which the alloc gate catches. And a request that already has a Host is now left ALONE rather than re-set. The test measures the SERIALIZED request. fasthttp writes the Host header from the URI once the URI has been parsed, so reading either field in memory can disagree with what actually goes over the wire; serializing is the only reading that cannot. It fails on the old code and passes on this one. Also: every test that binds a unix socket now does it in a short directory. A socket address is 104 bytes on Darwin and t.TempDir spends most of them on the test's own name, so 9 tests failed with "never began listening" — which reads as a timing bug, is green on Linux, red on every Mac, and breaks when a test is RENAMED. Suite goes 11 red to 2, both of which are pre-existing and platform: SO_PEERCRED (no LOCAL_PEERCRED path on macOS) and the alloc gate, which fails on pristine v1.27.1 when run in isolation. Co-authored-by: Hanzo Dev ɍ;KxHtree 1f77c5569b999947a6ef9eddfdcb5f15e5a1be76 parent 1e810926c5eb7508ab878faae499bfc6fb46c067 author Zach Kelling 1786189442 -0700 committer Zach Kelling 1786189442 -0700 zipdoc: a wrapped handler documents the handler, not the wrapper The handler position takes `f(x)` in two unrelated shapes and handlerDoc read both as a builder — a function returning the handler, whose own doc comment is the only one there is. An ADAPTER has the same shape and the opposite meaning: its argument IS the handler, and its doc describes the adapter. So every operation registered through one published the adapter's sentence. Measured on hanzoai/cloud: 55 operations across 24 apps described `cloud.Handle` or `cloud.Terminal` instead of themselves — "Binds a Service-scoped handler to a route", true of every route that uses it and about none of them — while the sentence each handler had already written sat unread one call inside. The arguments tell the two apart, and nothing else has to: a builder takes what the handler needs, a wrapper takes the handler. Recursing on the last func-typed argument reaches through nested adapters and leaves the builder case exactly as it was. Zڔbx$tree c080b0f5b502815a8b2ed480f9c46dfc4ae4be7c parent 7afa7ee42b63bb448b125f836e95b925569bd9c1 author Zach Kelling 1785994709 -0700 committer Zach Kelling 1785994709 -0700 mcp: derive readOnlyHint from the op's method Every typed op became an MCP tool with {name, description, inputSchema} and nothing else. An MCP client that cannot tell a read from a write must assume WRITE, and Slackbot says so outright: an unclassified tool defaults to write classification and prompts the user Allow / Always / Deny before EVERY call. Measured on hanzoai/cloud's live surface: 1,323 tools, 0 with annotations, 0 with readOnlyHint -- so every read cost a confirmation. That is the difference between an agent that answers and one that interrogates. The answer already lived in the op: a GET is a read by construction, so no op can be annotated inconsistently with the route it IS, and 1,323 tools are classified without touching one of them. HEAD rides with GET (a read whose body is discarded). Everything else is left UNSAID rather than asserted safe: only the true half is emitted, because readOnlyHint:false is the client's own default and writing it would claim we had classified a mutation when all we know is that it is not a GET. An unknown or custom method therefore fails toward caution. go build ./... clean. The one failing test, TestServePathAllocsAreChainDepth- Invariant (34 allocs/request), fails IDENTICALLY on unmodified main -- verified by stashing -- so it is pre-existing and unrelated. Co-authored-by: Hanzo Dev xtree 61cc8714f34480578515f2897fea9952ef03f8ce parent f048747237e90055cd8ea8fce37baec003d8baef author Zach Kelling 1785990539 -0700 committer Zach Kelling 1785990592 -0700 here: a co-resident caller runs the op, and MCP rides zap-proto/mcp Two things that are the same thing: a call does not need a wire, only an address, and a protocol layer belongs in the module that names it. Ask names an app and reaches it over that app's canonical socket. When the app is THIS process that socket is a loop -- the value the caller holds is serialized, handed to the kernel, read back, parsed into a fresh copy, and dispatched to a function pointer that was in memory the whole time. Nothing about the call needed a wire; only the ADDRESSING did, and addressing is what a by-name call already has. So a bound listener records which App answers for it, Serving reads that back, and Here runs the op through the op's OWN invoke seam -- the same validate -> authorize -> run core a REST request, an MCP tools/call, a CLI command and a socket call all land on. One fewer transport, not one more. That is what a co-resident caller uses INSTEAD of building a request for its own router to take apart again. The pattern it replaces cost hanzoai/cloud a re-entrancy counter keyed on a goroutine id parsed out of runtime.Stack, because dispatching a request into the whole app re-ran every edge middleware and a middleware that read the app it was serving recursed without bound. A direct op call cannot express that shape: it enters one op, not one router. MCP now comes from github.com/zap-proto/mcp v1.0.5 rather than being hand-rolled here, so it sits beside zap-proto/http as a protocol layer over ZAP instead of inside the framework as a special case. TestServePathAllocsAreChainDepthInvariant fails at 34 allocs/request against a budget of 1. It fails identically at v1.26.0 -- verified in a clean worktree at that tag -- so it is pre-existing and not this change. Named here rather than left for the next person to rediscover. {ѕnxtree fb58e4d193783966c06cb841d39b247d885e6a02 parent 6c2674394d9d14733c469196029e3041ff290140 author Zach Kelling 1785982440 -0700 committer Zach Kelling 1785982440 -0700 a peer that is this process is a function call, not a socket zip.Ask names an app and reaches it over that app's canonical socket. When the app IS this process — a fused binary, or a service asking one of its own ops — that socket is a loop: the value the caller holds is encoded, handed to the kernel, read back, and parsed into a copy for a function pointer that was in memory the whole time. Only the ADDRESSING ever needed a wire, and a by-name call already has that. So a bound listener records which App answers for it. Serving(name) reads it back and Here runs the op through the op's OWN invoke seam — the same opByName the socket plane uses, the same validate and authorize a REST request and an MCP tools/call get. registeredOp.direct and registeredOp.invoke now share one contract closure rather than each carrying a copy, so there is no way into a handler that skips a check another way makes; direct differs only in that it is handed the In instead of bytes to decode it from. Serving goes false before the listeners close, so the in-process door and the socket cannot disagree about whether the app is up. This is what a co-resident caller uses instead of building a request for its own router to take apart again. That pattern cost cloud a re-entrancy counter keyed on a goroutine id parsed out of runtime.Stack, because dispatching into the whole app re-ran every edge middleware and a middleware that read the subsystem it was serving recursed without bound. Entering one op cannot express that. Co-authored-by: Hanzo Dev 5g,@xtree c5da85664723dc5e919515ef96046335e1bc54c6 parent 8687aa1bb3a9401e7ae7f6b0c228ff5eef23632c author Zach Kelling 1785961538 -0700 committer Zach Kelling 1785961538 -0700 the id rule owes its own test ID is now THE rule an operation's name is derived by — the document, the tool list, the call plane and the command all read it — and it had no direct test. Every case pinned here is a collision the encoding has to survive, not a spelling preference: a parameter against a literal of the same name, the hyphen that must not fold into the separator, the four spellings of one parameter that must reach one name, and the wildcard that has no name of its own. The '_' aliasing it CANNOT resolve is pinned too, so the day someone tries to fix it there is a test saying the walk's uniqueness check is what catches it. cloud held the param-vs-literal case as a unit test of its own copy of the rule. The copy is gone, so the test comes here, where the rule is. Co-authored-by: Hanzo Dev ;_xO tree 2fedf10aef006b1f7741fc9acd0d18364ce55be8 parent d96b45b06b7880d98e48f0605479375c72438a5b author Zach Kelling 1785952997 -0700 committer Zach Kelling 1785953559 -0700 one rule for an operation's name, and it is the published one An operation's id was derived twice, by two rules that disagreed. zip spelled it dotted(prefix) + "." + method+path-with-the-punctuation- dropped, so POST /v1/agents/targets declared in a Group("/v1/agents") was v1.agents.post_targets. cloud's openapi package spelled it from the ABSOLUTE path with a parameter written "by_", so the same operation was post_v1_agents_targets. Both reach the published document — cloud's Fold hands a typed op's own id straight through — so openapi.yaml carries BOTH spellings depending on whether a route happens to be typed, and an agent that read the document and asked for the tool it named got "no such tool". The document's rule is the published one (every generated SDK method, every docs entry, the hanzo command tree), so it is the rule that stays. zip moves to it: - ID (exported, replacing defaultOpID) writes a parameter "by_" and sanitizes a segment to [a-z0-9.-]. '-' and '.' survive because '_' encodes '/', and folding them collapsed /v1/pricing-policy onto /v1/pricing/policy once already. Every spelling of one parameter reaches one name: ":id", ":id?", ":id", "{id}", "*". - occurrenceID derives from the ABSOLUTE path the occurrence answers at, not from a dotted qualifier built out of the composition's shape. Both invariants hold: a DECLARED id still survives composition verbatim, and two inclusions of one definition still get two ids — they have two absolute paths — with nothing positional about it. What changes is that a group-structured app now derives the SAME id as the flat one, which is the whole point: the id is what the address says. dotted is deleted; it had no other caller. Exported because cloud's openapi package held the identical rule as a second copy. One rule, one place — cloud now calls zip.ID. Also retracts a figure I published in 2c2991e: hanzoai/iam contributes 95 schemas, not 345. 345 was the changed-line count in plugin/iam/openapi.json, not the schema count. Prose only, in two doc comments; the code was right. Co-authored-by: Hanzo Dev -؜yxctree 66dc24eed463d8916de10a286ea157dab0ef0df8 parent 277026897bbe334e39d31e12c865f14e445f6df1 author zooqueen 1785933157 -0700 committer zooqueen 1785933157 -0700 an argument addresses a resource, and may not address a route Remote.Invoke percent-encodes every path argument (urlEscape) precisely so that what a caller passes as a value cannot become part of the path. fasthttp then undid it: its default serialisation is appendQuotedPath(u.Path()), and Path() has already decoded %2F and resolved "..". Invoke(GET /v1/platform/apps/:app, {"app": "../../../v1/iam/users"}) → GET /v1/iam/users One operation's ARGUMENT addressing a different operation entirely, on whatever credential the caller attached. Every decision made above this line — which command was named, whether that command may run, whether it mutates — is made about a request that is not the one sent. Two settings, because two things have to be told and only one of them is read per transport: Remote.do sets it on the REQUEST, so RequestURI() serialises PathOriginal() — the bytes Invoke built. This is what carries the property over ZAP (the default transport) and anything RegisterTransport adds. transport.go sets it on the http and https HostClients, because HostClient.doNonNilReqResp ASSIGNS req.URI().DisablePathNormalizing from its own field (fasthttp client.go:1631). On those two transports the request's own setting is overwritten, and the client's is the only one that survives. The request-level line alone measurably does not hold — that is how this was found. Pinned on a live server across the cases that matter: a plain id arrives unchanged, "../../.." arrives escaped as one segment, a bare "/" arrives as %2F, a pre-encoded %2F arrives as %252F rather than collapsing a level per hop, and a bodyless op's flags still ride the query string untouched. Co-authored-by: Hanzo Dev KUxWtree c7e3df023570c15905470135c6d5a4c8a909e042 parent cc8f15a88c455131a294d0df16ea2ec7e8b45838 author Zach Kelling 1785919746 -0700 committer Zach Kelling 1785919746 -0700 a group has no name, so it must not answer for who wrote the op Graft qualifies a composed type by the app that DECLARED it — iam.Application, iam.Role — because two children may honestly both call a type Application and a document that let the second overwrite the first publishes one name for two shapes. Every generated SDK then binds whichever the merge read last. composeOps asked the ENCLOSING definition for that name. App.Group returns an App with its name stripped (groupConfig), and every real app declares its routes in groups, so the question went to a nameless thing and the answer was nobody. One level with no group still worked, which is why nothing said so: hanzoai/iam publishes 345 schemas through groups and every one of them arrived in cloud's fleet document unqualified, colliding with the host's own Application and Role. The author is the nearest NAMED ancestor, carried down the walk as scope.origin — computed once at the inclusion site, inherited by every group beneath it, empty at the root so a program that composes nothing is byte-identical to what it published before Origin existed. Co-authored-by: Hanzo Dev D0xtree b36d27824d0f9ab261a0cb1811f8be3f442c4770 parent e570a16f6af0d119218da14a64f5e9e97a7b9f53 author zooqueen 1785906406 -0700 committer zooqueen 1785906406 -0700 metric v1.10.0 — the OTel bridge left the root package, and with it the SDK luxfi/metric moved its OTel adapter to metric/otel, so importing the registry no longer drags 34 OpenTelemetry SDK packages into every consumer. zip uses only the root package — the registry, EncodeText, the ZAP exporter — so this bump takes zip, and everything that inherits zip, to zero OTel packages linked. Module graph pruning even drops them from consumers' go.sum. This completes the ruling the telemetry work shipped under: nothing a plugin inherits. Co-authored-by: Hanzo Dev  :~xtree d720ff031c0407e887d46560fd95a1fd3264212c parent ed9616933e63f81c566d12b195bc2512ce7e44d9 author zooqueen 1785905399 -0700 committer zooqueen 1785905399 -0700 telemetry: spans and the request record ship over native ZAP The request boundary already holds everything a server span and a request record contain, so both are structs filled from data it has: the trace, span and parent ids it minted or joined, the route template as the name, start and duration, an outcome-derived status, and the caller's org when a gateway parked one. They are appended under one lock, drained once per tick and at shutdown, and shipped as JSON in a ZAP envelope — internal/o11y declares the batch shapes itself, no SDK, no protobuf, nothing a consumer inherits. The keys are the collector's vocabulary, not ours. It reads a path out of url.path / http.target / http.route / path in that order, so those are the keys this fills; http.path, which an earlier draft shipped, fills nothing. The contract/ module proves it the only way that stays true: it starts the collector's real receivers, serves one real request, and asserts on the structs those receivers produced. It is its own module because the collector already requires zip — the proof would otherwise be a cycle. The address is the switch, spelled O11Y_SPANS_ADDR / O11Y_LOGS_ADDR / O11Y_METRICS_ADDR — three names because the collector binds one listener per signal and promises no adjacency between them. The metrics name replaces O11Y_METRICS_ZAP_ENDPOINT, which deployments had already stopped matching; the socket preference is deleted because the collector only ever binds TCP, so that branch could not run. Nothing stated means nothing starts: no exporter, no node, no dial, no goroutine. An app's own logging stays its own. Only zip's request line ships to the log ear; teeing a program's every log line off the box is one decision for luxfi/log to make once, for everything that logs. Co-authored-by: Hanzo Dev V>ܐ[xOtree 53cacb2350b6c4bd34ec6853f9008e952247e17a parent 090bac90f1a396692a1b8b6567902a49c4d1cdda author Zach Kelling 1785900755 -0700 committer Zach Kelling 1785900755 -0700 an op's address is a value its input already carries zip.Address is bindURL read backwards. registerTyped binds the segments the router matched onto the op's In, so by the time a handler runs the In IS the address's parameters, named and decoded. Anything that has to rebuild the concrete path — a relay handing the call on to something that speaks HTTP — otherwise spells the address a SECOND time by hand, and the hand-built one is what gets requested, so the route pattern it drifted from is never consulted and never contradicted. It is deliberately the inverse and not a new rule: same field walk (wireFields, so promotion counts), same naming (urlFieldName, so `url:` beats `json:`), same case-insensitive match. The tests bind a value in and read it back out rather than comparing against a table someone wrote down. zip.Template is the same address in the spelling a DOCUMENT writes — ":traceId" -> "{traceId}", with the router's own business (a constraint, an optional marker) dropped, because those say how a segment is matched and not what it is called. closeColonParams was already that function under a private name and now delegates to it, so the document's spelling has one implementation. Co-authored-by: Hanzo Dev '&}x)tree 60c103df130b826cc56d18c1988ff25ca3c269d5 parent 7ceef82acd1ef164a2f1b49f737661b8b30c9fe3 author Zach Kelling 1785897042 -0700 committer Zach Kelling 1785897042 -0700 zip.Mount is a proxy, not a mount — the name now says which of the two it is `Mount` meant two unrelated things across the fleet at once: zip/remote.go func Mount(prefix, addr string, decl ...Declaration) (*App, error) 112 subsystems func Mount(app cloud.Router, deps cloud.Deps) error The second is the fleet's registration contract, stated in hanzoai/cloud's package doc and checked by cloud.MountFunc. The first is a leftover: Mount was one of five composition verbs (Listen/Mount/Add/Graft/Use), the other four were dissolved into Use, and this one survived by being the only one that pointed at another process. A reader seeing `Mount` in a diff could not tell which was meant without counting arguments. Renamed to Proxy, which is what it BUILDS. Every route it registers runs the one handler this file calls `proxy`, whose whole body is forward() to the address given; "proxy" is the term of art for a local stand-in whose handlers hand the request to someone else, so it needs no gloss. It is also a noun, which a function returning a value should be — composition is Use's job now, and the doc has said so since the four verbs were dissolved. NOT Remote: [Remote] already exists here and is the CALLER's side, a client executing commands against a service elsewhere. This is the SERVER's side, a definition standing in for that service inside this program's routing table. Two sides of one wire are two things. Also renamed the tests that named it, and mount_test.go -> adapt_net_http_test.go with it: those pin AdaptNetHTTP, a THIRD sense of "mount", and TestMount_* named none of the three. Regression set empty: TestServePathAllocsAreChainDepthInvariant fails identically on the parent commit (an allocation bound, untouched here). Co-authored-by: Hanzo Dev ˺g,x2tree e4b99be39728addc0a7005369538005d8bd2f618 parent dbf00910f1355f54dde7c0be566903ec693102b4 author zooqueen 1785891627 -0700 committer zooqueen 1785891627 -0700 an app's own instruments ride the one registry Metrics returns the standard Registerer over the registry the framework's request instruments already live in, so a domain gauge — a queue depth, a fleet probe verdict — appears on the same /metrics page and travels the same export as the built-in numbers. One registry per program, one road out, nothing to configure. The caller holds no framework type: the standard interface is the whole surface, and the registry stays owned here. Co-authored-by: Hanzo Dev Afxgtree 7bf8f180b810d38cfe750718cd25cb06f442b966 parent 6cc782199ba676de099cc824aa8747a973bd5beb author zooqueen 1785887469 -0700 committer zooqueen 1785887469 -0700 spans and logs travel the way metrics already do: native batches over ZAP One protocol for the three signals, shapes declared once in internal/otlz and pinned both directions against what the receiver accepts — a field invented fails as loudly as a field missed. No OpenTelemetry SDK is linked by otlz; importing the receiver for tests would have grown the module graph to 1145 modules, so the contract is goldens, measured not assumed. Zero configuration. A program reports because it exists: each signal resolves its collector by convention — an override if one is set, the well-known socket if it exists, loopback's conventional port otherwise — re-resolved on every attempt, so a collector that starts later is found without a restart. Absence is free: lazy dial, the batch dropped, one line when export begins working and one when it stops, with the reason. Over the socket the kernel attests which process exported a batch, which loopback cannot. Two races the tests forced out: the ship decision moved off the serve goroutine, so a request answered immediately after Serve no longer loses its span; and export starts in the last synchronous step Serve and Listen share, so a short-lived process cannot reach Shutdown before the flush hook exists. The runtime-directory scheme lives once in internal/sock; RuntimeDir and SocketPath delegate to it. luxfi/zap moves one patch, v1.2.6 to v1.2.7. Co-authored-by: Hanzo Dev sDnxtree c345aba8cd7404553f7122b0d3941688d2b7b495 parent cf68b751f35048c3e7d329a7b063518cdfb2d0b7 author zooqueen 1785879408 -0700 committer zooqueen 1785879408 -0700 an app reports because it serves: telemetry is the framework's Every program built on zip now emits one log line per request through its own luxfi/log logger — method, path, status, duration, trace and span, plus the caller when the environment parked one — and RED metrics through luxfi/metric, with W3C trace context joined when a request carries it, minted when it does not, and propagated on Call with no handler code. /metrics renders the one registry, and export speaks the shipped ZAP exporter, which is what o11y ingests. Config.Telemetry{Addr, Off} is the only switch; the default is on. The boundary is installed outermost by materialise, so requests that match nothing — 404s, preflights — are still counted; per-route composition cannot see them. Two defects the tests forced out: the status is derived from the handler's error, because at the boundary the response still reads 200 (fiber writes the real status after unwinding, so every refusal would have recorded as success); and the route label reads the not-found sentinel, because an unmatched request leaves the middleware's own registration in place and would otherwise be indistinguishable from a real root leaf. middleware.Logger and middleware.Telemetry are deleted, not deprecated: telemetry an app can lack is the defect this closes. luxfi/metric moves to v1.9.1 — v1.9.0 is the published build whose registry constructors sit behind a build tag nothing sets, so counters accepted Inc() into a registry nothing gathers and /metrics served empty. Co-authored-by: Hanzo Dev Hrx Ltree 56fa70b863685ae0f3a1da733643042c453658b3 parent 0ce276b638336c2c9056e84be4ea6cb337eb44a4 author Zach Kelling 1785860485 -0700 committer Zach Kelling 1785860485 -0700 Shadow is removed: a braided program is unbraided, not accommodated v1.24.2 shipped two fixes. The operation-id one stays and is untouched here: a declared WithOperationID survives composition verbatim (measured on hanzoai/o11y — 353 ops, 217 declare an id, all 217 were being renamed by a host prefix and now are not). The address one, App.Shadow(), is removed. Shadow existed to make an op declarable in one place and answerable in another: a service installing its published table of ops onto the router its implementation already serves on, a test registering a second handler at an address deliberately. Both are the same shape — a declaration and the handler that satisfies it, written apart, with a framework verb holding the two ends together. That is a braid, and a framework that grows a verb per braid grows one verb per caller. The fix belongs in the caller: a typed registration is ALREADY both halves, the handler the router installs and the op the document, MCP tool list, CLI and SDK all read, so the declaration and the answer can simply be the same line. Use composes definitions, Group scopes them, and between them every shape Shadow was written for is expressible with one claim per address. So the address check goes back to what it was, exactly: one registration at an address, both parties named when there are two, no scope and no option that can talk it out of an accident. addrClaim, addressErrors and addressRules are gone with it — 190 lines of walk.go that existed only to reason about the SHAPE of multiple claims at one address, a question the language no longer asks. Removed: App.Shadow, OpScope.Shadow, route.shadow, App.shadow, wrapRouter.shadow and yields, App.method's shadow parameter. wrapChain and OpScope lose their nil-wrap branches, which existed only for a Shadow-only scope with no middleware to compose. No caller outside this repo referenced any of it at a released tag. Tests: shadow_test.go deleted (250 lines, ten cases, all about the removed verb). oneclaim_test.go replaces it with three that pin the rule from both sides — the braid is refused with both parties named, one registration declares AND answers, and Use+Group place a definition's ops wherever a host wants them with one claim per address. Everything else is unchanged, including all of declaredid_test.go and the unnamedApp/billingApp split in compose_test.go, which are the id fix and not this one. 319 root-package tests pass on a clean testcache and under -race. Co-authored-by: Hanzo Dev ֜x<tree d980726d0869c622671e648471bc04f99e03d05d parent 222d7f196d6db38f2790b59e9aa014beb5aa3a43 author Zach Kelling 1785835375 -0700 committer Zach Kelling 1785835375 -0700 a declared id is not composition's to edit, and a yielded address has a spelling Two defects, one theme: a declaration the programmer WROTE is not something the shape around it gets to overrule. occurrenceID qualified every operation id with its occurrence's prefix, including one the author had written with WithOperationID. Including github.com/hanzoai/o11y under /v1/o11y therefore renamed its published ops to v1.o11y. — every MCP tool an agent had cached, every operationId, every CLI command, every generated SDK method — as a silent side effect of one wiring line. LLM.md's own Graft table has said `operationIds | untouched` since v1.18; the walk had stopped obeying it. Measured on o11y: 217 of its 353 ops carry a declared id, and all 217 were renamed by a host prefix. They are not now. The rule asks one question first. A DECLARED id survives verbatim, because it is a published name and a service embedded at a prefix publishes the same operations it publishes standalone. An UNDECLARED one is still qualified by its occurrence's prefix, deterministically and from the composition's shape, because there no promise exists and a real ambiguity does: one definition included twice is two operations and a document cannot hold two under one id. Where the two meet — declared AND twice — is now a refused program that names both occurrences and both fixes, instead of a silent rename that resolved an ambiguity the author never saw. Two registrations at one address was a refused program, and that refusal is right. It also refused two shapes the estate writes on purpose: a service installing its own published TABLE of ops onto the router its implementation already answers on (o11y: 353 ops, publish() after the service's own routes — "order is the contract"), and a second handler at an address declared to pin what the router does with two (cloud's openapi generator test). Nothing in the program said which it was, so the check could not tell them from an accident. App.Shadow() says it. Scoped like With, and for the same reason — a group is an App, so app.Shadow().Group(p) carries the property onto the group and every leaf beneath it inherits it, including leaves registered later. Nothing about the wire, the registry or any projection changes: the route installs exactly as before and fiber chains it behind whatever came first. Only the conflict check changes, and into two NARROWER rules rather than none — - exactly one claim at an address may decline to yield, and it must be the FIRST, because the router answers with the first registration. A shadow ahead of what it yields to would stand in front of it, so "order is the contract" is now checked rather than stated. Two claims that both mean to answer is still the accidental collision, refused in the same words. - at most one claim may carry an op. A document keys an operation on method and path; there is one slot, and two ops asking for it would publish one and drop the other. Shadow yields an address to another HANDLER, never a document slot to another op. A shadow that is the only claim simply answers, which is what lets ONE table be mounted into a host that has an implementation and into one that does not. Shadow is on the concrete *App and deliberately NOT on the Router interface: Router is implemented from outside this package method by method (cloud's scope, commerce's mintRouter), and widening it is what stalled v1.19 adoption once. Tests: declaredid_test.go and shadow_test.go, twelve cases, each failing before the change — the id one with the literal v1.o11y.CreateRole, the address ones with the refusal origin/main emits. compose_test.go gains unnamedApp, the same definition with no declared id, because a definition that names its ops cannot be the one included twice: the diamond is a test about the UNDECLARED half of the rule and now says so. Co-authored-by: Hanzo Dev s2הPxtree d45849870f11c26b9dce83a08b275c819e4b4e52 parent 96eaf1c1e526bfa48b510ff7f4e78800b98dc8bf author Zach Kelling 1785830821 -0700 committer Zach Kelling 1785830821 -0700 Test prepares, because it promises the generation serving would run App.Test says it "builds the program if nothing is live, exactly as serving would, so a test exercises the same generation a request would". It did not. Serving calls prepare, which installs the DEFERRED PROJECTIONS — /mcp, the OpenAPI document, the op-call plane, the plugin route. Building alone installs none of them, so those four addresses answered 404 under Test and 200 in production. That is the worst shape a test can have: it cannot see the surface it was written to check, and the closer it gets to the real program the more confidently it reports the wrong thing. hanzoai/cloud's MCP tests only passed because callers reached for an exported Prepare and remembered to call it — which is why unexporting Prepare broke them rather than fixing them. The projections belong to "run the program", not to the caller's discipline. prepare is sync.Once, so a table test that calls Test in a loop still installs them once; TestTestPreparesIdempotently holds that. Co-authored-by: Hanzo Dev wjxQtree 5c6064c4efd0f272b18f125f0a5f6b06bebdfde9 parent 57d4cfa90a510b76b507e00de055e69a44535682 author Zach Kelling 1785823815 -0700 committer Zach Kelling 1785823815 -0700 zip owns its TestConfig, so nothing has to import fiber to write a test App.Test's doc comment tells callers to use it INSTEAD of reaching through App.Fiber — and its signature took a fiber.TestConfig, so a test that merely wanted a timeout imported the router this package exists to keep out of its callers. The advice pointed back at the thing it replaced. hanzoai/cloud has 75 call sites doing exactly that, every one of them through the escape hatch, and every one of them setting only Timeout and FailOnTimeout. zip now declares those two fields itself. Two, because two are what the estate uses: a knob nobody turns is a promise about the router underneath. wrapRouter.Fiber() goes with it — dead since Router stopped requiring the method, and the last place a decorator claimed to have a *fiber.App of its own. What remains is App.Fiber and Ctx.Fiber: both documented escape hatches, both on a CONCRETE type, neither on Router. That distinction is the containment rule, since requiring fiber on the interface a decorator implements is what made it unimplementable outside this package. TestFiberDoesNotLeakIntoTheExportedSurface reads this package's own AST and holds that line, with the two hatches named and justified. Verified by regression: put fiber.TestConfig back on App.Test and it fails naming the exact signature. The leaks arrive one convenience at a time and each looks reasonable alone, which is why this is a test and not a review habit. Co-authored-by: Hanzo Dev Wvbx)tree c012dfe1c886c7514aa011b0c2df94ddd665ba6a parent b2159fbf097ace77de2ad8dc1a6b18d27a27fcc5 author Zach Kelling 1785823481 -0700 committer Zach Kelling 1785823481 -0700 test: a definition has no absolute address until composition resolves it Two assertions for the same fact, from opposite sides. The first holds what every consumer depends on: whatever address the router SERVES, the declaration NAMES. Those are computed by different code paths — materialise walks the composition tree, composeOps recomputes each op's absolute path through o.abs — and nothing in the type system makes them agree. Now something does. The second documents why a decorator cannot ask a Router "what is your prefix?" and get a URL back: the question has no answer at registration time. The same definition can be included at more than one site, so a group has no single absolute prefix until a build resolves the tree. OpScope is a registration-time value; its Prefix is the local join only. That is not a gap, and it is worth a test because it reads like one. hanzoai/ commerce's mint layer asked exactly that question through the removed escape hatch — r.Fiber().(*fiber.Group).Prefix — and got an answer only because fiber flattened a group into one prefix at declaration. That approximation is silently wrong the moment a definition is composed twice, which is the shape zip exists to make ordinary. A consumer that needs the address a route is served at reads it from the declaration, after composition. Co-authored-by: Hanzo Dev 1-ux_tree f6856b1b1a8ce70e956d7e4a4e49219f11ebc2a6 parent 889cf8acedcb5c6f4803127502240a7c4106fb89 author Zach Kelling 1785729619 -0700 committer Zach Kelling 1785729619 -0700 acting for another org, a failure with a body, and a verbatim passthrough Three survivors, and one of them was a live cross-tenant bug. ActingAs derives a caller acting on another org's behalf. It does NOT weaken the laundering guard: it cannot invent a caller, only re-point one already authenticated, and with nothing authenticated it refuses — so stating an identity still cannot override an authenticated one. What it adds is that the derived caller carries both facts. Org is whose data the call is for; ActedBy is who chose to touch it; the original actor survives a chain of hops; and both travel in the forwarded identity set, so the impersonation is visible at the next hop instead of the trail ending at this process. That is the wrong-ledger bug: the admin's own org was being forwarded. It deliberately does not authorise. Whether a principal may act for an org is a tenancy policy, and policy belongs in an Authorizer — this supplies the vocabulary and the audit trail, nothing more. WithStatus now accepts a declared non-2xx, for an op whose failure carries a typed body the error envelope cannot express. The doctrine survives where it was load-bearing: an error return still renders {status, code, error}, and that is still the way to answer a failure with nothing extra to say. The test that pinned the old rule is rewritten to state the new one rather than deleted. Gap 9 needed no change: json.RawMessage as the input already round-trips a body verbatim, unnamed fields and all. Measured, then pinned — a passthrough is expressible as a typed op with an opaque declared body, so the RequestOf refusal still stands. Co-authored-by: Hanzo Dev mexPtree 84ce589d593dd151500cec4a2bf9bc11ca1cc114 parent 78328b8f15bf353bfed9759142bf2b54aaee54d6 author Zach Kelling 1785726246 -0700 committer Zach Kelling 1785726246 -0700 an answer states its response headers, and Host already binds The third and last gap holding Bridge open. Symmetric to the status fix: the ANSWER states its headers, declared on the op and valued by the returned value, so there is no mutable slot on the context. A slot is invisible to every projection, which is how a browser session cookie came to be set by a route no projection described. WithResponseHeader declares the names; HeaderCoder on the output supplies the values; an undeclared name is refused as an error rather than written. Every declared header lands in the document under the response, because a header a caller relies on — a cache directive, a payment challenge, a Set-Cookie — is part of the contract and Set-Cookie is a security-relevant part of it. Transport meaning is DEFINED rather than silent: written wherever the op owns the response — REST, and the by-name call plane, where one request carries one op — and not written over MCP, where one HTTP response carries a whole JSON-RPC envelope that may hold several results. The declared set still reaches the tool schema and the answer's value is identical everywhere. Tested. And Host needs no new spelling: header:"Host" already binds, because fasthttp surfaces Host through the same accessor. Measured, not assumed, and pinned by a test so cloud can convert its 2 sites as they are. Co-authored-by: Hanzo Dev 6@ux^tree c96d35964a0ab0810dfba5a89e39d61f8be6300f parent 08da1b6858b00a27376cf7fed12478892de1472f author Zach Kelling 1785725607 -0700 committer Zach Kelling 1785725607 -0700 the caller's address, and it does not believe X-Forwarded-For Caller.IP is the last thing forcing a Bridge install: cloud's request-needing sites cover body, arbitrary headers, URL and IP, and only IP was still missing. It is ambient, not declared — what the CONNECTION says, not something the caller states about itself — so it sits beside identity rather than in the op's input shape. Empty when no connection is behind the context, which is the same honest answer every other Caller field gives and never a panic. The trust question decides the rest. By default IP is the socket peer, which cannot be spoofed and behind a load balancer IS the load balancer. zip does not silently believe X-Forwarded-For: anyone can send one, and an IP that quietly reports the proxy is worse than none because someone will rate-limit or audit on it. A deployment behind a proxy opts in with Config.TrustProxy, and the opt-in is ALLOWLIST-GATED — TrustedProxies names the peers whose forwarded header is believed, and anywhere else it falls back to the peer. Setting TrustProxy with no allowlist trusts nothing, which is the safe reading of an incomplete config. The knobs are wired through to the router, because a trust setting that does not reach c.IP() is a promise the code does not keep. Measured: the typed path is 31 allocs/1388 B against 40/3063 on the previous tag. The improvement is stable across runs but I have not confirmed its cause, so it is reported rather than claimed — what is verified is no regression. One allocation I did add, a per-request closure for the header reader, is now built only for ops that declare a header. Co-authored-by: Hanzo Dev mjx\tree 4a3fd3120b30b07c04a826265845ed90a9bb8ed4 parent 41f9a5d0fc6ff697dca2c96d9cd61d791f00b575 author Zach Kelling 1785724967 -0700 committer Zach Kelling 1785724993 -0700 an operation can state its request facts and its success codes Bridge exists in cloud because zip lacked two vocabularies. Both close here, and both close the same way: the fact rides the op's CONTRACT, so every projection sees it. A replacement that were equally invisible would not be one. Gap 1 — a header tag. `Tenant string \`header:"X-Tenant"\`` binds off the wire with no middleware anywhere, and appears as a header parameter in the document, a flag on the command, and a property in the tool schema. Binding order is body, then headers, then URL: the URL is the addressing authority. On a transport with no HTTP request — the CLI, and the call plane — the answer is nothing rather than a nil panic, which is the shape CallerOf already established. Gap 2 — WithStatus takes a SET, and the answer states which one it is via StatusCoder. The status is a property of the value the handler already returns, so there is no mutable slot: a slot is a side channel and a side channel is what Bridge was. Every declared code reaches the document, so a client has a branch for each. A code the op did not declare is refused as an error — not a panic, because it is a runtime value on a serving goroutine. Also: App.Routes and App.Test now exist. Router's comment recommended both while neither did, and they are the two things callers reached through Fiber() for — so the stale reference is fixed by making it true rather than by deleting it. Co-authored-by: Hanzo Dev HNxo tree 31e53c0b21c4c8a25ce2beeb538c64d501cd107e parent 069260805654b5a40fcf72eaa5eab07c79233167 author Zach Kelling 1785706341 -0700 committer Zach Kelling 1785706347 -0700 use: a handler that answers an address is refused, at every depth Two things, both closing a gap between what walk.go states and what it checks. A HANDLER MAY NEVER TERMINATE A REQUEST. Enforced now. The inert check only ever asked something strictly weaker — that a definition carrying middleware has routes beneath it — which app.Use(zip.Static(assets)) passes on any app with a route, and its depth-0 skip meant the app being SERVED was never asked at all. That is exactly where a wiring file writes it, and the static handler then ran before every route in the composition and answered each one with a file, or a 404 where no file existed. walk.go's closing comment said so plainly: the rule condemned no form anyone writes. Terminality is now a property the walk can read. A leaf constructor returns its handler through zip.Terminal — exported, so wsx.Upgrade and third-party leaves come through the same door — and the identity is the closure's code pointer, never a name match. AdaptNetHTTP and AdaptNetHTTPMiddleware return closures with the same body from the same file, and only their authors can know which one answers. The handler comes back unwrapped, so registering a leaf at an address is byte for byte the registration it always was. The depth-0 exemption stays where it belongs, in the inert check alone: root middleware is router middleware and covers requests that match nothing, so it is never inert. ONE INTERPRETER. routesUnder re-walked App.entries per definition with a cycle guard of its own — a second authority that could disagree with the walk about the program it was asked about, and that read a definition's LIVE entry list rather than the one the generation was built from. It is now one pass over the occurrence slice, because a trail cell carries its *App, which makes an occurrence's breadcrumb its ancestor chain; a cyclic composition never reaches a reducer, so there is no guard to need. materialise reads its Handler through the third accessor the other two always documented, instead of asserting the payload. The two AST guards in binding_test.go become one that is strictly stronger: function granularity rather than file, bare type assertions as well as switches, and every allow-listed site must still be HIT — so deleting or renaming one fails the test rather than leaving it quietly vacuous. derived() already owns operation-id collisions; nothing here touches it. Co-authored-by: Hanzo Dev yڛzxTtree ca5e501fb7248c545289e096d131468cb1289c00 parent f4e20591c564f820c85dbed0efe1e0de99a683f8 author Zach Kelling 1785705625 -0700 committer Zach Kelling 1785705625 -0700 declaration projects the program; Fiber() escapes are refused; Listen is Serve+Wait Three things a consumer migration surfaced. HEAD shadows. Declaration filtered ALL HEAD and OPTIONS, which also deleted an EXPLICITLY declared HEAD — a real door a host would then answer 405 on, which is the analytics-outage class this type exists to prevent. The doctrine was right and the mechanism was wrong: a declaration now projects the PROGRAM, not the materialised router, so shadows never appear (nothing wrote them) and declared HEAD does. App.All is the one entry that is genuinely many doors, so it expands. Consumers enumerating routes should read Declaration, not Fiber().GetRoutes — fiber's own method cannot apply a doctrine zip owns. Fiber() escapes. Fiber() hands out the CURRENT generation's router, and a generation is a projection, so app.Fiber().Use(cors.New(...)) was silently discarded by the next build — no error, no CORS headers. A doc line is weak medicine for a lost CORS policy, so the generation records its route count and a rebuild that finds more refuses, naming the count and pointing at app.Use. Listen. Serve is the one serving mechanism and Listen is now literally Serve followed by Wait — sugar, not a second path. The no-handle shape is deliberate and documented: a fixed program wants the terminal form, anything that loads at run time wants the handle. And a bug of my own, caught by TestLoad_EmbeddedBinary: the first cut of Serve left h.errc nil, so Wait returned immediately and Listen stopped serving at all. The test I wrote for Listen passed against that, so it has been strengthened to dial the socket and assert Listen has NOT returned — verified to fail without the fix. Co-authored-by: Hanzo Dev 6xZtree fd1878a2de95f050d10fbde0e667f5e4534a148c parent 98d4837f67f8a6f0d7df632c3e5855b8ecd0e5ea author Zach Kelling 1785704074 -0700 committer Zach Kelling 1785704178 -0700 v1.20: the slice returns, the host owns the live verbs, two validation stages Three deltas against z's final language and runtime documents. 1. walk(app) ([]occurrence, error). The materialised form is deliberate: the alternatives are rewalking once per reducer, buffering secretly, or rendering during traversal — which weakens validation-before-rendering, the ordering every other guarantee rests on. occurrence is unexported and non-semantic; the tree stays canonical. What died was its claim to be part of the language, not the slice. Each generation retains its walk result so live reducers reuse it. 2. Include/Drop/Reload move to a Host, obtained from zip.Serve. Use extends a program; Include publishes a new generation of a running one. This deletes the process-level server set, reachability filtering, creation-order locks and cross-host commitment — they existed only to answer which hosts an App-anchored call reached, and host anchoring makes that unaskable. A shared definition is immutable everywhere; a new version is Reloaded per host. 3. Validation splits into named stages: structural (cycles, conflicts, inert middleware) then derived (id derivation and post-derivation collisions). Derived cannot run earlier — two occurrences can be structurally fine and still derive one operation id, which is a new check and now caught. Binding requirement enforced mechanically: the only type switch over node lives in walk.go, and no validator or reducer reopens App.entries. The test found three real violations, including Lint, which now consumes the walk. Also: Registry(app) recomputes in the mutable phase rather than serving a memoised draft, per the runtime doc — the draft cache had already produced one stale answer. And the iam five-prefix trap is pinned: composing a definition once per prefix is five occurrences, and prefixing an absolute-path definition moves it, visibly, in the registry. Co-authored-by: Hanzo Dev N1 gjx_tree 446e4c161f27d36c6f183dec70ae80f4920dd219 parent 7d223411852ad226d4011ccf5c8e7a85cfa2b2f0 author zooqueen 1785703270 -0700 committer zooqueen 1785703270 -0700 router: Group returns the abstraction too, so a decorator survives nesting Same defect as Fiber(), one layer down. v1.19 narrowed Group from Router to *App; Go has no return-type covariance, so a concrete return forces EVERY implementor to hand back an *App — and a decorator's group has to stay decorated, which means returning itself around the group. v1.18 had this right in all four places (Router, App, routerAdapter, wrapRouter). compose.go already documents what narrowing costs: "Dropping it here reopened a gate that origin/main held shut (wrapRouter.Group used to return another wrapRouter, so the chain rode down every level) — an auth seam quietly lost at the second nesting." That was patched INSIDE the package by copying a.wrap onto the group. An external decorator has no such lever, which is why hanzoai/commerce's mintRouter fails to satisfy Router on Group exactly as it did on Fiber. App.Group now widens to Router and delegates to an unexported group() that still returns the concrete *App, so wrapRouter reaches g.wrap directly and no assertion can silently drop the chain. Behaviour is unchanged. The two red_test call sites that use App-level API on a group (Drop, Include) now say so with an explicit assertion — asking for the concrete type is exactly what they are doing. Verified: build, vet, gofmt, the decorator guard, and the full suite measured against a stashed baseline — 7 failures before, the same 7 after, zero new. Co-authored-by: Hanzo Dev jRMtxBtree 54d2cdc28cf7d1687f31ddfba6c48160a7abac38 parent 3407863fb528f88cbeea393a1004c66c59349bd8 author zooqueen 1785702942 -0700 committer zooqueen 1785702942 -0700 router: the abstraction stops naming its implementation Router carried `Fiber() *fiber.App` "for one-off escape". A Router is the type a DECORATOR implements — OpTarget's own doc says so, and says how — and a decorator wraps a Router, so it has no *fiber.App of its own to hand back. Requiring one made the interface unimplementable outside this package: zip's wrapRouter only ever delegated the method, hanzoai/cloud's `scope` and hanzoai/commerce's `mintRouter` could not satisfy it at all, and a 157-file v1.19 adoption in cloud stalled on a member nobody wanted. The file already said the rule two lines up — "fiber.Ctx is the underlying type the framework's users never see directly" — and then exposed *fiber.App. v1.19 made it worse than v1.18, which at least returned the fiber.Router interface rather than the concrete app. The escape hatch was never the problem; putting it on the ABSTRACTION was. It stays on the concrete App, so a caller that genuinely needs the underlying router still reaches it and has to hold an *App to do so, instead of every Router in the estate quietly widening to fiber. router_decorator_test.go is the guard: a decorator that embeds a Router, counts registrations and imports no fiber, asserted against Router at compile time and driven through a real registration so it cannot pass while swallowing routes. A comment asking for the property is not the property. Verified: build, vet and the decorator test pass. The suite's 6-7 socket and release-fetch failures are pre-existing — measured against a stashed tree, the failure sets are identical bar one flapping wire test. Co-authored-by: Hanzo Dev O*Afxjtree 314904252acc7a9710e055079c29e690de7ae67b parent 1ea512e127c04e6ebe466dd37280f68d71c609f4 author Zach Kelling 1785700522 -0700 committer Zach Kelling 1785700522 -0700 the walk is a visitor; the occurrence type is gone walk(app, visit func(n node, ctx scope, site callsite) error). The callback's parameters WERE the payload, so the struct wrapping them was a noun invented to carry what three arguments already carry — and retaining the slice made every backend a consumer of a materialised intermediate rather than a reducer over a traversal. The English word survives in prose because the definition/occurrence DISTINCTION is load-bearing; the type does not. Validation stays its own first pass (verify), so cycles and conflicts complete with trails before any backend sees a visit. A generation retains what was REDUCED — router, ops, host set — never the traversal. Also: #4 verified, not changed. Own-op tool names already ride the operation-id rule because they read Registry(); a plugin catalogue tool is invoked by NAME at the plugin's own door and never consults a prefix, so ONE definition is ONE tool and namespacing it would invent a callable that does not exist. Tests pin both. #2: Drop and Include share one transact path, so the guarantee is identical, and the lock discipline that makes it deadlock-free is now written down with the two invariants it rests on. Documented honestly: commitment across servers, not simultaneity. Godoc: every bracket reference to a deleted symbol rewritten. LLM.md carries the canonical three-document spec. Co-authored-by: Hanzo Dev ?2Sx1tree 1ffad02252f1ad2c14ce940736bb069a5823704d parent 3866f2728b245fce453b31e1134b0f36d8c72ac3 author Zach Kelling 1785693442 -0700 committer Zach Kelling 1785699275 -0700 phantom: Use is compose-time only; the freeze has no exemption appendEntry allowed a write while a transaction was in flight. No transaction path reaches appendEntry — compose, Drop and includeRoutes all append directly, already holding buildMu — so the exemption could ONLY ever admit a Use racing a transaction from another goroutine. That append landed on the program and materialised on the next, unrelated Include: a plugin load in one subsystem could activate a route appended hours earlier by a caller that believed it had failed. Taking the lock made the phantom reliable rather than absent, which is worse. Use is compose-time only. Include is the one transactional live verb. Two verbs, two lifetimes, neither silent. Both regression tests verified to fail with the check disabled. Also: the inert-middleware refusal now names the fix. A handler that ANSWERS an address is registered at that address; Use is for handlers that WRAP. Use cannot say WHERE a handler answers, which is the same argument that made Group the way to express a scope rather than line position. Co-authored-by: Hanzo Dev Q@xtree dca7e198d12c3882bd624cf5a55495ddda5a1504 parent 38c792c6b0d695c306c9d8fa11c852ac017e3f2d author Zach Kelling 1785693063 -0700 committer Zach Kelling 1785699275 -0700 mcp: the one door that dropped the caller typed.go and call.go both build the handler's context with callerContext(fc); mcp.go used fc.Context(), which carries no reference to the RequestCtx. So CallerOf() came back EMPTY for any op dispatched by a tools/call — an Authorizer could not tell who was asking, and an onward zip.Call from inside such a handler forwarded no identity headers at all, so the next service saw an anonymous request that had in fact arrived authenticated. It is also why hanzoai/cloud grew a hand-installed Bridge() middleware at the app root in ~100 places: middleware runs on the fiber Ctx, so parking the identity there papered over the hole in that repo's private vocabulary. The test fails with the bug and passes with the fix; both directions verified. Co-authored-by: Hanzo Dev axtree 3a18519a58e9c68cf62e3da90941d6fb1448a331 parent 4d3a09b7d12e792eb073c24059f9f64cb476748e author Zach Kelling 1785691518 -0700 committer Zach Kelling 1785699275 -0700 gofmt Co-authored-by: Hanzo Dev 0lJ sx8tree 313229d474abbb09db8e560d9d3d8e93fa6340ff parent 7e16e8f0af169f0a74d9b4a8b797f449e143825d author Zach Kelling 1785691509 -0700 committer Zach Kelling 1785699275 -0700 green: three decisions, the MCP catalogue, and the last race Decisions, all one principle — the framework may refuse, never be silently wrong: - A projection of a program that does not compose PANICS, carrying the joined error. Registry and Declaration return values, not (value, error), so there is no honest answer; a sentinel loses because a sentinel can be ignored, and a caller ignoring it was the failure. Build validates BEFORE prepare, so the one function whose job is to return the error still returns it. project() writes nothing and fails, so a pipeline can no longer ship an empty API document. - Include on a non-root WORKS. It rebuilds every live server the edit reaches, builds them all before swapping any, and swaps only if all succeed. The freeze panic recommends Include; a recommendation that no-ops is a bug in one of the two, and this keeps the recommendation true. - A definition with middleware and no routes ANYWHERE BENEATH IT is refused at seal. Inert is correct under lexical anchoring, so the scoping rule is not bent; what was unacceptable is that it was silent and reads exactly like working code. A group whose routes come from its children is fine. The MCP catalogue joins Plugins/Reload/Unload/Start on the walk: a plugin is a definition now, so its tools live with it and the host aggregates. Duplicate tool names and two open plugins are refused at build, where two definitions can finally see each other. And appendEntry takes buildMu. Making the flag atomic was not enough — a transaction rewrites the entry slice while holding the lock. Co-authored-by: Hanzo Dev yxUtree d4fb9863240a8675379a06f23a4dd8eb23d99aec parent 9118f9c2e4d75937c2b54770cae886a0b4b2e1cd author Zach Kelling 1785690597 -0700 committer Zach Kelling 1785699275 -0700 red: 9 of 12 adversarial findings fixed, 3 are design calls Fixed, in severity order: - transact's rollback is DEFERRED and now restores adopted teardown hooks too, so a panic in the build no longer unwinds past it and poisons a.entries. An unknown HTTP method in a Declaration is refused at the boundary it crosses instead of panicking inside fiber's register(). - App.Group inherits a.wrap. A scoped With used to be lost by a nested group, which reopened a gate origin/main held shut — a regression this branch introduced when Router.Group changed its return type. - With(...).Use(definition) is refused loudly. It cannot wrap a definition's own leaves, and silently composing them UNGATED was the one unacceptable answer for the chain people reach for With to install. - conflicts() keys on path then method, upper-cases the method, and treats ALL as colliding with any method at that path. Deleting App.claim was justified on the walk answering better; the ledger's strongest case was mounts and plugin prefixes, which register as ALL, so this had to be true before that sentence was. - project() refuses to write a document for a program that does not build. used to emit {"routes":[]} and exit 0 for a broken service. - Drop bumps the version counter; a dropped route could otherwise serve forever out of a stale draft. - is atomic. Include is by design called against a running system, so the check that catches a concurrent Use must not itself be a race. - A nil handler panics at registration, as router.go always promised. Still open, all needing a decision rather than a patch: accessors return an empty projection for a program that does not build (Registry/Declaration cannot return an error); Include on a non-root is a silent no-op though the freeze panic recommends it; a middleware-only definition is inert because depth>0 middleware has no routes to compose into. MCP catalogue migration still outstanding — see f26b559. Co-authored-by: Hanzo Dev 4>xtree cd6a1fe911fc8738967a838cd94d65bb6efb3f99 parent 7ec13236ffa991f7023f0ae0e579154588c2084f author Zach Kelling 1785690220 -0700 committer Zach Kelling 1785699275 -0700 WIP: plugin+MCP state still needs to move to the walk The verb deletion is done and the library builds: Graft, Add, Service, the Mount VERB and the claims ledger are gone; Load and Mount return definitions; Plugins/Reload/Unload now find their plugin by walking. NOT DONE — the same entanglement, one layer over: a plugin's MCP catalogue (pluginTools/toolOwners/open) is still read off the host that loaded it, but a plugin is now a definition, so the host reads an empty set and serves no door. Four mcp_compose/mcp_open tests fail on exactly that. The fix is the same one that worked for Plugins(): aggregate across App.hosts() instead of reading a private map, and move the duplicate-tool-name refusal to the walk so two plugins can actually see each other. Co-authored-by: Hanzo Dev Wߞ3x>tree c23609392aff1c66f9319f6df9a69a71ea8398cc parent 6a5ca4037db2f6580a1541a496fa9dd52e936341 author Zach Kelling 1785689601 -0700 committer Zach Kelling 1785699275 -0700 one verb: Graft, Add, Service and the Mount VERB are gone Everything composes through Use. A unit of functionality is an *App — whether it is linked in, loaded from a binary, or another process — so Load and Mount become definition CONSTRUCTORS returning (*App, error) instead of verbs. App.claim/release and the claims ledger go too: the walk's conflict accumulator already answers 'who else wants this address', and answers it better — every collision at once, with both claimants and their call sites named. Two mechanisms for one question are two answers waiting to disagree. Co-authored-by: Hanzo Dev gA5xVtree 08b2281b858c0331cb9487860b9dfd62abe140d6 parent db5203729ea73d6df476d290ab943dbd860cad03 author Zach Kelling 1785685466 -0700 committer Zach Kelling 1785699275 -0700 acceptance: the iam graft document is byte-for-byte unchanged iamserver.NewApp(db) (hanzoai/iam v1.34.0) grafted into a 4-path host renders an identical OpenAPI document under this branch and under released zip v1.18.22 — same sha256, 85 paths, 102 operations. iam compiles against the branch unchanged; it has no bare closure at a Use call. The circulating 4->164 figure is not what this pairing produces: it is 4->85 paths / 102 operations. Also gofmt: build.go was left unformatted by my own edits; caller.go, examples/express-in-zip and internal/zipdoc/extract_test.go were already unformatted on main. Co-authored-by: Hanzo Dev ;xEtree 20d457c1d8f24405abba4f486ae248a645feea55 parent f24360adf653c059d5a86a499fcc010349738889 author Zach Kelling 1785646906 -0700 committer Zach Kelling 1785699275 -0700 generations: a program is not mutable, it is versioned Replaces seal-forever. A generation is a sealed program plus its projections; the live system is one atomic.Pointer. A composition change builds N+1, walks and validates it, and swaps only on success — so a colliding plugin fails the build with breadcrumbs and the old generation keeps serving. Requests load the pointer once on arrival and finish on their own generation. Use pre-build (cannot fail); Include/Drop against a live system (transactions). Drop is receiver-local: an entry belongs to the app that wrote it. Also fixes a test of my own that trusted App.listening instead of dialling the socket — listening is incremented before the bind. Co-authored-by: Hanzo Dev QIx4tree 54153b496c0249d3f07cb71b24f77fe5f2b4039d parent 7dc45e8b7561bb1a327174e3b5eb94b68f523441 author Zach Kelling 1785645363 -0700 committer Zach Kelling 1785699275 -0700 LLM.md: what the prototype is, and the six things the code proved Co-authored-by: Hanzo Dev 1_ :xUtree 86d05eea809f620def132e380a83c8813081e58c parent 3e406f232d8d07e61672855b69442cac87627aa6 author Zach Kelling 1785645363 -0700 committer Zach Kelling 1785699275 -0700 compose: one verb, because the eager registry was the disease An App becomes a PROGRAM: an ordered list of entries, each carrying one of exactly three payloads — middleware, a route, or another App INCLUDED BY REFERENCE. One walk flattens it into occurrences in preorder; every projection is a reducer over that slice. Graft, Mount and Add delegate to the same walk. Five verbs existed because the op registry was a FIELD that composition appended to at call time, so composing two apps meant merging two registries and AdaptNetHTTP could destroy five projections by type-erasing an *App. A projection over a walk needs no merge rule. Prototype only: not for main, not tagged, not released. Co-authored-by: Hanzo Dev _> cx?tree 04ec0eabf087838897df9b2f9dbc8c975ed57bef parent 28a3781c34fd376b1b132f13fef3ca4f531edce7 author Zach Kelling 1785644336 -0700 committer Zach Kelling 1785644336 -0700 ops: the ops listener is an address, and the address names its transport OPS_PORT and ZIP_OPS_ADDR were two environment variables for one listener, and they disagreed. OpsAddr() turned OPS_PORT=9090 into the bare string ":9090", and a bare address takes DefaultScheme — ZAP. So the knob HIP-0119 §5 actually names bound a ZAP socket for /healthz, /readyz and /metrics, whose only two clients are a kubelet httpGet probe and a Prometheus scrape, neither of which speaks it. The probe's "GET " arrived as a frame header: zaphttp: read frame: frame size 1195725856 exceeds MaxFrameSize=67108864 0x47455420. The other variable, undocumented, worked. That is how iam standalone came up with no reachable /healthz, never went Ready, kept zero endpoints, and took every caller that resolves identity through it down with it. Both variables go. The ops listener is Config.OpsAddr — an address, in the same grammar App.Listen already takes, so a binary states all of its listeners one way and one place: svc serve --zap :9653 --http http://:8000 --ops http://:9090 DefaultOpsAddr replaces DefaultOpsPort and carries the scheme, because the port was never the part that was ambiguous. Empty still binds nothing: a host names no ops address for a child, so a child owns none. TestOpsListenerSpeaksHTTP pins it — it fails on DefaultOpsAddr = ":9090". Co-authored-by: Hanzo Dev PKxOtree 83b79e9bea332f60592f3b529ba5f9db15ab3971 parent 0f3b7e912e93954667bcf1bec8c267fcaf4fe10b author Zach Kelling 1785614185 -0700 committer Zach Kelling 1785614185 -0700 alias: one handler at two addresses belongs to zip, so both addresses say what it does A service that keeps a legacy spelling reachable writes a two-line helper: reg(canonical, h); reg(legacy, h). hanzoai/iam has one, and it cost it the prose for NINE pairs — 18 operations — because the registration happens inside the helper, where a pass that reads `router.Get(path, handler)` calls cannot see it. Both halves published an address and silence, and the legacy half is exactly the one a consumer is likeliest to be pinned to. So the primitive moves here. zip.Alias is the same two lines, and zipdoc knows it by name — a matcher can only recognise a function whose identity it knows, which is the argument for zip owning this rather than each service rolling its own. Both addresses get the SAME sentence, because both are the same handler and mean the same thing. Deleting the legacy half when the last pinned consumer moves stays a one-word edit. Co-authored-by: Hanzo Dev 㒠NBx/tree dcac0bd15c641d6c3efed53d784f71d745c667d1 parent 605e96dfc03add9cec3dcc3fc6c256b5559f9003 author Zach Kelling 1785613714 -0700 committer Zach Kelling 1785613714 -0700 zipdoc: a router that arrived as a parameter is read as mounted at the root `func routeFrontDoor(r zip.Router, db orm.DB)` is the shape a subsystem uses to be mounted BY its host, and it is where the pre-auth surface lives — sign-in, sign-up, the OIDC token and authorize endpoints, JWKS. zipdoc could not resolve that router's prefix, because only the caller knows it and the call is in another file, so every one of those routes was skipped and stayed silent. An unresolvable router is now read as mounted at the root, and only for a path already written absolute. Getting it wrong costs nothing a reader can see: zip.Describe renders only where the router carries the key, so prose filed under a path nothing serves renders NOWHERE — the same silence as not lifting it, never a sentence attached to the wrong operation. Co-authored-by: Hanzo Dev s|x1tree 73eacb7d24487152aa8db510c5151c3fecc3cba6 parent 51ecb2af85528b2e5bcf4e350a8c7de64d4e854d author Zach Kelling 1785613593 -0700 committer Zach Kelling 1785613593 -0700 zipdoc: an UNTYPED route is an operation, and now it can say what it does Some routes cannot become typed ops and it is the WIRE that says so, not the author: an OIDC redirect, a JWKS document, a SCIM body RFC 7643 governs, a multipart form, a file download, an SSE stream. They are operations a paying caller reaches, and they had nowhere at all to state what they do — hanzoai/iam alone publishes 98 of them, each an address followed by silence. So the pass reads `router.Get("/path", handler)` as well, and lifts the same doc comment from the same three shapes. Two properties keep it honest: * DESCRIPTION ONLY. No In, no Out, so no schemas and no field prose. This must never make a raw route look typed. * It registers no route and invents no operation. zip.Describe is keyed "METHOD /path" and renders only where a router already carries that address, so the router stays the sole authority on what EXISTS and this adds only what it MEANS. The receiver decides, not the method name: *zip.App or anything satisfying zip.Router. And a non-constant path is skipped rather than refused — the typed case must fail the build because a computed path is a hole in the schema surface, while refusing here would turn every raw handler in the fleet red on release day. zip.Prose exported alongside, because the typed-op registry is not the only reader. A host that composes several apps projects its LIVE ROUTER — typed and untyped alike — and the untyped half has prose here and nowhere else. Without it the host keeps a table of strings for routes it does not own, which is the exact duplication this package exists to remove. The summary is derived inside Prose so every projection of one operation shortens it identically. Co-authored-by: Hanzo Dev DxBtree 513bc142811e49bab27c21990a64d14e3e24c6c7 parent c64ff0effc9a9c939ebd82ea3cf22f0f15efc0d3 author Zach Kelling 1785612301 -0700 committer Zach Kelling 1785612301 -0700 zipdoc: an inline handler is documented above the REGISTRATION, not the closure handlerDoc's own comment already said "the comment directly above the registration" — the code looked above the closure LITERAL. Those are the same line only while the whole call fits on one. The moment a registration carries WithSummary or WithTags the handler moves onto its own line, the line above the closure becomes `zip.Post(app, path,`, and every sentence written above such a call was dropped. That is not the rare shape. It is what a registration looks like as soon as the service has anything at all to say about the op — 11 of hanzoai/iam's legacy verb aliases are exactly this, each with prose above it reaching no document. Looking above the call subsumes the old behaviour: when the closure IS on the call's line the two positions are identical. Co-authored-by: Hanzo Dev xڝmx"tree ae640e6ec376d1d95bcc70b20f1ec088f21c7c2c parent 0132e503bec7c72773595e1a769337df2f86497e author Zach Kelling 1785612133 -0700 committer Zach Kelling 1785612133 -0700 zipdoc: a handler BUILT by a function is documented by that function The moment a handler needs a dependency, a service writes a builder that closes over it and returns the handler — and zipdoc's handlerDoc had no case for a call expression, so every one of those operations projected an operationId and silence. Not for want of prose: `// listProviders returns every provider in the owner scope, newest first.` was already written on the builder, already reviewed, and dropped on the floor by the reader. The closure a builder returns has no declaration of its own, so the builder is not merely a convenient place for the sentence — it is the only place there is. Reading the callee is the SAME rule as the named-handler case applied one call deep, not a second convention: in all three shapes the sentence sits immediately above the code that does the work. zip.Get(app, p, ListUsers) named -> the function's doc comment zip.Get(app, p, listUsers(db)) built -> the BUILDER's doc comment (new) zip.Get(app, p, func(..) {..}) inline -> the comment above the call The two symbol cases now share one funcDoc, and both route through calleeIdent, so a generic instantiation resolves for free. A call that is a type conversion resolves to a TypeName, not a Func, and yields nothing — as it should. Measured on hanzoai/iam, which registers this way throughout: 34 of its 84 typed ops carried no description at all before this and every one of them had a doc comment sitting on its builder. Co-authored-by: Hanzo Dev ]txKtree 8294be4a1b79429c4eded17c0342f6e5581da1db parent 926fa0b0885143461ed39a5c59ed1db3676bee56 author Zach Kelling 1785609543 -0700 committer Zach Kelling 1785609543 -0700 zipdoc: the symbol is dropped on shape too, not only on an exact name The lift already dropped a leading identifier when it matched the handler's own name exactly. Measured across 829 lifted comments in one fleet, that is the minority: 449 of them open with a symbol that is NOT the handler's identifier — `deleteLB` carrying "DeleteLoadBalancer removes one of the caller org's load balancers", `list` carrying "ListAgents returns every agent". The convention is being followed against a CONCEPTUAL name, so exact matching left most of the leak in place and every one of those sentences reached an SDK docstring, an MCP tool description and a CLI help line opening with a Go symbol the reader cannot see, cannot call, and already has in operationId. So the rule now takes two evidences, strongest first: the handler's name exactly, and failing that Go's own sentence shape — a strict CamelCase word followed by a lowercase verb, which is the form the convention itself prescribes. An inline handler names no function and now gets the second evidence, which it never had. Both halves are deliberately narrow, because a wrong strip damages a sentence somebody wrote while a missed one leaves it exactly as it was. A run of capitals is not a hump, so GPUs, OpenAPI and HTTPHandler stay the ordinary words they are; a copula makes the leading word the sentence's subject, so "CompleteDeployment is the CI hook" keeps its name rather than becoming "Is the CI hook"; and punctuation after the second word means it is not the verb of "X does Y". Still one transform in one place — the lift every projection inherits from. Co-authored-by: Hanzo Dev vʋx tree fe71f7531f8837377ba43a5ca9bb7c53ff481bab parent 6123184ce6bdd8bce570fe9db493e4bfc93ebc07 author Zach Kelling 1785606490 -0700 committer Zach Kelling 1785606490 -0700 graft: compose an App in process, so the child's registry survives The only way to put a live *App behind a host's router was app.All(prefix, zip.AdaptNetHTTP(child)). AdaptNetHTTP takes an http.Handler and returns a closure, so the App went in and a bare function came out — and the child's op registry went with it. All five projections die at that closure: the OpenAPI document, the MCP tools, the CLI commands, the by-name call plane and the Declaration. A host could publish only the wildcard it hung the closure on. hanzoai/cloud publishes five path keys for an identity provider holding 94 typed ops. Graft is the fifth verb. Listen serves here; Mount delegates there; Add composes a registrar; Load composes a binary; Graft composes an APP. Delegation, not route-copying — the load-bearing call. Copying the child's route handlers drops its middleware (Declaration projects GetRoutes(true), which filters Use out), and a service whose whole authentication seam is app.Use(guard) would arrive with the guard gone. Copying the Use entries instead is worse: a pathless Use grafted onto the parent gates every route in the host binary. Delegation has neither failure, because middleware stays inside the app that declared it. It is also cheaper than the adapter it replaces — no net/http round trip, so the ~5% and the dropped fasthttp user-context both go — and it NARROWS the surface: only the patterns the child declares, so an undeclared path falls through to the parent instead of being swallowed. Paths and operationIds are untouched: op.Path is already the whole absolute path, and an id is a published SDK method name. The registry gets a COPY of each op carrying Origin, so composing a child never edits what the child says about itself, and op.invoke still closes over the CHILD's authorizer. Schema names are qualified . UNCONDITIONALLY. Qualifying only on collision makes a published type name a function of who else is in the room. One more input to schemaRegistry.nameFor, which already qualified by package — not a second naming scheme. An app with nothing grafted is byte-identical to before. The refusal is all-or-nothing and reads the ROUTER, not the document: the addresses that collide in practice are liveness paths no document publishes. Graft refuses after prepare, because the document, the tool list and the call plane render once — an op grafted later would serve and never describe, which is the defect this removes. AdaptNetHTTP stays: it is still right for a genuinely foreign handler. What dies is AdaptNetHTTP applied to a *zip.App. Co-authored-by: Hanzo Dev <뤐Oxtree 44a24752d109d10a88eac37a44be35a704076951 parent 68e88af3b646932f7b9595e7d4fae0f26c57e409 author Zach Kelling 1785471587 -0700 committer Zach Kelling 1785471587 -0700 mcp: the per-caller dedup wrote into the fleet's name set — two silent bugs callerTools read the shared name set and then WROTE the caller's own names into it. The set is one map, loaded once at render and shared by every request, so: - one tenant's tool name became "already claimed" for every tenant after it. The second org silently lost a capability it had, and could infer from the absence that someone else had a tool by that name. - two lists in flight were two writes to one map, which is a runtime FATAL that no recover() catches — on tools/list, the one method an MCP client calls constantly and therefore the one most likely to arrive in parallel. The fleet set is READ-ONLY and the request's own dedup is its own map. That is also cheaper than cloning: nothing copies 549 entries per request. Both failures are pinned. TestCallerToolsDoNotLeakBetweenCallers fails on the old code with the second caller's tool missing; TestConcurrentListsDoNotRace drives 64 goroutines under -race. Co-authored-by: Hanzo Dev #Pxtree 199cc8c4526674ae893fb602b18bdad59061a30c parent 07bec67def3248dab71aa153b11f86e445a8d91e author Zach Kelling 1785471277 -0700 committer Zach Kelling 1785471293 -0700 mcp: prove the host half of the open door, with a real child v1.18.14 shipped both halves of the per-caller seam and tested one. MCPConfig.Source was covered end to end; Plugin.Open — the composition across a process boundary, which is the half a fleet actually runs — was covered by nothing. The claims that mattered most were the ones written only in prose: that an anonymous tools/list still wakes no child, and that a second open plugin is refused. internal/testplugin grows a Source of its own, so the test drives the real shape: a host, a LAZY child in another process, and a tools/list that has to cross that boundary to be answered. Proven: an anonymous list carries no tenant tool and starts zero processes; a named caller's own tool is spliced in beside the build-time half; a second caller gets a different list off the same door; a name no catalogue claims reaches the open plugin and runs there; and Load refuses a second open plugin, naming the first. No library change, so no tag — v1.18.14 is what these describe. Co-authored-by: Hanzo Dev /x#tree ae4145b1a0e75249ccc5089d6b30a7b729f75c4d parent 2492cb30123a6b95cb57a546442a5d0ccb98a6b2 author Zach Kelling 1785469243 -0700 committer Zach Kelling 1785469243 -0700 mcp: the door's other half — the tools that exist because of who is asking A typed op is a value known at build time, so zip projects it once and serves the array as bytes; that memcpy is what makes tools/list affordable for a host composing 112 lazy children. A tenant's own capabilities are ROWS — an org's connected connectors, its authored skills, the tools on the external MCP servers it registered — and no build-time projection can hold them. They were therefore reachable only THROUGH a tool, never as tools, which is a second registry wearing a different hat. Two additions, one idea: some tools depend on WHO is asking. MCPConfig.Source the leaf: an app contributes the caller's own tools to its own door. Called with the context the request is served on — the same value a typed op gets — so an implementation reads its caller from there and never from the arguments, which the caller wrote. Plugin.Open the host: this plugin's catalogue is INCOMPLETE by construction, so ask it per caller and hand it a tools/call no catalogue claimed. At most one may be open, for the same reason two may not own one tool name. The invariant that made the door affordable is kept, not traded: the build-time array is still bytes and still byte-identical to the artifact, the per-caller half is APPENDED rather than merged, and it runs only on a request that NAMES a caller. A per-caller answer needs a caller, so an anonymous tools/list still costs a memcpy and starts nothing. A projected name can never be shadowed: composeTools now returns its name set with its bytes, so the dedup is a map lookup rather than a re-parse of hundreds of schemas per request. mcpAnswer is lifted out of mcpCall so a typed op and a Source render one shape — a handler error is isError content either way, which is what lets a model read a refusal instead of a transport failure. Co-authored-by: Hanzo Dev 47xutree 542a93f90a8fdfda3dfe644b97ae8d12974c0325 parent c16fdab90e1105423fd963ece4cfdaaefe42e488 author Zach Kelling 1785467544 -0700 committer Zach Kelling 1785467544 -0700 zipdoc: strip the handler's own name from projected prose Go's doc convention starts every comment with the identifier it documents, so every projection — OpenAPI description, derived summary, MCP tool description, CLI help — read "GetSQL returns one database" with a Go function name a spec reader has no namespace for. The lift now drops an exact leading match of the handler's own name and recapitalizes, and only that: inline handlers name no function, and prose that merely opens with a camel-case word keeps it. Source stays idiomatic Go; the document reads as prose. One transform, at the one place every projection inherits from. Co-authored-by: Hanzo Dev {2T;xDtree 19d3ccdc5faa315c3fd83879bab1071aadcde205 parent 00db0cad1bfd1bf4e65b30e79dd2be0c67178bb0 author Zach Kelling 1785421632 -0700 committer Zach Kelling 1785421632 -0700 mcp: a plugin composed after Listen is on the list, not invisible v1.18.10 rendered the composed tool array once, in installMCP, which is right for a host that Loads everything before it serves — and silently wrong for one that does not: a Load landing after Listen appended to pluginTools that nothing read again, so its tools existed in the owner index (callable) and not in the list (undiscoverable) until a restart. No race, just a state nothing can see or explain. The list is now an atomic pointer that any load re-renders. tools/list stays a memcpy of a constant — the property the whole design rests on — because the cost moves to the Load, which is rare, instead of to the request, which is not. Co-authored-by: Hanzo Dev IxC tree 304eb1c7b1c73842d886fff2d9c9c1083e59ba67 parent 3def6f75e22bd421e6af16e773f9658022db796b author Zach Kelling 1785420098 -0700 committer Zach Kelling 1785420098 -0700 openapi: an embedded struct's fields are on the wire, and no projection said so encoding/json PROMOTES an embedded struct's fields onto the outer object. Four things asked "what fields does this type carry" and each answered with its own loop over NumField, which is not that question — and an embedded body type is very often UNEXPORTED, because it is an internal detail two routes share. So all four skipped it on IsExported and dropped every field it promoted: the schema published an object with only the outer fields; the document declared NO request body at all when the outer fields were all path params, since "every field is a path param" was true of the fields it could see; the CLI offered no flag for them, so the command could not send a body; bindURL could not bind one from the URL. The decoder never had the bug. The wire took those fields the whole time, which is exactly why nothing failed — the four projections were describing a request shape the service does not have, and a generated client would have had no way to send the body at all. wireFields is the one function that knows the promotion rule, and the four read it. It answers STRUCTURE only — which fields exist, the outer type's and the promoted ones together. WHICH HALF of the request carries a field stays with `json:` and `url:`, asked by each caller, because a field can be URL-only (`json:"-" url:"script"`) or body-only (`json:"script" url:"-"`) and a filter in one place would silently drop one of the halves. A tagged embedded struct is a named object rather than a promotion, which is encoding/json's rule and so this one's too; an embedded pointer is not followed, because a nil one has no fields to promote and a projection must not describe what binding cannot reach. Found by declaring a real route on v1.18.9 — cloud's PATCH /v1/admin/catalog/providers/{name}, a path param plus an embedded unexported patch body — and READING the artifact rather than trusting it. It published no requestBody. embed_test.go pins all four projections plus the wire, and fails on the first of them if the rule regresses. Co-authored-by: Hanzo Dev d8ϕuxUtree 6968c7ba31d3c05ca434eadf234b9152840b2e0b parent cc2d647ed0e789c5fe6c2271bada3c2357b2cb96 author Zach Kelling 1785419764 -0700 committer Zach Kelling 1785419764 -0700 mcp: a host composes its plugins' tools without running one The fourth projection was already free per app — every typed op is a tool, at /mcp, over every transport the app listens on — and completely unreachable in a fleet, because a HOST has no ops of its own and MCPTools() is in-process: it cannot ask a plugin that is not running, and asking would defeat Lazy. tools/list is the method an MCP client calls constantly, so a host that woke 112 children to answer it would trade the one invariant that makes 112 services affordable for a question whose answer is fixed at build time. So Plugin.Tools carries that answer: the JSON array the plugin's own MCPTools() projected, captured when it was built. load indexes it name→plugin (refusing a duplicate name at compose time, the analogue of a duplicate prefix claim — a name is dispatch, so two owners make it unroutable), installMCP renders own ops ++ every catalogue ONCE as bytes, and tools/list is a memcpy of a constant. Zero processes. tools/call is the only trigger, and it starts exactly one: p.target(), the same single-flighted lazy path a prefix request takes, then the SAME message forwarded to the owner's own /mcp. The child's registry answers, so the host can only NAME a tool, never invoke one the child did not declare — a stale catalogue yields the child's -32602, not a wrong call. mountVia's proxy body is extracted rather than copied: one forwarder, differing only by a rewritten path. mcpTools() also sorts now, because this projection is SERIALIZED — an artifact ordered by registration churns on an edit that changed nothing a client can see. Co-authored-by: Hanzo Dev IJx tree e3256186848a14f4977d73a4e30d2630594ac0c2 parent 86b2f3dda2437d1aa538a4fd58fce5d0fd396ef3 author Zach Kelling 1785418126 -0700 committer Zach Kelling 1785418126 -0700 openapi: four things the document said that were not true Each of these shipped into openapi.yaml and therefore into every generated SDK, and none of them could fail a build, because a wrong description is not an error. A PHANTOM REQUEST BODY. hasBody asked only the method. So POST /things/:id/verify, whose whole input binds from the path, published a requestBody marked required whose one property WAS the path param — every generated client gained an argument the caller must construct to repeat a value it already passes in the URL. Ten instances were live in the fleet's published subsets. hasRequestBody refines hasBody with the clause that was missing: the input must have at least one field the URL does not already carry. The wire is untouched — bindURL binds the path last, so a body repeating a path param never won anyway. A TYPE DESCRIBED BY ITS PARTS INSTEAD OF ITS WIRE FORM. schemaOf reached the custom-marshaler rule only inside the struct case, but the rule is about the MARSHALER. json.RawMessage is a []byte whose MarshalJSON emits raw JSON, so it fell to the slice rule and published as an array of integers — for relay ops whose answer is frequently an array or null, the document asserted a shape it can never have. time.Time fared worse: all its fields are unexported, so it published a $ref to a schema with no properties, leaving every timestamp in every SDK undescribed. The marshaler check now runs first, with time.Time named as the one marshaler whose output shape is documented (RFC 3339, format: date-time). A plain []byte still reflects as a base64 string, because it has no marshaler. A SUMMARY WITH A LINE BREAK IN IT. A doc comment wraps in Go source; a sentence ends where the next begins, whether that is a space or a newline. The summary is neither fact — it is one sentence on one line, in the spec, in CLI help, and in the first docstring line of every generated SDK. sentenceEnd now accepts a break as a terminator and the result is re-joined on single spaces. A ROUTE THAT COULD NOT BE DECLARED AT ALL. bindURL matched on the json name, so a path parameter and a body field that are the same word for two different things (a worker's name in the path, its source in the body) collided: the body field was silently overwritten by the path value, making the route structurally untypable. Fields now name themselves for the URL with `url:` and opt out with `url:"-"` — one tag answering one question, separate from what `json:` answers. The CLI reads the same tag, so the opt-out gains a flag rather than losing one. Co-authored-by: Hanzo Dev zޕJxZtree 4f1ce079c25bfe782c121c5a39c0901bdcf897f7 parent 5dfa4ef616777248a380d79be8395dadc4f0d493 author Zach Kelling 1785418109 -0700 committer Zach Kelling 1785418109 -0700 zipdoc: an imported type's fields had no docs, so the plane projected nameless The extractor paired the type-checked view of a struct (authoritative for names and tags) with the parsed view (which carries the comments) by matching a byte OFFSET. That works only for a package this pass loaded from source. A position in an IMPORTED package comes from export data, whose positions carry the real filename and line and a synthetic offset — the importer fabricates a file whose every line is one byte long. So the offsets never matched the moment a type lived in another package. Which is every op whose In and Out live in the call plane. Those ops published a description and ZERO field descriptions: the OpenAPI schema, the CLI flag help and every generated SDK's field docstrings were all nameless, and nothing failed because a missing description is not an error. Match on the LINE, which both views agree on, and disambiguate by type name. Co-authored-by: Hanzo Dev 7Ιxp tree c4258f119ea008b76346a48d2a67f3c30b814784 parent fb32c54715b643fdc25042b15bc4277f3b164adf author Zach Kelling 1785372868 -0700 committer Zach Kelling 1785372868 -0700 plugin: a repo declares its routes, and the host discovers them HIP-0106's plugin contract, in the framework rather than in 116 repositories. Declaration projects the LIVE ROUTER — every method+pattern, complete by construction, so a route a plugin serves and does not publish is still declared. That is the analytics-ingestion outage class: the published paths were listed, the four ingestion doors were not, and every product beacon in the fleet answered 405. Declaration/Route/(*App).Declaration what a host discovers /.well-known/zip/plugin.json the same value off a running child (*App).Described ` openapi ` / ` declare ` Tenant the tenancy read, with the real rule Delegate a continuation for another org Ask dial a peer by name, invoke one op (*App).Peer peer ops on their own app, own socket (*App).Ops /healthz + /readyz + /metrics Config.Eager the one fact a router cannot show App.claim a second claim of a prefix is an ERROR zip/runtime -> zip/js a language runtime is an adaptor Four things the reference plugin falsified while being built: - Describe was already taken. zip.Describe(methodPath, Doc) is the doc registry generated code calls. The projection writer is (*App).Described, one call, because argv is read in one place and a main cannot forget to forward it. - zip's control plane is NOT all under /.well-known/. /docs and the MCP path are not, so a prefix filter let a child declare them — paths outside /v1/ that every plugin serves and whose first claimant takes the HOST's document and agent door. App.control now registers and records in one call, so leaking one is impossible rather than unlikely. - OPS_PORT appeared in no Go file in the fleet. HIP-0119 named the paths and nobody implemented them, so conformance meant 116 repos hand-rolling three routes and a listener. It is one sibling app now, brought up by Listen. - There is deliberately NO default ops port. A default made every second app in a process die on "address already in use" — a plugin has two apps in it and a test process has many. The deployment states OPS_PORT; a host states none on a child, so a child correctly owns none. Load's duplicate claim used to return nil while the first registration kept answering: the losing plugin's whole surface served another plugin's 404 and nothing said so. It is now an error naming both claimants, all-or-nothing across a plugin's prefixes, taken before anything is spawned. a.ops was the op registry and is now a.registry — the ONE registry the OpenAPI document, the MCP tool, the CLI command and the plane op are all projected from. a.ops is the ops sibling. Co-authored-by: Hanzo Dev  x tree 2b845248e8fccfb4051024979847258438148768 parent 30885479aba821a234e108863e2bde65e5fb66bb author Zach Kelling 1785366797 -0700 committer Zach Kelling 1785369984 -0700 runtime: the JS toolchain is opt-in — Loader/Module are declared at the root The root zip package imported zip/runtime for exactly ONE thing: the type of Config.Loader. zip/runtime imports dop251/goja (a JS interpreter) and evanw/esbuild/pkg/api (a JS bundler) directly, so every consumer of zip compiled a JavaScript toolchain to name an interface — and the interface was itself only a type ALIAS of a dependency-free leaf, internal/runtime. Loader and Module now live where they are consumed: the zip root, next to App.Module, which is the only thing that calls them. internal/runtime and the zip/runtime aliases are deleted — one home, one name. zip/runtime keeps goja and esbuild and stays the JavaScript implementation; it is simply a separate import now, so the cost lands on the binaries that ask for JS. There is no hot-path coupling to invert: the root only ever calls through the interface (a.loader.LoadOne) into a loader the consumer constructs and passes in via Config.Loader. That contract is unchanged. Measured with `go list -deps . | wc -l` in a CLEAN module importing only zip, outside any other module graph: before 315 packages, 33 of them goja + esbuild after 258 packages, 0 opt-in 314 packages, 33 (a consumer that DOES import zip/runtime) 57 packages leave and none arrive: esbuild 25, goja 8, x/text 9, regexp2 3, sourcemap 2, pprof 1, go/ast+token+scanner, archive/zip, encoding/base32, hash/maphash — plus the two zip packages no longer reachable. hanzoai/cloud, which imports zip/runtime nowhere, measured against this commit vs its parent (same zip baseline, so the delta is only this change): cmd/cloud 402 -> 346 (JS 33 -> 0) cloud root 603 -> 547 plugin/crm 605 -> 549 plugin/storage 716 -> 664 cmd/cloud builds, and `go build ./...` yields the byte-identical error set before and after (3 pre-existing k8s/autoscaling failures, unrelated). Also corrected a doc claim that was already false: Config.Loader said it "is satisfied by *extruntime.Loader". It is not, and was not before this commit — extruntime.LoadDir returns map[string]extruntime.Module, and Go requires IDENTICAL result types, so an equivalent method set does not satisfy the interface. The docs now say an adapter returning zip.Module is required. Co-authored-by: Hanzo Dev hmx"tree 67a083bcfcd4b788ebf1cdccd0e572b76db44c31 parent 0f32a1dbd9e8a3e4aa4eb1958c2eb8b0a11e5251 author Zach Kelling 1785330911 -0700 committer Zach Kelling 1785330926 -0700 call: the plane carries ZAP, not JSON The op-call plane marshalled its body with encoding/json. That put a text format inside the binary protocol: two services on one host, holding the same struct in memory, serialized it to JSON and parsed it back to cross a socket. JSON is the BOUNDARY encoding — it belongs on the REST routes a browser reaches and in the MCP envelope an agent reads — and it has no business between our own processes. internal/zapenc derives a wire layout from the In/Out type itself: fields take slots in declaration order, each aligned to its own width, which is the rule zap's own schema builder applies. Nothing is named on the wire — a field IS its offset — so the bytes on the socket are the bytes in memory, and the type declaration is the schema both ends read. bool, every sized int/uint, float, string, bytes, nested structs, pointers and slices cross; a map or an interface is refused at encode rather than dropped, because a field that silently does not cross is how a callee decides on a value nobody sent. Refusals cross as ZAP too, status intact, so errors.As still recovers the *HTTPError the callee returned. op.invoke takes its decoder as a PARAMETER, so there is still exactly ONE handler core under REST, MCP, CLI and the plane. The encoding belongs to the transport; the contract is the same op either way. The layout is the type, so the compatibility rule is: append fields at the end, and only at the end. Reordering, inserting or retyping changes the wire. Co-authored-by: Hanzo Dev Rc[xOtree 34dd055732170aadc3df754de615df52548f3128 parent 5835826a43fa05a38b297b01ff644449c11d8e95 author Zach Kelling 1785307027 -0700 committer Zach Kelling 1785307027 -0700 load: a lazy plugin had one door, and the fleet comes in another Lazy is what makes many plugins affordable, and a lazy plugin starts on exactly one trigger: a request reaching one of its prefixes. A host that reaches its plugins another way has no way in at all — Hanzo's fleet calls app-to-app over each app's own unix socket, which never touches the router, so nothing ever started the callee and the socket it would have bound was never there. Correct by design, inert in practice. Start is that second door. It goes through target() — the SAME single-flighted path a prefix request takes — rather than a parallel one, so a burst of first callers arriving by either door still produces exactly one child. It is what Reload is not: idempotent. Reload on a running plugin starts a second child and retires the first, which is right for a version swap and wrong for 'make sure this exists'. An Unload'ed plugin stays down; a deliberate stop the next caller silently undoes is not a stop. shortDir in the test: a plugin's socket lives inside Plugin.Dir and the kernel caps a unix path at 108 bytes, so t.TempDir() plus a descriptive test name overflows it and the child reports 'exited before listening'. Co-authored-by: Hanzo Dev ,hxrtree 11a7ed13e95704bd2a7508191e8b3b0968649d43 parent 6d59210228a50c51579349a45761a0c17e998cd4 author Zach Kelling 1785299298 -0700 committer Zach Kelling 1785299298 -0700 caller: forward the whole identity, and let a background caller state one identityHeaders forwarded five of the nine headers a gateway asserts, so a callee reached over the op-call plane saw a principal with no project, no minted name, no owner and no org-admin bit — while the same handler reached over REST saw all four. Two of them decide authority: owner carries membership of a reserved platform org, and isOrgAdmin says only that someone administers their own org. A subset let a callee read the second for the first, or find neither, without anything on either side saying so. Add WithCaller for the caller that has no inbound request to propagate. A grant issued when an org opens and a meter that debits after the response has gone out both act FOR a tenant; without a way to say which, the only place left for the org is the argument, and an org in the argument is one the caller chose. An inbound request still wins, so this supplies an identity where there is none and cannot override one. CallerOf reads it back off the same context, so a job sees what it is about to send. Ctx gains Project, UserName, UserOwner and IsOrgAdmin, so the REST reader and the call reader spell one vocabulary. TestForwardedIdentityCrossesWhole fails on exactly the four dropped fields if the array is narrowed again; the other three cover the stated path, the two admin scopes staying apart, and an unattributed call staying anonymous. Co-authored-by: Hanzo Dev ŵIxxttree 7d4e2ff0065221c7ee38a20c781b9616d156f674 parent ff7fe451d6b6ef415c5de650fc44c9a7a8a1dcba author Zach Kelling 1785297465 -0700 committer Zach Kelling 1785297465 -0700 zipdoc: prose follows the op's REAL path, and an unresolvable router is loud zip learned group registration in v1.18.0. zipdoc did not. It keys prose on the path LITERAL in the registration call, so `zip.Post(g, "/targets", …)` filed under "POST /targets" while the op's identity is "POST /v1/agents/targets" — docFor looked up the composed path, never matched, and the doc comment vanished from the OpenAPI description AND the MCP tool description. Silently. That is the worst shape a bug can take here. The doc comment IS the product surface: it is what an SDK user reads and what a model reads to decide whether to call a tool. A migration using the natural group form would produce hundreds of typed ops that pass every gate, regenerate cleanly, and carry no prose anywhere — and nobody would notice until an agent tried to use the tools. zipdoc now resolves the prefix the way the router composes it. groupPrefixes walks each file for `g := .Group("/prefix")` and records what each router variable stands for, composing nested groups; routerPrefix maps the registration's first argument to that prefix, with *zip.App as the root that has none; joinPath mirrors zip's own composition. So the key written is the path zip registered. An unresolvable router is now an ERROR naming the call, never an assumed empty prefix — because a prefix this pass cannot see is prose filed under the wrong identity, which is the silent drop it exists to end. Verified both directions against hanzoai/cloud: the ergonomic `zip.Post(g, "/targets", …)` now yields `POST /v1/agents/targets`, and a router the pass cannot resolve fails with the file, the line, the reason and the fix. Co-authored-by: Hanzo Dev Nrx$tree 9936a83eb06605dfbb6aad5115abcd8c275f56a8 parent 9d386ae349b70c02ab9d5b851df9dfaf3230fd76 author Zach Kelling 1785288560 -0700 committer Zach Kelling 1785288560 -0700 typed: WithStatus — a 201 the document can see zip wrote 200, or 204 for a nil Out, and had no vocabulary for anything else. A service that answers 201 Created therefore had to reach around the framework and set the status per request, from inside the handler. That works on the wire and nowhere else: the status is a CONTRACT detail written into a side channel no projection can read, so the document says 200, every generated SDK says 200, and the route has always sent 201. It is the same failure as a query parameter's required-ness being invisible — a contract detail that exists only at run time is not a contract. So the status is declared on the op, where the registry can project it: zip.Post(app, "/v1/things", create, zip.WithStatus(201)) op.Status keys the document's responses object, so a client generated from it expects what the service sends. The schema rides along unchanged — a 201 describes its body exactly as a 200 does — and an op that declares nothing keeps the old defaults byte for byte, so no existing document churns. HTTP-only by construction. The REST route and the document read it; the MCP tool, the CLI command and the op-call plane are untouched, because each carries its own outcome. A void op keeps the status it declared rather than falling back to 204: the declaration is what the caller was promised. A non-2xx panics at declaration rather than failing at request time. An error status is the error a handler returns (ErrNotFound and friends); letting a declaration state one too would be two places for one fact, free to disagree. Co-authored-by: Hanzo Dev 'x,qxtree 7961eba03a8012ee94bba43d544c4fb3337da029 parent b1dc6ac252864e61d4f5101b3e9a304f654fd22e author Zach Kelling 1785285041 -0700 committer Zach Kelling 1785285041 -0700 typed: OpScope is exported, because a decorating Router has to implement it v1.18.0 sealed OpTarget with an unexported method, reasoning that nothing outside zip should claim to be somewhere an op lives. That reasoning was wrong, and building hanzoai/cloud against it is what said so: hanzoai/commerce's middleware.Mint decorates a zip.Router — it prepends a platform-only gate to every route registered through it, so that money-mint routes cannot be declared without their gate. A sealed method made Mint uncompilable, with no fix available to it from outside this package. Worse than uncompilable is the version that compiles: a decorator that embeds the wrapped Router and inherits its OpScope registers a typed money-mint op with NO GATE. The decorator's entire purpose, silently skipped, on the routes that move money. So the method is exported and returns a value that says what it is — OpScope{App, Prefix, Middleware} — and its doc says what a decorator owes: fold your middleware into s.Middleware or the op you register is ungated. A struct rather than three returns so a later field does not break implementors. TestOpTarget_AnOutsideDecoratorCanCarryOps is the shape, written as an outside package would write it: embed the Router, override OpScope, assert the gate reaches a typed op. That test is what a sealed interface could not have. My compatibility check for v1.18.0 grepped the local source trees and not the module cache, which is why a published implementor got through. Building the consumer is the check that finds this; the grep is not. Co-authored-by: Hanzo Dev gxytree 08a64fd02138b4fab569425190591cf4526749f6 parent 810ca316b4a74c955afae1235ff86a47b91e00da author Zach Kelling 1785283680 -0700 committer Zach Kelling 1785283680 -0700 docs: say what a group carries, what a DELETE carries, and what is gone LLM.md leads with an upgrade note, because three of these are visible from outside and an agent bumping the pin needs them before it reads anything else: a typed Delete no longer reads a body, zip/zaprpc is deleted, and the document now declares a URL-borne field's required-ness and carries a bodyless op's example. The two "known bug" sections they replace are gone rather than edited — both described drift that no longer exists, and a known-bug section that outlives the bug is worse than none. What is left in their place is the rule: hasBody is what a method carries ON THE WIRE, read by the route, the document, the CLI's remote invoker and its flag derivation; op.invoke is unaffected because a call addressed by name has no URL. The zaprpc section stays, shrunk, because the fact worth keeping is not the package — it is that cloud's `zaprpc` alias points at zap-proto/go/rpc, a different module. Someone will meet that alias again. Two statements the release made false are corrected rather than left: LLM.md and migrate-from-gin both said a typed op cannot inherit a Group prefix, and clispec.go said the document only ever emits one level of $ref. subsystem-mount now shows the shape the note describes — a subsystem takes the Group it owns and declares its ops on that, so the composition root never repeats the prefix. Co-authored-by: Hanzo Dev cA5ZxStree 24abf77bcd72551152ed48ac5ff84f70aa861c95 parent 8f6dcca49e87decd44857e3759f4d2a6aad9d451 author Zach Kelling 1785283667 -0700 committer Zach Kelling 1785283667 -0700 zaprpc: delete the second envelope — it was reachable by nothing BREAKING: the github.com/zap-proto/zip/zaprpc package is removed. It was a parallel implementation of a wire format zip does not own: a 24-byte header with service and method as STRINGS, against zap-proto/go/rpc's 28-byte u32 ordinals with promise pipelining. A peer speaking one could not decode the other, so it was unreachable by the rest of the ZAP fleet. Nothing in the estate imported it, including zip. Its own docs mounted it with `app.ZAPRegistry()`, a method that has never existed in this module. It is NOT what hanzoai/cloud's service plane uses, and the reason that was worth checking twice is an alias: cloud imports `zaprpc "github.com/zap-proto/go/rpc"` — a different package in a different module, under the same local name. That module is untouched by this. Two ways to reach another service was always one too many. The op-call plane is the one: zip.DialApp + zip.Call address an op by its operation id, typed both ways, over whatever transport the callee is listening on, projected from the same registry as the routes, the document and the tools. For the ZAP wire format itself, use zap-proto/go/rpc, which owns it. Co-authored-by: Hanzo Dev lMxG tree 533d053fc078e36f5f0e21e959e20de091cb7bb2 parent 900da9c94cd584d122e99babf5b1e46cabdd34d4 author Zach Kelling 1785283667 -0700 committer Zach Kelling 1785283667 -0700 wire: a bodyless method, spelled once — DELETE stops reading a body BREAKING, on purpose. hasBody called itself "the ONE place that rule lives" and was the only site that called it; three others re-stated it differently and DELETE had drifted: - typed.go read a body for anything but GET/HEAD, so a typed Delete decoded a request the document says has none; - cli.go's Remote.Invoke SENT that body, so the CLI's remote path and its in-process path disagreed about one op; - cli.go's bindIn offered every field as a flag, including ones no URL can carry — `--tags '["a"]'` on a DELETE marshalled fine, went out as a query value, and was dropped by the binder. The command silently did nothing. All four now call hasBody. A typed Delete takes its input from the URL: path params and query string, which is what every client generated from that document already sent. It is a rule about the WIRE, not about the op — op.invoke still decodes whatever JSON it is handed, because a call addressed by NAME (MCP tools/call, zip.Call, a command) has no URL to carry half the input in. Two things a bodyless op lost in the document are closed with it: - REQUIRED-NESS REACHES THE PARAMETER. urlField.required reads the same `validate:"required"` the body schema does. Every query parameter was hardcoded optional, so a field the handler refuses to run without was described as optional and every generated client made the argument optional to match — a document describing a call that cannot succeed. - THE EXAMPLE SURVIVES. A bodyless op has no requestBody for the doc comment's Example to live in, so it rides the parameters that carry its values and CommandsFromSpec rebuilds the object from them. Before this, every GET and DELETE reached the published reference and the generated CLI with no example at all. TestCLI_SpecAndRegistryAgree is now plain equality over every field of every command for every method. The skip is gone, and so is the divergence helper that replaced it one release ago: there is no divergence left to pin. Also: a validation failure names the field the way the CALLER named it, through the same jsonFieldName rule the decoder, the schema and the flag all read. Someone who sent `reason` was told `field "Reason"` is required — a name that appears nowhere in the document they were working from. Co-authored-by: Hanzo Dev rx*tree aa48625cff1db8df882b2c2993fe16827a3aa63e parent d74376912b1e32f814fa1895b5636762278900bf author Zach Kelling 1785283649 -0700 committer Zach Kelling 1785283649 -0700 typed: an op declares on a Group, because that is where routes already live zip.Get and friends took the *App and nothing else, so an app built on app.Group("/v1") could not put a typed op on its own router — it had to spell the prefix out per route, while the untyped handler inherited it for free. The friction pushed exactly the wrong way, on the one axis this framework cares about, in every codebase ported from a router that has groups. They now take an OpTarget: the App, any Router of it, or app.With(mw...). A group's prefix is part of the op's path and With's middleware composes around its handler, so structuring the router costs nothing in schema. The prefix is read off the ROUTER (fiber composes a nested group's when the group is made) rather than tracked a second time here, and zip composes the leaf with the same rule the router uses and registers THAT path — so op.Path is the route, one string, with no second composition to drift from the first. A typed op and an untyped one on the same group land on the same prefix, which is the test that says so. OpTarget's only method is unexported. The interface is sealed: an op lives on an App's registry, and nothing outside this package gets to claim otherwise. With() composes only when there IS middleware — wrapping unconditionally would materialise a *Ctx on every typed request to hand to a chain of length zero, and the typed path is measured. The first version of that wrapper captured the handler variable it was about to overwrite and called itself; the test that proves middleware runs is what caught it. Co-authored-by: Hanzo Dev +܀txHtree fde40ff0a1e20a30a55d2497155d0d75e1ef756e parent bbabddeaa884ae8dc153950482ba45c952379940 author Zach Kelling 1785281913 -0700 committer Zach Kelling 1785281913 -0700 docs: the typed op is the primary API — the README said the opposite README.md called `app.Get(path, fn)` "the primary API" thirty-one lines above the section describing the op registry as the one source of truth, and its first code block — the first zip anyone reads — declared every route untyped. LLM.md's verb table listed the untyped verb second, unqualified. The docs were recommending the one pattern that darkens every projection, which is a large part of why ~88% of the fleet's ops are untyped: the framework taught it. Typed ops are now unambiguously the default. The hero example declares one, the feature list leads with it, and the untyped verb is documented as the escape hatch it is — named, last, with an honest account of what it costs (no OpenAPI entry, no MCP tool, no command, unreachable by zip.Call) and the short list of cases where it is still correct. Also corrected: there are FIVE projections, not four. The CLI was a projection nobody counted — cli.go called itself the fourth and call.go said there were four in total, so the tables in both docs omitted one of them. LLM.md gains what the next agent needs: how the schema registry works and why a cycle used to be fatal, what changed on the MCP wire for nested types, the zaprpc-vs-zap-proto/go/rpc distinction with the table that settles it, and the hasBody drift updated to say it is now pinned rather than skipped — along with the two doc-shape gaps that pin exposed (a query parameter's required-ness is never derived, and a bodyless op's example does not survive the document), both owed to the same coordinated release. Co-authored-by: Hanzo Dev oMx tree af8b48e7708b5dd83de220ba70964177a0034019 parent 572aeb8750bbc881fee449aaa7bfd40950de6d39 author Zach Kelling 1785281901 -0700 committer Zach Kelling 1785281901 -0700 examples: declare typed ops, because that is what the examples are teaching Ten of eleven examples declared their surface with untyped handlers. An untyped route registers no op, so every one of them modelled the single pattern that leaves an endpoint out of the OpenAPI document, out of the MCP tool list, out of the CLI and out of the call plane — while the README two files away calls that registry the one source of truth. The examples are where the default is learned, and they were teaching the wrong one. hello, subsystem-mount, migrate-from-chi, migrate-from-beego, plugin/billing, plugin/host and internal/testplugin now declare typed ops. The migrate-from-* examples show the port as the two steps it is: mechanical first (same handler shape, one edit, and invisible to every projection), typed second, because stopping after the first leaves exactly the surface you were migrating away from. sse-streaming and websocket stay untyped and now say why in the file header: a typed op is one decode, one call, one serialize, and a stream has no single value to return while an upgrade has no response body at all. That is the whole list of reasons — a stream, an upgrade, a proxied byte range, a non-JSON body. express-in-zip registered two routes on app.Fiber(), BELOW zip entirely: no *zip.Ctx, no error handler, no middleware, no Authorizer, and no projection — served by the app but not governed by it, which is a security seam and not a shortcut. Both move onto the zip router. /runtime/:lang becomes a typed op, so "run this source in this language" is now in the document and is a tool an agent can call; the legacy JS wildcard stays a wildcard and says what that costs. testplugin's catch-all stays untyped for the reason it exists: it answers paths that do not exist, so a host mounting it at two prefixes can tell its own 404 from the plugin's. A wildcard is deliberately not one named endpoint with one schema. Every example was run and probed, not just built: 30 assertions across all eleven, including the openapi/mcp routes the typed ops now light up. Co-authored-by: Hanzo Dev 2jx[tree 526f5e3cf9c8fbcd704eb99642b3c86df7981251 parent 72353f9d03d8fdd1c0f5bd58e0e42710af5b7ac5 author Zach Kelling 1785281888 -0700 committer Zach Kelling 1785281888 -0700 docs: say precisely why the two registrars that project nothing cannot app.Module registers a route and no op, so an extension endpoint has a JSON contract that reaches no document, no tool list, no CLI and no call plane. That hole is now stated at the seam instead of discovered, along with the two structural reasons it cannot close today — a module is loaded at run time, so there is no Go type to derive a schema from, and a typed op cannot express the module's status/headers response envelope — and the one thing that would close it: an extension that DECLARES its contract on runtime.Module. zaprpc's HTTPHandler doc showed `app.ZAPRegistry()`, a method that has never existed in this module (the only implementation was in the dead hanzoai/zip fork), and justified its fiber.Handler return with an import cycle that does not exist — zip does not import zaprpc. Both are replaced with an example that works. The package is marked Deprecated and says what to use instead. It is NOT what hanzoai/cloud's service plane imports: cloud imports github.com/zap-proto/go/rpc under the local alias `zaprpc`, which is a different package in a different module — u32 ordinals and promise pipelining against this one's 24-byte string-keyed envelope, mutually undecodable. Nothing in the estate imports zip/zaprpc, including zip. Deleting it is owed, but removing an exported package from a public module is a breaking change and does not ride a patch. Co-authored-by: Hanzo Dev Wx "tree f7848248af85ac204501f6f204cbd7435d3410ff parent d15ad939f69a2abef4e1c599e49e30cf91519961 author Zach Kelling 1785281877 -0700 committer Zach Kelling 1785281877 -0700 openapi: one type, one definition — and a cycle can no longer take the process down schemaOfDoc took a `registry` map and never wrote to it. Two consequences, one cosmetic and one fatal: - no $ref sharing. A type reached by ten ops was inlined ten times. - NO CYCLE GUARD. `type Node struct { Children []Node }` recursed forever, so building the document overflowed the stack — and so did listing the MCP tools. A Go stack overflow is not recoverable, so a service whose input had a self-reference could not start at all. schemaRegistry makes the registry real: a named struct is described ONCE and every use of it is a $ref. The entry is claimed BEFORE the type's fields are walked, and that claim is the cycle guard — a type that contains itself finds the definition already in flight. Two packages that both call a type Config no longer overwrite each other either; the second is qualified by its package instead of silently publishing one type's fields under the other's name. The projection owns where its definitions live: #/components/schemas/ in a document, #/$defs/ in a standalone schema. rootSchemaOf is the standalone form an MCP inputSchema needs — the root inlined (a tool's schema has to BE the object) with everything it reaches carried alongside, and no $defs at all when nothing refers to anything, so a flat tool schema is byte-identical to before. Three more things stop re-deriving what the registry already knows: - PATH PARAM TYPES. They were hardcoded "type":"string" while query params consulted the input type — the same value described two ways depending on which half of the URL carried it. bindURL is ONE binder over ONE set of fields, so urlFields is now one list and the document reads it for both. - FLAG KIND. cli.go's flagType re-derived the type vocabulary from reflect. It now asks schemaOf what the field IS and maps the answer with specType, the same rule the spec-derived CLI uses, so a flag spelled from a Go type and one spelled from that type's published schema are equal by construction. - COMMAND IDENTITY. commandName computed a different op identity from opName and ignored WithOperationID entirely: renaming an op renamed it in the document, the tool list and the call plane while the CLI carried on spelling itself from the route. One op had two names and no test related them. Command.OperationID now carries the one token every projection uses, CommandsFromSpec reads operationId off the document, and an explicit id renames the command with everything else. TestCLI_SpecAndRegistryAgree stops hiding the hasBody drift. It used to `continue` past GET/HEAD/DELETE while the fixture registered no DELETE — the case was skipped twice over. It now registers one and pins the divergence precisely: the document names the registry's scalar flags and only those, declares them optional whatever `validate` says, and drops the example. None of that is endorsed; closing any of it fails the test and sends you to LLM.md. Co-authored-by: Hanzo Dev Qu^x Ttree 64ecdc8ad47c08c40e831ca3b26382c30a5a6a7f parent 2d402e3978953cde898ce4d976b49d07e479d7a0 author Zach Kelling 1785268565 -0700 committer Zach Kelling 1785268565 -0700 feat(call): services call services by op name, over ZAP on a unix socket The typed-op registry gets its fourth projection. An aggregator that reaches another app today either imports its package — dragging in that app's whole dependency graph, which is what turns a fleet of small services into one mega-binary — or hand-writes a client against its URLs, which is the schema copied into a second place to drift. Neither is necessary: the op already has a stable name, and now that name is callable. c, err := zip.DialApp("flags") // $ZIP_RUNTIME_DIR/flags.sock out, err := zip.Call[BoolIn, BoolOut](ctx, c, "flags_bool", &in) The plane is an ordinary route (/.well-known/zip/op/:op), so it rides every transport Listen was given and inherits the app's middleware, error handler, validator and Authorizer — exposed exactly as much as the REST routes and no more. It resolves through opByName + op.invoke, the same pair tools/call runs, without MCP's agent-facing envelope. Errors cross whole: the wire form is what errorHandler already writes, so errors.As sees the *HTTPError the callee returned, status intact. A void op yields (nil, nil). Generic, not generated, deliberately: a generated per-op Go client would put a second copy of the schema in the caller's repo on its own regeneration schedule — the drift this plane removes, one directory over — and would be a fourth client generator racing openapi-generator, which already builds the published SDKs from the OpenAPI projection. ONE socket-path scheme, used by both halves so they cannot drift: SocketPath(name) = RuntimeDir() + "/" + name + ".sock" RuntimeDir() = $ZIP_RUNTIME_DIR | $XDG_RUNTIME_DIR/zip | /run/zip A service serves at zip.Addr(zip.SocketPath("flags")), a caller reaches it with zip.DialApp("flags"). socketIn states the shape once; the plugin loader names a child's private socket with the same function. Listen creates the directory 0700 when missing, so the canonical path works on a fresh host. Identity is never forged, because the caller never states it. WHO the request is for is the gateway's assertion, forwarded by Ctx.Forward and read by CallerOf; WHAT is calling is SO_PEERCRED, read by PeerOf — the peer does not send it, the kernel answers on its behalf. nil means "cannot attest", so a check fails closed rather than reading a zero Peer as root. MCPTools() exposes the tool surface the same way OpenAPISpec() exposes the document, so a host can compose plugins' tools in-process without a round trip. openapi.go now reads operationId from opName, the one place that rule lives, instead of re-deriving it inline — all four projections address an op by the same token. Cost: Benchmark_TypedRoute/typed 28 -> 29 allocs/op (the one context value that makes CallerOf and PeerOf possible). The untyped path is unchanged at 27 and still pinned at one heap value per request. Proven end to end: a real plugin on a unix socket, a client dialing it, a typed round trip with no HTTP in the path — the reply frame is decoded with zaphttp's own codec, HTTP/1.1 text gets no HTTP answer, and the peer credential the handler observes is proof the transport was unix. Full suite green with CGO_ENABLED=0 and under -race. Co-authored-by: Hanzo Dev ﵻx4tree 75090b98afabe9f57cc80e30a241c5ed478fb006 parent e92d162de1c17e3bf2700052ded6d032c3bfd9a1 author Zach Kelling 1785259890 -0700 committer Zach Kelling 1785259890 -0700 docs: the doc comment now reaches the tool list too Records what v1.17.6 changed and, more usefully, why it was invisible: the spec and the tool list disagreed about the same op and only the spec was ever looked at. Co-authored-by: Hanzo Dev ,(x7tree d4d2d64eb9ff85c8c2b3167b1845dc0f9eab65a1 parent d8bab06112c10bf436bc48783f76d985c236d97e author Zach Kelling 1785257190 -0700 committer Zach Kelling 1785257190 -0700 zipdoc: record the module-load vs package-load extraction divergence Co-authored-by: Hanzo Dev b=x*tree 17b8728b324c1b741b72ffd1be28e138197a4c39 parent 93ba6784c6b8d2ba63f0daa190a9ef6bc21d13dd author Zach Kelling 1785257118 -0700 committer Zach Kelling 1785257118 -0700 mcp: the doc comment describes a tool too, not just a spec d417801 made the doc comment the spec, and bb518e2 made it the CLI help. The tool list kept reading WithSummary alone, so every op documented the canonical way — a doc comment, no WithSummary — reached a model as an empty description over a schema whose fields said nothing. That is the surface where the words matter most: a human picking an endpoint has the whole spec open, a model picking a tool has only this list. mcpTools now reads the same docFor extraction openapi.go and cli.go read, and builds the inputSchema with schemaOfDoc so field prose lands on the fields. WithSummary stays the fallback, so an op in a package cmd/zipdoc never ran over still names itself. Co-authored-by: Hanzo Dev %O֒'xrtree 3b8ec43687c398d3bb083f9862adff4354122707 parent 250e3206f2a2dcaaa0bb241b4906f35b77cc9c62 author Zach Kelling 1785214691 -0700 committer Zach Kelling 1785214691 -0700 fetch: key the cache on the digest alone The cache path was Name+"-"+Sum while the comment said the name IS the digest. It was not, and the gap is expensive: one multi-call binary mounted under 108 names downloaded 195MB 108 times and kept 108 identical copies — ~21GB to negate the whole point of shipping one artifact. Keyed on Sum, the first plugin to start warms every other. Co-authored-by: Hanzo Dev Aڕ(xztree e7d9c608cb6f9d029860f58794cf750d0d81668a parent 3b86d4dfba857df1be2cca80359f3d6584cc5645 author Zach Kelling 1785212951 -0700 committer Zach Kelling 1785212951 -0700 plugins: one Reload, and Status stops stuttering ReloadTo was Reload wearing a second name. A restart is a reload to what is already there, and every source a plugin can have is a field of Plugin, so widening the parameter subsumes the byte form: Reload(name, Plugin{Bin: b}). One operation, one name, one path through the three invariants. PluginStatus -> Status: zip.PluginStatus says plugin twice. Co-authored-by: Hanzo Dev %bx"tree 047cbcd33c99465655b544e258a97c5c107d9653 parent 170e572463db51c1b6304f0464b05408b1f00fe9 author Zach Kelling 1785209092 -0700 committer Zach Kelling 1785209092 -0700 plugins: pin a version, roll it back, and make disable stick Three things a control plane needs that Reload alone could not express. ReloadTo(name, Plugin) swaps a plugin to a DIFFERENT artifact — another URL+Sum — where Reload only restarts the one it was loaded with. Rolling a version back is that call naming an earlier digest, and since the digest is the cache key the bits are already on disk: the rollback touches no network. Reload is now that call with a Bin set, so there is still ONE reload path and the three invariants hold for both by construction. A new artifact replaces the old one whole. Leaving the previous Bin in place would shadow the URL just asked for, since start() prefers Bin — the swap would report success having restarted the version it was already running, and PluginStatus.Version would name bits that are not the ones serving. Unload now pins a LAZY plugin down. target() starts a lazy plugin on the request that reaches it, so the next request undid the Unload: disable did not stick for exactly the plugins a many-service host runs, which is nearly all of them. PluginStatus.Disabled tells that deliberate stop from a crash — both answer 503, so without it an operator pages for a maintenance window. TestUnload_LazyStaysDown fails against the previous behaviour with status 200. Co-authored-by: Hanzo Dev U$(sx:tree fcb8a92631c9173f7b3d85d4489eec87c2c70bee parent 26ac297f6a6f0356b15343849aea337f2004f0ab author Zach Kelling 1785196769 -0700 committer Zach Kelling 1785196956 -0700 cli: the registry is the CLI, and the doc comment is what describes it One registry, three projections. A typed op already produced a REST route, an OpenAPI path and an MCP tool; it now also produces a command. cli.go derives ` ` from the op's own identity, so adding a route can never rename an existing command, and LocalInvoke runs it through the op's own invoke seam — a fused binary needs no client because the command IS the handler call. clispec.go builds the same commands from a served spec, which is what lets the CLI drive a service it was not linked against. cmd/zipdoc + internal/zipdoc close the gap Go leaves: doc comments do not exist at run time, so prose reaches the spec only via a build-time AST pass. Field docs and examples are extracted from source and keyed ".". Two defects found by making the projections agree: commandName treated "ends in a parameter" as the only way to address one thing, so GET /v1/paas/apps/:app/deploy became apps-deploy-LIST — named for a collection, returning one deploy. The route already says which it is past its parameter: /apps/:app/deploy is singular, /nodes/:node/jobs is plural. OpenAPI parameters carried no description while the registry had one, so the same argument had help in-process and none from the spec. Both now read the same key, and query parameters get it too. internal/jsontag exists so the reflect view of the wire-name rule and the AST view cannot drift; transport gains a dial-only https, because reaching a published API is an ordinary Mount and terminating TLS stays the ingress's job. Co-authored-by: Hanzo Dev bthxtree bf369bdd6b610fd01cf010bb93ce26b0ff84b6cd parent 4b79de5cc41a8a9f3281c53b85983e90ac323708 author Zach Kelling 1785195522 -0700 committer Zach Kelling 1785195566 -0700 bench: price the plugin hop, because the trade is not decidable without it A plugin buys independent build, release, restart and per-process measurement, and charges a unix-socket round trip for it. Nothing measured that charge, so every argument about where to draw the boundary was an argument about a number nobody had. Benchmark_PluginHop serves the SAME route two ways through the same host — once linked in, once by a child — so the delta IS the hop. On this contended box (load ~100, 9x sample spread) the minimum of 18 samples, 8 of them A/B interleaved one round per process: linked 410 ns/op 482 B/op 7 allocs/op plugin 10360 ns/op 51 B/op 1 allocs/op ~10 us, ~25x. The ratio is the misleading half: the denominator is a handler that only encodes two fields. Against work a service really does — a SQLite query at 10-100 us, a network call at milliseconds — 10 us is 0.01-10%. A plugin is affordable exactly where the handler does real work, which is why the boundary belongs at a service and not at a function. The allocation columns move the other way and are exact on any host: the HOST drops 7 -> 1 allocs and 482 -> 51 B per request, because the response is encoded in the child now. A host that stops doing the work stops paying for its garbage. buildPlugin takes a testing.TB so the benchmark builds its subject exactly as the tests do, rather than growing a second builder. Co-authored-by: Hanzo Dev j5~xtree 163606cad1cb28db01ffa5aa1d44c1de8447b25b parent 0ff1091763780d1b585a0c943f4e4d9ae46c24be author Zach Kelling 1785195365 -0700 committer Zach Kelling 1785195371 -0700 feat(typed): a typed op reads the whole URL, not half of it An op bound its input from the body and the path and stopped there, so the query string — the other half of the URL — was unreachable. That made every route carrying `?q=` inexpressible as a typed op, which is most of a read API: it had to stay an untyped handler, and an untyped handler is absent from BOTH projections. Measured on hanzoai/cloud: 1372 live routes, 0 MCP tools, because not one route could be typed. bindPath becomes bindURL — one binder for both URL sources, because a path param and a query param are the same kind of value (a name and a string carried by the URL) and two functions for one idea drift. It converts by the field's kind (string, bool, sized ints/uints, floats) instead of binding strings only. The three sources bind in increasing authority: body, then query, then path. Query beats the body because it is part of the URL; path beats query because it is the part the router MATCHED on. The authorizer still runs below all three on the same decoded value, so the target it authorizes is the target the URL named. A malformed scalar leaves its field zero rather than failing the call: `?limit=abc` is a caller's typo about ONE field, and refusing the request would make a typed GET brittler than the untyped handler it replaces. `validate:"required"` is how a field becomes mandatory. The document follows the binder: a bodyless op declares its non-path input fields as query parameters, typed and optional. hasBody() is the single predicate deciding "body or query" for both the binder and the doc, so the two cannot disagree about what a request looks like. MCP is untouched — a tools/call carries every argument in its JSON object, so neither query nor path binds there. Co-authored-by: Hanzo Dev +ΚdxJtree 114a24400c8a9fa415ebf1b2c6dbea0ae3a0a6d7 parent 4ed2d9c1e44f0831e0c001dfa074764f90cd0abd author Zach Kelling 1785194847 -0700 committer Zach Kelling 1785194847 -0700 feat: the doc comment IS the spec — descriptions, field docs and examples A spec with no descriptions and no examples is a reference someone reads, not one they can press "try it" on, and that gap is most of what an API portal is for. This closes it without anyone writing anything twice. Go does not retain doc comments at run time — reflection sees types and struct tags, never comments — so prose can only reach the spec through a build-time pass over the AST. That constraint is the whole design. The alternative is WithSummary("…") sitting directly under a doc comment that says the same thing: two places to change, one to forget. cmd/zipdoc (next) walks a package and emits Describe calls carrying the handler's doc comment, each In/Out field's comment, and the Example/Response bodies written in that comment. buildOpenAPI merges them: operation description, per-field descriptions keyed by Type.field so an In and an Out "limit" do not collide, and request/response examples emitted as raw JSON so a malformed one is wrong loudly. The summary falls back to the comment's first sentence, because Go's own convention already makes that a summary — so nobody writes a summary at all. Degrades cleanly: with no generated file the spec is exactly what it was, schemas without prose. Nothing breaks by not running the generator; it just stays terse. Co-authored-by: Hanzo Dev 6oxtree 1a11a428ad5dc72f0efdfdb8a5b68c9166dbfd00 parent 398300dd19500a88b1c41c99aa3e2411ec7c6f7b author Zach Kelling 1785193322 -0700 committer Zach Kelling 1785193351 -0700 feat(ci): publish the reference plugin per OS/arch on every tag zip defines the install contract — URL requires Sum, the digest is verified before the file is ever made executable, and it doubles as the cache key — so zip is where a runnable proof of it belongs. examples/plugin/billing now ships as a release artifact for linux/amd64, linux/arm64 and darwin/arm64, which means any host can exercise its own install path against real published bits without building anything. It rides the pipeline this repo already has: one `binaries:` block in hanzo.yml, read by hanzoai/ci. Nothing here grows a second release lane. https://github.com/zap-proto/zip/releases/download//example-billing-- https://github.com/zap-proto/zip/releases/download//binaries.json # url + sha256 That is the point of the URL form and it was documented only as a doc comment on Plugin: a plugin is built ONCE, per OS/arch, and every host picks up the same artifact. Neither side rebuilds for the other — the plugin's repo ships bits, the host's deployment names them — and if URL and Sum come in as configuration, even moving a host to a new plugin build stops being a host rebuild. Docs say so where someone looks for it: examples/plugin/README.md (the lane, the URL shape, why Sum is not optional, what the digest-keyed cache buys), the host example's own comment, and LLM.md — which also stops claiming Plugin takes exactly one of Addr/Bin/Path, and stops writing the pre-multi-prefix Load(prefix, Plugin) signature. Co-authored-by: Hanzo Dev %hkpx tree c5db5079f46f057998846c29a13eaee53dcf646a parent 954779fc31a915319a99a2c25b9e931583f726e2 author Zach Kelling 1785193115 -0700 committer Zach Kelling 1785193115 -0700 perf: one request, one Ctx — the wrapper stops paying per handler toFiberHandler materialised a fresh *Ctx for every zip handler a request passed through, so the wrapper's cost grew with the chain rather than with the traffic. A service running Recover + RequestID + Logger + CORS above its leaf allocated six of them per request; only the shape of the route was ever measured, so the growth never showed up. A request now gets ONE *Ctx, created on first touch and kept in the request's own user-value storage — the lifetime is exactly right, since both transports clear those before dispatching (zap-proto/http's serveConn, fasthttp's keep-alive loop). Allocations per request go 1/2/4/6 → 1 at chain depth 0/1/3/5, and 12 → 8 for the production stack above. Sharing the value also makes it carry: c.SetLog() in middleware now reaches the handlers below it, which is what middleware.Logger has always meant by attaching request_id / org / user. It attached them to a Ctx that was discarded one handler later. Benchmark_ZipTax reused a RequestCtx without clearing user values between iterations, which after this change would have reported a triumphant 0 allocs/op for a path that allocates one per request. It clears them now, and Benchmark_ChainTax measures the axis that was missing. Min of 24 alternating samples, contended 20-core arm64: depth 5 280.8 → 143.6 ns/op (-48.9%), depth 0 76.4 → 78.9 (+3.3%) — a bare route pays ~2.5 ns to store a value it won't reuse; anything with middleware wins several times that. allocs/op are exact. Co-authored-by: Hanzo Dev @n0x tree 51aaa23d235cbc990e9b2eca12f3e7ac781b30c0 parent 5bcede4533b5613a595133625bfa14a2d6e82ba8 author Zach Kelling 1785192789 -0700 committer Zach Kelling 1785192789 -0700 fix: a plugin's status names every prefix it owns, not just the first v1.15.0 let one plugin own several route subtrees, but PluginStatus kept reporting a single Prefix. A fleet view that says o11y serves /v1/o11y understates what goes dark when o11y does — /v1/sentry goes with it. The remote (Addr) branch was worse: it never recorded prefixes at all, so a split deploy reported the one prefix a log line happened to use. Prefix stays (it is the log-line name, and the first prefix by definition); Prefixes is the whole surface. Co-authored-by: Hanzo Dev _Rx-tree ceabc8da071beebd94e9eade629232654effeef6 parent 3d7fc4e43c1c1c0fd4a1eb204212c295547de215 author Zach Kelling 1785192691 -0700 committer Zach Kelling 1785192691 -0700 feat: Lazy — start a plugin on its first request, not at boot Routes register at Load either way, so the served surface is identical; only the process is deferred. That is what makes many plugins affordable. A host composing 69 services eagerly pays 69 processes, 69 resident sets and 69 startup times at boot for a set that is mostly idle. Lazily it pays for the ones traffic actually reaches, and a CLI that touches one service starts one. zip.Load(zip.Plugin{Name: "reports", Bin: bin, Lazy: true}, "/v1/reports") The first caller through the mount starts it, single-flighted, so a burst of concurrent first requests produces ONE child rather than one per request. A failed start is not cached — the next request tries again, because the usual cause is a dependency that has not come up yet. Steady state is one atomic load, the same as an eager plugin. Opt-in rather than default: the cost moves to the first request, so a latency-critical prefix should stay eager. Status reports it honestly — registered but Running=false with no PID until something asks for it. Co-authored-by: Hanzo Dev Xx#tree 92e089f1d9a46d37f55ca168a201948577be8331 parent 1d67323b50bf4b33e33d06e2c877c717d9bfdc6e author Zach Kelling 1785192043 -0700 committer Zach Kelling 1785192043 -0700 feat: supervise plugins, and account for what each one costs A plugin that panicked was invisible and permanent. Nothing watched the child, so when it died cur still pointed at the corpse: every request became a connection error dressed as a 502, Plugins() kept reporting Running, and only a manual Reload recovered. A plugin is a separate process precisely so a panic cannot take the host down — which is only true if the host notices. It notices now. The supervisor sees the exit, stops serving from the dead instance (503 "deployed but down", the truth, rather than 502 blaming an upstream that no longer exists), and restarts with capped backoff. An instance retired by Reload or Unload also exits; a compare-and-swap tells the two apart, so only a death that was still current counts as a crash. Restarts is reported separately from Reloads — deliberate swaps and crashes should never be one number, and a climbing Restarts is a crash loop. Proven, not argued: TestPlugins_SurvivesPanic panics the plugin on a goroutine, where no recover() can catch it, and asserts the host survives, the pid changes, Restarts increments, and the same routes serve again with no re-registration. Child exit is now a closed channel rather than a single-value one, because the supervisor, a drain and Shutdown all need to observe the same exit and the first reader would otherwise starve the rest. Also adds per-plugin resource accounting, read from /proc: Usage{CPU, RSS, Threads, FDs} // measured, not self-reported This is the observability a monolith cannot offer at any price. One process has one RSS and one CPU clock, and nothing inside it can be attributed to a subsystem — "which app is eating the memory" is an argument. Running a service as its own process makes it a question with an exact answer. Measured on a live plugin: rss=12.7MB threads=5 fds=7. And plugin output is tagged with the plugin name. An untagged line in a merged stream is worse than useless: you can see something is wrong and not what. Co-authored-by: Hanzo Dev ZNxtree cf50a3c9c22dcb8d11eaf5834e5aa5a3f46d4fc6 parent 2b895a49858ea1b49a2f64bee9e0290179e2f829 author Zach Kelling 1785191518 -0700 committer Zach Kelling 1785191518 -0700 feat!: a plugin can own more than one prefix Load took a single prefix, so a service owning several route subtrees silently 404'd every one it could not name. Real services own several: o11y answers both /v1/o11y and /v1/sentry, and extracting it as a plugin dropped /v1/sentry/* entirely — the host started, reported healthy, and served nothing there. That is the worst failure mode this API can have. zip.Load(zip.Plugin{Name: "o11y", Bin: bin}, "/v1/o11y", "/v1/sentry") Prefixes are variadic and last, so one call declares everything the plugin owns rather than a prefix field competing with an argument. Zero prefixes is refused rather than mounting a plugin nowhere. The test plugin now echoes the path it received, because a host that never registered a prefix and a plugin that has no such route are indistinguishable from outside otherwise — both are a 404. The echo is what tells them apart, and the multi-prefix test asserts on it. Found by the o11y extraction, which hit this immediately. Co-authored-by: Hanzo Dev $_' xtree f3322110b0473e261446b2932156789f07abddcf parent 5f283eb7427b2e1175c3710cbc08ee565a3ec6a7 author Zach Kelling 1785191194 -0700 committer Zach Kelling 1785191194 -0700 deps: zap-proto/http v0.3.1 — zero-alloc encode restored v0.3.0 had regressed encode to 1 alloc/op by merging two deliberately-separate header appenders into one generic; escape analysis could no longer keep the closure on the stack. Restored, and 3.2x faster with it. Co-authored-by: Hanzo Dev r^Cx7tree a6f4e85245e2c165b39787363ec5e35a797ee01a parent 4403d199cec8418df49a2aa2790327f031271945 author Zach Kelling 1785183804 -0700 committer Zach Kelling 1785183804 -0700 fix: a plugin must not outlive the host that started it Graceful Shutdown already stops every child. A host that is SIGKILLed, OOM-killed, or crashes never runs its hooks — and a plugin is a separate process, so it kept running, kept holding its unix socket, and kept serving requests for a host that no longer existed. Orphaned plugins on stale sockets are the one way a subprocess plugin is genuinely more dangerous than a linked-in one, so it is worth the platform-specific code. Children are now started with Pdeathsig on Linux: the kernel signals them when their parent dies, whether or not the parent got to say so. Non-Linux builds get a documented no-op — Shutdown still covers every ordinary exit path there. Found by noticing empty /tmp/zip-* directories left behind by hosts that had been killed rather than shut down. Co-authored-by: Hanzo Dev `v xqtree 083bb1539fc4fb9474fc7c97c415811727f81753 parent 2869190b451bc3cf6a414ab9e0edf81810d0bdcd author Zach Kelling 1785181904 -0700 committer Zach Kelling 1785181904 -0700 feat: App.Plugins() — a host reports what it is actually running A fleet view needs one thing this package did not expose: the ability to ask a live process what it loaded, at which version, and whether it is still up. Deployment config answers what was INTENDED; only the process knows what is TRUE — which is exactly the difference that matters mid-rollout, when the two disagree by design. for _, p := range app.Plugins() { // Name, Prefix, Source, Version, Addr, PID, Running, Since, Reloads } Version is the artifact's SHA-256 for a URL-installed plugin — the only version identifier that cannot drift from the bits running, because it IS the bits. Since resets on Reload, so it reports the age of what is running rather than of the mount, and Reloads climbing on one host and not its peers is the signal that a rollout is uneven. An Unloaded plugin stays listed with Running=false, because "deployed but down" and "not deployed" are different states and its routes are still registered answering 503. Remote (Addr) mounts are recorded too. They took an early return and were invisible before; a fleet view that silently omits part of the surface is worse than none. Two fixes found by having the tests exercise this: Shutdown now waits for instances a Reload or Unload is still draining. Those retire asynchronously so the caller is not blocked for the drain window, which let a child outlive the host that spawned it — and since children inherit the host's stdout, the process appeared to hang after main returned. The suite showed it as "Test I/O incomplete 1m0s after exiting"; it now finishes in 22s instead of 74s. Tests no longer hardcode ports. A fixed 19653 meant an unrelated process on the box made TestListen_ZAP fail with 404 rather than a connection error, because the port answers — it is just answering for someone else. That reads as a routing bug and is not one. Co-authored-by: Hanzo Dev RO 1785179684 -0700 committer Zach Kelling 1785179684 -0700 refactor!: drop AdaptNetHTTPFunc — http.HandlerFunc IS an http.Handler Two adapters did one job. http.HandlerFunc already satisfies http.Handler, and the underlying fiber adaptor.HTTPHandlerFunc is literally `return HTTPHandler(h)` — so AdaptNetHTTPFunc was a second name for the same conversion, differing only in that it let a bare func literal skip the explicit http.HandlerFunc() cast. One adapter, one path: adapt a bare func as AdaptNetHTTP(http.HandlerFunc(fn)). AdaptNetHTTP and AdaptNetHTTPMiddleware stay — they front third-party handlers and stdlib middleware that cannot be rewritten natively, and they are genuinely different shapes. adapt_test.go pins the func path so the removed adapter cannot creep back. Co-authored-by: Hanzo Dev Nqxtree 199233f1af494a86c3c696a87c3e582577ac1929 parent 93ca85dda2a7759c50e6d2311bd7d9898ebe874a author Zach Kelling 1785177916 -0700 committer Zach Kelling 1785177916 -0700 feat: install a plugin from its release — host and plugin builds fully decouple A host can now name a release artifact instead of carrying the binary: app.Add(zip.Load("/v1/billing", zip.Plugin{ Name: "billing", URL: "https://github.com/hanzoai/billing/releases/download/v1.2.3/billing-linux-arm64", Sum: "9f2c…", })) This is what makes the two build cycles independent. The host links zip and a transport, relinks in 0.65s, and never compiles a plugin at all; a plugin ships from its own repository on its own cadence. Embedded (Bin), on-disk (Path), installed (URL) and remote (Addr) are the same call and the same type, so which one a deployment uses is configuration rather than code. Sum is REQUIRED with URL. Fetching code over a network and executing it is the one place a plugin host turns into an arbitrary-code-execution vector, so an unverified download is refused rather than trusted. The digest is checked before the file is made executable or given its final name, so a truncated or substituted download is never runnable — the failure mode is a missing plugin, not a wrong one. Sum doubles as the cache key: the cached file IS named by its digest, so a restart costs no download, a rollback to a previously run version is free and offline, and a concurrent host either sees nothing or sees a verified binary. Tests serve a real built binary over httptest and prove all three: it installs and answers, a wrong Sum is refused before execution, and a second load at the same digest does not hit the network. Co-authored-by: Hanzo Dev j$xItree f1598b99d1b663261195add8878e48f540551a9a parent b9e5c40257efaea78ea57a738ce20d859f06d709 author Zach Kelling 1785177566 -0700 committer Zach Kelling 1785177566 -0700 feat(openapi): export OpenAPISpec so a service can render its own contract The spec was reachable only by serving it. A published contract is produced by a build step, not by booting a server and curling it, so the document the routes imply is now directly available — one source of truth for the routes, the docs, and every generated SDK. Co-authored-by: Hanzo Dev IX^xtree 16fb4f2de0adde1c263d4faae49d4f116c2320d2 parent 141d698fdcfe4e79c28332038dc2f39c7d65acc7 author Zach Kelling 1785176139 -0700 committer Zach Kelling 1785176139 -0700 feat(typed): bind URL path params into the typed input A typed op decoded only the request body, so a route could not carry its target in the URL — which is why every service that needed to address one resource spelled it as POST //get with the key in the body. The dialect was a symptom of the framework, not a choice. Path params now bind onto the decoded input by json tag, applied AFTER the body so the URL wins. The URL is what routed the request, so it is the addressing authority, and because the authorizer runs on this same decoded value the target authorized is by construction the target the URL named — a body cannot smuggle a different one past it. Only top-level string fields bind: a path param is a string on the wire, and a nested record is not a path target (an input that nests declares its target explicitly instead of having it guessed out of a sub-struct the caller also controls). Routes with no params are untouched, so no existing op changes. OpenAPI now declares every templated segment, derived from the same route pattern the router matches on, so the spec cannot describe a parameter the route lacks. MCP passes no path params: a tools/call carries every argument in its JSON arguments object, so the body is the whole input. Co-authored-by: Hanzo Dev s"Wxutree e8031067de07b1a6c7cbb83d44c904499dfa2296 parent 48c62d53c8bbf7a15993cf9cdd0022178f351673 author Zach Kelling 1785175780 -0700 committer Zach Kelling 1785175780 -0700 fix: Group carries the prefix, and a plugin need not extract into RAM Two things, both found by real consumers breaking. Fronting a net/http handler is Group's job, not Mount's. Mount delegates a prefix to a REMOTE address over a transport, so it takes a string; a local handler is composed, not delegated. The taught form is now: app.Group("/legacy").All("/*", zip.AdaptNetHTTP(h)) and for a net/http middleware, which IS middleware: app.Group("/legacy").Use(zip.AdaptNetHTTPMiddleware(mw)) Both keep the wildcard an ordinary route, so a route registered on the group afterwards still beats it for its exact path. Repurposing Mount's old (prefix, http.Handler) signature broke hanzoai/kms and lux-private/sovereign; this is the form both were fixed to. Plugin.Dir: Load extracted an embedded binary via os.MkdirTemp("") — the system temp dir, which on many hosts is a tmpfs, i.e. RAM. A plugin binary is tens to hundreds of megabytes, so that spends real memory and fails outright when the tmpfs fills. Found the hard way: the reload test died with "no space left on device" while other work shared /tmp. Callers can now put it on disk. Co-authored-by: Hanzo Dev #x=tree 198ebfa92204da86cb32f66e1e9c41bfad8a4e1a parent c1008a142f9cd4f3cd00f8422068881ac19b82dd author Zach Kelling 1785171022 -0700 committer Zach Kelling 1785171022 -0700 feat!: zap-proto/http v0.3.0 — headers on the wire are pairs, not JSON Picks up the header encoding change: the JSON map inside the ZAP frame is gone, replaced by length-prefixed name/value pairs, and decode is 0 allocs/op. BREAKING at the wire: a v1.10.0 process cannot talk to a v1.9.x one. Services must be rolled together. Co-authored-by: Hanzo Dev -.xtree c06d07eb3a01495a3fa02fd1d2a92661a504c999 parent a8f0bbf998459b49373ba6d2a5c594878c53fccf author Zach Kelling 1785170630 -0700 committer Zach Kelling 1785170630 -0700 docs: the impostor checkouts are retired ~/work/hanzo/zap-zip is deleted — it was a stale duplicate clone of this module and held nothing origin did not already have, so a clone restores it. ~/work/hanzo/zip now carries a DEPRECATED.md pointing here. Co-authored-by: Hanzo Dev +x@tree 1aab56ad8cff4114d14883e6c0159b2f238bc2ad parent 1fe095e64e72adb0ede50325278580987914059c author Zach Kelling 1785170193 -0700 committer Zach Kelling 1785170193 -0700 docs: LLM.md — the four verbs, the reload invariants, the impostor checkouts zip is now the framework every service in the fleet serves on, and it had no agent-facing doc. Records the things that are expensive to rediscover: which checkout is canonical (two impostors exist), that transport is a value in one registry with both directions, the three reload invariants that keep repeated swaps flat in memory, and why -buildmode=plugin is not an option here. Co-authored-by: Hanzo Dev 2(xytree 31ebd42af53ea08b08a479385dc5f6287ee3d1c8 parent 5ab532a6711eb6ae12e07dd6d330d9a592904030 author Zach Kelling 1785170146 -0700 committer Zach Kelling 1785170146 -0700 docs(examples): runnable plugin — separate binary, loaded over ZAP on a socket Two binaries built independently: the plugin is an ordinary zip app whose only plugin-specific line is zip.Addr, and the host composes it beside a linked-in Service with the same verb while never importing its code. Verified end to end — the host answers /health itself and /v1/billing/invoices from the child process. Co-authored-by: Hanzo Dev /Ș(xwtree fd46eeae83f4e62128df0df26c285953c34e881f parent b426c2b2a8592c6f4fb95117019a98d32f8fe69a author Zach Kelling 1785170029 -0700 committer Zach Kelling 1785170029 -0700 docs: plugins, Service/Add, unix addresses; drop other frameworks' names The README documented Listen but predated Service, Add, Load, Reload and Mount, and still described RegisterTransport's old func argument. Also drops the borrowed vocabulary — chi/gin/beego/Sinatra/Express were being used to explain our own API, which reads as if they were dependencies. Fiber stays, because it actually is one. Co-authored-by: Hanzo Dev Aٲx!tree 5866a319fce069479718ed4d8acec8ad926cd277 parent 748f8b41d1352d43cc62cbd313a4b2215018cf8d author Zach Kelling 1785168962 -0700 committer Zach Kelling 1785168962 -0700 feat: plugins — a service builds as its own binary and loads at run time A plugin is an ordinary zip app. It needs no SDK and no schema: it serves routes, and a host mounts them over ZAP on a unix socket. //go:embed bin/billing var billingBin []byte app.Add( billing.New(deps), // linked in zip.Load("/v1/billing", zip.Plugin{Name: "billing", // its own binary Bin: billingBin}), zip.Load("/v1/ml", zip.Plugin{Name: "ml", // already running Addr: os.Getenv("ML_ADDR")}), ) One type covers all three, so where a service runs is a deployment decision rather than a code change. Service is func(*App) error — a constructor taking dependencies and returning one is the same thing curried, which is what lets a composition root see only Service. The host links zip and a transport, never a plugin's dependency graph. Plugins build in parallel, one changing rebuilds only itself, and go:embed keeps the deployment a single artifact. Reload swaps a running plugin for a new build without dropping a request. This is why a plugin is a process: Go can map a shared object in but never unmap one, so an in-process plugin's code, globals and goroutines are unreclaimable for the life of the host. A child releases every byte when it exits. Three invariants keep repeated reloads flat in memory: - routes register ONCE at Load and resolve their target per request, so the route table never grows - the replacement must be listening before any request moves to it, so a bad build cannot take the route down - the old process is killed, reaped exactly once, its pooled connections closed and its directory removed Unload leaves the routes answering 503 rather than vanishing, so load/unload cycles are flat too and a Reload restores the same paths. Tests build two genuinely different binaries and prove which one answered across four swaps, a failed swap, and an unload/restore. Race detector clean. Co-authored-by: Hanzo Dev )Mx%tree 13cecb7e5724a3ca9e02d3f1610e42f2cfcbb190 parent 5f673aab59fc59c3182868820e8ffbcc5dec8bad author Zach Kelling 1785168476 -0700 committer Zach Kelling 1785168476 -0700 feat(transport): unix sockets on the zap scheme — the address names the plumbing A colocated plugin wants a socket path, not a port: nothing to allocate, nothing to collide, and filesystem permissions are the ACL. That needed no new scheme. The scheme names the PROTOCOL (zap); the address already says where it is spoken, so a leading "/" (or "./", or "@" for a Linux abstract socket) is a unix socket and anything else is host:port. app.Listen("/run/hanzo/billing.sock") // in the plugin app.Mount("/v1/billing", "/run/hanzo/billing.sock") // in the host A "zapuds" scheme was the obvious move and the wrong one: it is a compound name for the same wire, and it would have split one protocol across two registry entries that then drift. Reading the network off the address keeps it at one. Both directions gained unix from a single registry change, which is the point of Serve and Dial living in one Transport value. Requires zap-proto/http v0.2.2 (network as a value). Co-authored-by: Hanzo Dev d]x"tree 58476aebee929f46909069924537bbb3d6494091 parent b1e577cd941e5f91469caf7888ad43e09213f887 author Zach Kelling 1785167940 -0700 committer Zach Kelling 1785167940 -0700 feat(transport): Mount — delegate a prefix to a service over any scheme Listen serves here; Mount delegates there. Both read the transport off the address scheme through one registry, so a service running as its own binary is composed by address alone: app.Mount("/v1/billing", "billing.hanzo.svc:9653") // ZAP app.Mount("/v1/legacy", "http://legacy.internal:8080") // HTTP A transport is now one value with both directions (Serve + Dial) rather than a serve-only func, because a wire is one concept and two registries drift. *zaphttp.Transport and *fasthttp.HostClient already satisfy Client, so each built-in scheme gained its Dial as a one-liner. The mount is an ordinary wildcard route, so most-specific-wins precedence still holds — a route registered after a mount still wins its exact path. Nothing is re-encoded across the hop: the inbound fasthttp request object is handed to the client and the reply written straight back. This is what lets a service ship as its own binary. The mounting binary links zip and a transport, never the mounted service's dependency graph, so its link time does not grow when that service does. Moving a service between Mount and a linked-in route tree is a deployment decision, not a code change. Co-authored-by: Hanzo Dev $I.xtree be1a032d98d4e57872614efd20451b5664e06dbb parent 645f0f87883f92ea5700fc636b8ab9d04f8febe2 author Zach Kelling 1784140934 -0700 committer Zach Kelling 1784140934 -0700 zip: op-invoke Authorizer hook — authorize decoded typed input for REST and MCP Add App.Authorize(fn) installing an Authorizer that runs at the op-invoke seam, after decode+validate and before the handler, on the *In the handler will bind — the one point REST and MCP both funnel through, so the value authorized cannot diverge from the value executed. Add App.Prepare() to install the deferred /mcp and /openapi routes without a listener, so a test can drive them via Fiber().Test. Additive: a nil authorizer leaves invoke behavior unchanged. UØx7tree 859bf6e457e3b074b9a9d6109a55ecffdd56a028 parent c6658f77e5aae04ebccd4156890fefcc709d2b0a author Zach Kelling 1784097394 -0700 committer Zach Kelling 1784097394 -0700 ci: canonical caller restored; bisect artifacts removed Root cause of the startup failures: the called workflow's permissions: packages: write exceeds zap-proto's org default workflow permissions (read) — org default flipped to write, matching hanzoai. 4 x,tree 45313cd47845afa2fa3e5bc60f72e2ea5ff06283 parent 23d0f9e8c146cdc70473d8e5041bf309be789215 author Zach Kelling 1784097341 -0700 committer Zach Kelling 1784097341 -0700 ci: x5/6/7 <Μ x#tree 77b1993991d47db68f19c5034a72cc64a66f8285 parent 81a09e6f7980979d70381d89ecbdc9ad0541df2c author Zach Kelling 1784097182 -0700 committer Zach Kelling 1784097182 -0700 ci: xorg3/4 callers @\ x%tree d4b1f0b4938ae92da7226c2159fddc00f9165e6b parent 79a5be0ae09c6e19fb4d8320c341b03d7e392816 author Zach Kelling 1784097137 -0700 committer Zach Kelling 1784097137 -0700 ci: xorg → min2 @xtree 0830395d8e44a669bdcd334d579a73d0442fd57d parent 6332133be230b6dbc01df17a561b7177d177fb05 author Zach Kelling 1784097091 -0700 committer Zach Kelling 1784097091 -0700 ci: cross-org min bisect B[xtree debadca46da82f5d3abcdfc809f98a1a314f63f2 parent e582cceacc945f97c65dfd7e15e42da15e477178 author Zach Kelling 1784097054 -0700 committer Zach Kelling 1784097054 -0700 ci: bisect — drop secrets: inherit Jxtree 216b299e4acf08a3b335d77c2a89a59a5dcfed1e parent e30a9f7794acd37f0173e7e5f6df195a175544bc author Zach Kelling 1784097003 -0700 committer Zach Kelling 1784097003 -0700 ci: minimal same-repo reusable bisect UCHxtree 03d08a64351bc4cc4c025d1ac8f7ac5cdc99e594 parent 86d55c2e98ec974453fd0e1bf7e1da496d66c6cb author Zach Kelling 1784096962 -0700 committer Zach Kelling 1784096962 -0700 ci: discriminate — no with:, @main .Hxtree b642dca64aaf2648cacf450a0c80c3e2441ed00a parent f9aa701729a9df06ad4893acb5ad405598ab20f1 author Zach Kelling 1784096884 -0700 committer Zach Kelling 1784096884 -0700 ci: pin reusable by SHA (v1-tag resolution debug) ɭL x.tree 76f19fd2f2e5f6e5246faac087442f91f8355d8a parent ad85aa10b956a5778441cf09b0c13325b2c5552e author Zach Kelling 1784096317 -0700 committer Zach Kelling 1784096317 -0700 ci probe "0=xtree 859bf6e457e3b074b9a9d6109a55ecffdd56a028 parent cd81560456dbfc449b2f2343494db83b092dd4dc author Zach Kelling 1784096182 -0700 committer Zach Kelling 1784096182 -0700 ci: workflow_dispatch lever R-E4x}tree e6742c5285f420040dcb741f15c2e40cfe4b88b5 parent ef076345d608125a52dc54e9a913105a8444023b author Zach Kelling 1784096044 -0700 committer Zach Kelling 1784096044 -0700 ci: canonical hanzo.yml + hanzoai/ci caller on the zap-proto arc pool zip had no CI at all. Tests now run on our own runners (zap-proto-build-linux-amd64) — never GitHub-hosted. vyxtree dab42002951b3723a0d798ada6fc8274d0b9d49f parent f041d455b1c1edb4926852ad08b55f99ba1e55c9 author Zach Kelling 1784093647 -0700 committer Zach Kelling 1784093647 -0700 router: empty leaf = group root (normPath) — the gin/express idiom, pinned by test |Yt$xLtree f09fcf4f80a45e70f767238b1a0774f56c208356 parent ad2a308304982628ed0f411d2f49076f519cc8ca author Zach Kelling 1784093443 -0700 committer Zach Kelling 1784093443 -0700 router: fix route-chain inversion — fiber executes handlers in ARGUMENT order splitChain was flipping (middleware…, handler-last) to handler-first on the assumption fiber runs trailing args before the named handler; fiber chains in given order, so the flip put the TERMINAL before every gate. Chain now passes through verbatim + two regression tests pin order and the no-Next abort. ƿx#tree d1e435126c9b72759eadf332fb0e60798da51f50 parent c3606be66cf1c5ca91970954e7dd149da465da7e parent f0f2be094dabb3f0a04c7189bede9427412a8cd5 author Zach Kelling 1784091376 -0700 committer Zach Kelling 1784091376 -0700 Merge remote-tracking branch 'origin/main' Xx tree b50a84dcc1b0ec173f2ead34062bd84d0ef12d3c parent 077a7b4552cd5ab5bf7e2c3a02f45c32a22718b8 author Zach Kelling 1784091368 -0700 committer Zach Kelling 1784091368 -0700 ctx: SetContext — one request context, set once at the boundary SxWtree a83b4cf6ed76d8cdf9200e79f0f5d5b309ebb739 parent 077a7b4552cd5ab5bf7e2c3a02f45c32a22718b8 parent 556a947bc6fb5d49b03f55334f00d8b0c069b671 author Zach Kelling 1784091134 -0700 committer Zach Kelling 1784091134 -0700 Merge fix/transport-server-header: pre-routing responses carry ServerHeader (no fasthttp leak) [kHxttree a83b4cf6ed76d8cdf9200e79f0f5d5b309ebb739 parent 077a7b4552cd5ab5bf7e2c3a02f45c32a22718b8 author Zach Kelling 1784091060 -0700 committer Zach Kelling 1784091131 -0700 fix(transport): pre-routing errors carry ServerHeader, never 'fasthttp' The HTTP transport built a bare fasthttp.Server and applyConfig never set its Name, so fasthttp stamped its default 'Server: fasthttp' on the responses it writes BEFORE the fiber handler runs — 431 (header overflow), 400 (parse error), timeouts. Those bytes are unreachable by ProductionHeaders (or any middleware), so the framework name leaked on exactly the malformed-request path an attacker probes, invisible to the in-memory (Fiber().Test) suite. applyConfig now propagates ServerHeader onto the transport server (Name, or NoDefaultServerHeader when '-'), so pre-routing responses carry the same value as handled ones. Proven on a REAL socket: a 9 KiB-header 431 now reads Server: , never fasthttp/zip; '-' emits none. Also corrects the Ctx.Host() doc to state X-Forwarded-Host is ignored (zip has no TrustProxy), so the Server brand cannot be spoofed from a request header. уEx#tree 6f837638c9eeeebf5483c6cbd797b4490edf903a parent 8ad31c6ffa358c96d3ca00301bd1b5431838f153 parent 3378e4506fa37ee281d993070cf30c2836392a0c author Zach Kelling 1784090353 -0700 committer Zach Kelling 1784090353 -0700 Merge remote-tracking branch 'origin/main' vVxtree 2ecf0535cd24e104a773eaa504fcd1f0c07b2563 parent 35f6d857ad4b5bd2520a74ec0c849625dba47fe8 author Zach Kelling 1784090336 -0700 committer Zach Kelling 1784090336 -0700 static: WithFallback — SPA deep-link shell fallback, fail-closed traversal unchanged Zxetree d3bd355bad1ada4625810fa01287241d5c19eba9 parent 35f6d857ad4b5bd2520a74ec0c849625dba47fe8 parent 70e56dbc81634ce6436ba889a2bc384e0cf89222 author Zach Kelling 1784087548 -0700 committer Zach Kelling 1784087548 -0700 Merge feat/production-headers: ProductionHeaders posture (brand-by-host Server, X-Api-Version, HSTS/nosniff) ̊o?x tree d3bd355bad1ada4625810fa01287241d5c19eba9 parent 35f6d857ad4b5bd2520a74ec0c849625dba47fe8 author Zach Kelling 1784087537 -0700 committer Zach Kelling 1784087537 -0700 feat(middleware): ProductionHeaders — brand-by-host Server, X-Api-Version, HSTS/nosniff Stamp the production response-header posture on every response (success, error, and 404) from one home in the framework: - Server: white-label brand resolved from the request Host via an injected Brand func(host) string, so a lux/zoo caller is never served hanzo and no response leaks the framework name (fasthttp/fiber/zip). Neutral fallback for an unknown Host; never a hardcoded single brand. - X-Api-Version: the API contract/build version under a brand-neutral key. - X-Content-Type-Options: nosniff always; Strict-Transport-Security when HSTS. X-Request-Id stays owned by RequestID(); the two compose. Never emits X-Powered-By or any framework/version string. Adds Ctx.Host() for the brand-by-host lookup.  1784075447 -0700 committer Zach Kelling 1784075447 -0700 testctx: App.TestCtx — detached Ctx over a synthetic request for handler-unit tests {[ax-tree be52ee54acbed548bfec6242e7d1ac9a04db2d55 parent 971bc93b7dc705600c8efe782aa3d4503904a436 author Zach Kelling 1784075270 -0700 committer Zach Kelling 1784075270 -0700 router: one chain, gin/express order — variadic (middleware..., handler-last) on every route method; Ctx.Redirect splitChain flips to fiber's handler-first convention in exactly one place; zero-handler registration panics at boot. With() wraps only the terminal. ǔUxTtree 7f38778bb4f8bb0349fb4c435fe10e89405db764 parent d6ba52c97a14003b6c16fbde3abc3b5fbf7ec9d0 author Zach Kelling 1783822459 -0700 committer GitHub 1783822459 -0700 zip: delete deprecated + redundant surface — one way to do everything (#8) Breaking (minor, forwards-only per house rule): remove redundant exported symbols so each operation has one and only one path. - App.Mount(prefix, http.Handler) [was Deprecated] → app.All(prefix+"/*", zip.AdaptNetHTTP(h)). Mount WAS literally that composition. - Router.Route(prefix, func(Router)) → app.Group(prefix), register on the returned Router. Route was Group + callback sugar; zero consumers. - App.ModuleFn(method,path,fn,rt,dir) folded into App.Module — Module is the one HIP-0105 mount verb (fn is derived from the path); no external caller. - App.UseFiber(fiber.Handler...) → Use(Handler)/With; unused fiber-middleware escape hatch. Kept (live external consumers): AdaptNetHTTP, AdaptNetHTTPFunc (cloud websearch), AdaptNetHTTPMiddleware (gateway zipFromGin — the net/http middleware bridge). Docs (MIGRATION.md, HANZO_CHANGES.md) and the deprecated-alias test updated. Core surface (Use/With/Group/Get..All/typed Get[In,Out]/Static/AdaptNetHTTP/ OnShutdown/Listen/Shutdown) untouched. Suggested tag: v1.6.0. Co-authored-by: Hanzo Dev ѫJxQtree bba78f55529200dd8d6ee6b7d5d677cd66ed676e parent a0825689f3e4afe42584726e27e8770e8058ba4d author Zach Kelling 1783771613 -0700 committer GitHub 1783771613 -0700 bench: framework-tax suite + BENCHMARKS.md (#7) Measure what zip costs on top of raw fiber, against hand-written baselines. - bench_test.go: - Benchmark_ZipTax: zip.App vs raw fiber.App with byte-equivalent handlers, isolating the per-request wrapper tax (the &Ctx materialised per request). - Benchmark_TypedRoute: generic Post[In,Out] vs an idiomatic hand-written zip handler doing the same JSON decode/validate/encode. - BENCHMARKS.md: methodology (M1 Max, go1.26.4, -benchtime=1s -count=6, benchstat medians) and the real numbers, cross-referencing fiber's routing benchmarks. Findings: zip's per-request tax is a constant ~24ns + one 48-byte allocation (<1% of real handler cost); the generic typed API is FREE — Post[In,Out] runs on par with (marginally leaner than) a hand-written handler (3.51us/27 allocs vs 3.58us/28 allocs), because it decodes straight off c.Body() rather than through fiber's content-type bind machinery. Co-authored-by: Hanzo Dev j @`x tree bdc6dc64528172f4e27ce0fe59ac3ba550302df3 parent b6fafc3a4f4410a1b0466cf14d5e7586f556e663 author Zach Kelling 1783770365 -0700 committer GitHub 1783770365 -0700 zip: Static file handler + composable Middleware (With/Chain) — additive (#6) Two additive capabilities on the zip surface, neither touching the existing Use(Handler...) c.Next model. Static(fs.FS, ...StaticOption) — leaf file handler for a wildcard route. Serves the "*" subpath from any fs.FS (embed.FS or os.DirFS); path.Clean + fs.ValidPath reject traversal fail-closed (404); a missing file calls c.Next() so a later route or SPA catch-all wins, never a 500. Sets Content-Type/Length/Last-Modified, honours HEAD and If-Modified-Since (304). WithIndex / WithStripPrefix options. fasthttp owns the streamed file's close. Middleware = func(Handler) Handler, Chain(mw...), and App.With(mw...) — chi's per-route wrapping idiom. With wraps the leaf at registration (not via c.Next), Chain composes left-to-right. Coexists with Use: Use = global/prefix stack (declaration order), With/Chain = per-route explicit wrapping. Tests: serves file (content/type/len) over embed.FS AND os.DirFS, HEAD, traversal blocked, missing->Next->catch-all, specificity beats the wildcard, index, strip-prefix, 304; Chain/With execution order + the cloud rateLimit+CSRF order and short-circuit proof. Suite green except the two pre-existing macOS-host failures (TestListen_DualTransport, TestMCP_FreeToolSurface). Co-authored-by: Hanzo Dev /VHxytree 040694ed99f6ffbd565a896f1a15edc76af466ea parent 509a645e32d4e9ad1565215e24b77c75e31fe7da author Zach Kelling 1783726157 -0700 committer GitHub 1783726157 -0700 zip: dissolve App.Mount into All+AdaptNetHTTP (deprecate; one composition path) (#5) App.Mount(prefix, h) has always been exactly a.All(prefix+"/*", AdaptNetHTTP(h)) -- two primitives that already exist. Mark it Deprecated and point callers at the explicit form so there is ONE way to put a route on the app. Mount stays as a behaviour-identical alias (cloud still calls it); nothing breaks. The mounted subtree is an ordinary wildcard route, so it participates in the zap-proto/fiber fork's most-specific-wins precedence: a static route registered AFTER the mount still beats it. New mount_test.go pins this as the load-bearing proof, plus body/path-intact and the deprecated-alias regression. Docs/examples (README, migrate-from-chi, migrate-from-beego) updated to the canonical app.All(prefix+"/*", zip.AdaptNetHTTP(h)) form; the buggy AdaptNetHTTP doc example (which passed a zip.Handler to Mount) is fixed. Co-authored-by: Hanzo Dev Jœxtree 97a8c551e7c0902423b90d20c8dbe10305e34b51 parent ee9f707822024d231899b962d21a390e5d154378 author Zach Kelling 1783725202 -0700 committer GitHub 1783725202 -0700 zip: OnShutdown — LIFO lifecycle hooks for express-style composition (#4) Add the one teardown primitive zip was missing: func (a *App) OnShutdown(fn func(context.Context) error) Subsystems register their own cleanup at mount time; reverse-mount teardown falls out for free. This is what consumers (hanzoai/cloud) need to flatten a MountSpec{Shutdown} registry into plain pkg.Mount(app, cfg) calls. Semantics: - Order: hooks run LAST — after listeners stop accepting and after in-flight requests drain (fiber) — in LIFO order. Draining first means a subsystem's teardown never races the requests still using it; LIFO gives reverse-mount teardown of dependencies. - Errors: every hook runs even if an earlier one fails; all hook errors (plus the drain error) are aggregated via errors.Join. - Context: ShutdownWithContext passes its ctx (values + deadline) to hooks; plain Shutdown uses context.Background() (process ending). - Idempotent: a shared once-guard makes the whole Shutdown a no-op on the second call; hooks run at most once, across both entry points. - Post-shutdown registration is a no-op: the hook is dropped and a warning logged (no panic). Keeps OnShutdown's meaning constant — register-for-later — instead of silently changing to run-now. - Registration is mutex-guarded; a nil hook is ignored. Decomplect: fold the internal `closers` stopgap onto OnShutdown. module.go's own comment described appendCloser as a poor-man's graceful-shutdown hook list "because fiber doesn't expose one" — which is exactly this primitive. Module() now registers mod.Close via OnShutdown, so there is ONE teardown mechanism. A module's Close now runs AFTER in-flight requests drain (it previously ran before), so a module stays live for any request still executing it — a correctness improvement. closers.go is deleted. Tests (shutdown_test.go): LIFO order, errors.Join aggregation, idempotent second Shutdown, ShutdownWithContext ctx propagation, post-shutdown drop, nil-hook, and concurrent registration under -race. Co-authored-by: Hanzo Dev _,)xhtree f802352bc2a176521ddedde922f0679c8da27ac5 parent 5e4ca54293c93e91c13f58f85c4cc117fa1d52bf author Zach Kelling 1783718408 -0700 committer GitHub 1783718408 -0700 docs(readme): vendor-neutral rewrite — correct module path and license (#3) Rewrite the README for the public zap-proto/zip surface: use the correct module path github.com/zap-proto/zip (was github.com/hanzoai/zip), correct the stated license to MIT (matches LICENSE; the README previously said Apache-2.0), drop vendor-specific framing, and condense to the current feature set with a link to zap-proto.dev/docs/zip. Co-authored-by: Hanzo Dev Fݟ7xtree b778021ea864f6f8f52de1bfebb4de628794b018 parent 797b00cf56f54b544fc8e7524ea9139b862cedd7 author Zach Kelling 1783715927 -0700 committer GitHub 1783715927 -0700 zip: ride zap-proto/fiber v3.2.1 — specificity route precedence, natively (#2) Swap the engine gofiber/fiber/v3 -> zap-proto/fiber/v3 (our fork: gofiber v3.2.0 + ServeMux-1.22 route precedence fixed IN the router). Most-specific pattern wins regardless of registration order, ambiguous equal-specificity overlaps panic at registration, use/mount stay declaration-ordered barriers. No zip-side buffering/finalize — the framework surface is unchanged; six specificity tests pin the contract at the zip surface (engine-agnostic). Kills the consumer order-int idiom (subsystem order ints existed only so specific routes registered before wildcards). Co-authored-by: Hanzo Dev ֕6UKxFtree f541981650ae2ecdde1a99f471d29110de3b4ed0 parent 5e90c2aa7b1d8b0e46b107c529580762027e7ccf author Zach Kelling 1783073390 -0700 committer Zach Kelling 1783073390 -0700 fix(transport): HTTP transport must honor Config buffer knobs (fixes 431 at 4 KiB) zip's built-in HTTP transport constructed a bare fasthttp.Server{Handler: h} and never propagated the App's Config — so zip.Config.ReadBufferSize was silently dropped at the wire. fasthttp then capped request headers at its 4 KiB default and returned 431 (Request Header Fields Too Large) once a browser's multi-domain SSO cookies crossed ~4 KiB. Only fiber's own listener (app.Fiber().Listener) honored the config; app.Listen("http://...") did not. Push the App's per-conn tuning (ReadBufferSize / WriteBufferSize / Concurrency) onto the transport's fasthttp.Server after construction via a tunableServer seam. Only non-zero knobs are applied, so unset fields keep fasthttp defaults (no behavior change for callers that don't set them) and internal high- concurrency services keep the 4 KiB budget. Test TestHTTPTransport_ReadBufferSize_Raises431Ceiling: default 431s a 9 KiB header; ReadBufferSize:32768 serves it 200. 7xvtree a157a70e35ddaf364d4ef1242355e8b66f7abfb0 parent fc15f4d1d5c9f3bf51030ae617bb9f25d5268b09 author Zach Kelling 1782978337 -0700 committer Zach Kelling 1782978337 -0700 feat: streaming over ZAP through the framework (zap-proto/http v0.2.0) Bump zap-proto/http v0.1.0 -> v0.2.0 (streamed responses). Now ANY zip route that uses c.SendStreamWriter (SSE) pushes each flush over ListenZAP as a live stream — real server→client push over ZAP, wired through the framework with zero per-handler transport code. This makes bidirectional/streaming (MCP notifications, progress, chunked bodies) available to every zip app for free. Verified: TestListenZAP_Streams flushes 3 SSE events one-at-a-time through a zip route and the client receives each BEFORE the next is released (buffering would time out). All transport + MCP tests pass; build/vet/gofmt clean. M.zwxztree a433c63936d793c8b81affeb4b252f49a81d304d parent c581e0af7b892fc8a6ea28e255aabddb8433097a author Zach Kelling 1782974562 -0700 committer Zach Kelling 1782974562 -0700 feat: one-verb Listen (transport as value) + free MCP third projection Decomplected the transport layer and added a free MCP tool surface — both from the principle 'values, not places; one and only one way'. TRANSPORT — one verb, transport is a VALUE (the address scheme), not a method: app.Listen(":9653") // ZAP (bare addr = the primary) app.Listen(":9653", "http://:8080") // ZAP + HTTP in one call app.Listen("quic://:443") // any RegisterTransport'd protocol Mirrors net.Listen(network, addr). Removed ListenHTTP/ListenZAP/Serve — one Listen. An open transport registry (RegisterTransport) means any future termination/ serialization proto slots in with ZERO API change. ZAP is DefaultScheme. FREE MCP — every typed handler (Get/Post[In,Out]) auto-projects to a Model Context Protocol tool at /mcp (JSON-RPC 2.0: initialize/tools/list/tools/call). The SAME op registry feeds REST routes, the OpenAPI doc, AND the MCP tools — one value (the op), three projections; tools/call runs the exact same fn as the REST route (op.invoke, the transport-agnostic handler core). Because /mcp is an ordinary route, it's served over every transport → ZAP-native MCP for free. On by default; Config.MCP.Disabled to suppress. Supersedes the same-session v1.0.0 transitional ListenZAP/HTTP/Serve API — forward only, no compat shims (per repo policy: break within v1, never lazily bump major). Verified: build/vet/gofmt clean; TestListen_ZAP + TestListen_DualTransport serve a real request over ZAP (and both transports from one Listen); TestMCP_FreeToolSurface drives initialize/tools/list/tools/call end-to-end (schemaOf projection + same-fn call + validation→isError). ҉KxCtree 60becbe26818872fe5b6e518041fa9bcd3b44d10 parent 4bf404bfc620ceb04709183a7786d687a71965ab author Zach Kelling 1782972515 -0700 committer Zach Kelling 1782972515 -0700 feat: zip canonical home — the ZAP-native web framework, consolidated zip is shared protocol infra (the fiber-over-ZAP web framework used by every Lux/Hanzo/Zoo Go binary — nodes, gateway, cloud, iam, kms, o11y, ai, …), so its home is the ZAP protocol family (zap-proto/{go,http,zapd,zip}), NOT any one org's brand namespace. This consolidates the rich framework (formerly hanzoai/zip v0.5.0 — Ctx/Handler/Errorf/Err*/HTTPError, typed handlers, middleware, runtime/extension loading, openapi, validate, zaprpc) with the real ZAP transport (ListenZAP/ ListenHTTP/Serve over zap-proto/http) into ONE canonical module. Module path github.com/hanzoai/zip -> github.com/zap-proto/zip. Code identical to hanzoai/zip v0.5.0; promoted to v1.0.0 as the stable shared-infra framework. The prior hanzoai/zip lineage is retired — one home, one import path, one way. Verified: go build/vet/test ./... green; the ZAP round-trip integration test serves /v1/health over the real ZAP transport (200 + handler JSON). X.Μ'x|tree 18c7ad70c394244b43f473aa2d33ca63ee5bc321 author Zach Kelling 1782931963 -0700 committer Zach Kelling 1782931963 -0700 feat: zap-proto/zip — ZAP-native web framework (gofiber v3) One framework for every Go binary (all nodes, gateway, cloud services): gofiber v3 routing + middleware served over ZAP as the primary transport, with plain HTTP as an optional extra. Runtime dynamic mounts for node chain handlers registered after Listen; the single net/http boundary is adapted via fasthttpadaptor. Because the transport is ZAP, ZAP + MCP ride on top for free. Co-authored-by: Hanzo Dev yxw<_pM3ICYʦBedJ.wÖdGJiIe4*(H]y^\PyڎAh<퟈;O`yt󿷪O*+OV^#+(҅,T6, D|DDg560ղ2C~K\!~{Ι͕h&Z:gkjhf<@9L.n^F=wYQOV&:$լZCm]3k]Rk߿$]|C J  nx?TqUacJ䗱s:%,| ;~YjZ8.3s1/|7|9|b*#*Y7:B򍡯DsvfR0x78\A~:XMjhrQ%`p"N_[ y9~7)Q;BVFg4)z8]ҪsejAPp^I\HL.`ÊҊGkvN_`8  ƶvO]?Ż*ܪlkѩJ&CY{A$e5c垔u7O^4=Kfu Ge 3Ep" l0J~r6Aa3%x .+|ŠHn,tE(~d_ٌf/WGB{[,7թGm.e'F=ݩ8\n;2B!a\ sl8 /(ݛ!ٮ p*ŝ@] QqX*]~ћ +u`s>RO\)lμ.2֜]Qx;/342zfGMr < @:c ۮ.z% o2+T!B5,J88T lo/2,^{v wȻ[_Y:O X29 ?55Hom.54C ${}0Ugcyjr >-âkO8&CI><v<~cz@b1x2ǖ>HeÀ}OfC@E1aoE =) 9̚@q_o"Fǻ]_* Lطo,V;Ͷ5g͙$qNvl=% Xw8# GUYQ>q}w7NƸAC4$ԳYL~V˖Mk1 "*g Ki;w=7G @5{8DzSbǖ3ɱ >W~6U!mr %s;S/QvdLykfE?E4V"cDbY-/{6FFR(o ĝ\e6{VLAaOi@ @{1-D @q8h`X}ojeg` @o7`i1&jMg0+p]I~)aTV L,@I=F:-lt ` }K/7A}^r>!V{[rc5}ݹV=S<^v)2{j:LA ' )Ӄiӱ*%L2+0 HZy24_3S$ j;/P=~{(V>A8Q "5n -/s~H}20r,V`쀄7$̮up)5WJB`4vBC z6km=௔qC7<+ЙT j_HҼi_YD-+ටӋEYY}II:) U`p<ه1gp/o)vC0ˌ(|9'C_Zύd~aX*J_mw,wf7ps#H뒷B9 m{Jn;:.wMAB'su( p+UHaY9ŝ7ԕŶ~3D8a s@rF܉MVTBQ'XkrW]=Vvh U=x=`\},²×+ہjC&`׫vӡJN9 .k)~V3gxl$s܊wڴ5p?LUFuݴ0{a&gbRݮ*48uڠCq!՝!/UP ^uyӝ4eaOJCAPB.i?ҷ3&#SP(?E,p78Kʒk]?u|@Pzcf|X. B^u^e&[,y?%R8 l& |0Kpq)S= \mtA|rLI{ѥ !# Mw/]w86ɾcACENFcy%2xa8^|ھfu%hp%{}96[Y TY{jxIed%^e;kQpdr6 cOLrxlb>L!P d}Vی#m UĖPR<2 P|x(_u\s|!/$'Ts}Б뷎3üP9h8|Uۤv~d~q& ^X"^n8X HBa{aq]eN[{9PB㩽dFyڷh9CRO#} FXlhRwP+ 8LE OW6]<2A縅n d|AIBӟ(7Z`v!WA _W噬@< 'OĘγ*> =DT EO(&L3MrEv"V ~U}G(*Xg`>UJ7o$@cB]N1[1k5og\caJGcB[P WcSIpQwiIV-Nqg  &=}s9op]`V$Q+?|$K" K@0%s. u?s{ֵ̱'?] H\(ه7nyr/NOE|,PaT7TPe3Lȫ7f2r" w4I&MP>^4ցA~O;^̳ҟ*"ۃ|-/RзT;MfYF >xVpPIW, Bp$ZXfB۪x=88#O@hY7QB/':8ڵl;yIf[-&%hYVMWXwM (FGVXP/ Kx%NXF>]J-$-Mᖯ;Noyv^\~UӛWŐ?H+=nS'NQFNho=4V){Ϭ6=vs<*ĕ3C'Ehb5,XPayҴJ|W奈BޮyS@qN+)+ "$dHqxBrhW[0*F {5X:QuM݃-^[Laqܺr.{8hh;*Wg)PEk S#[-v2;S'e_3#[,l%%+=Ddr[4~ŀ"?a`H]&^۞? 2|j;](0Pݽ^\:wSư@<CW1XbBЅлQofmfDbH0/zD=ԲkC_G5!IܞS5b^iU՝wO4@=Oبug߯^L\ p aLK0 \)-[kB+EgUCo1.+@Jh6Ä{+Wmy`g>xA)& (tj%?]i~RһrP,GU J/NgG!sR‹mDAR%Ҏ Un['ϸ Tΐ!|}qTUJA*vΠ_RԟHyɫkGlk\EEug8Pi^6=Ʌ/X5^*|Jɸ$~4 *w,]=[Ƅp9SUYLjt<@Iێh"-1|Pd{Wcm\7wZ q}VeS,0S!Z77;ZQ,H\gVr/ӳn#ZB-k; ?Wuû_L;C^Ǔt oK^ި0O{ޫMF,e,Ǫ;Kkw]IqLv{Q#} voNΏG,i'dڐ-S8؍N-n$ZVb˫*22sb%SMJ._N@I!R1cGkCQƚ%hh6p}u{.nkkZS_"ܴ}9}m&|A2?jznZMiO- ` βzac]P{2& ՚F5?TlQ/Vc1iH륻nj=;{kH(M_ڟ ^ ;+)x%ou A\ĩlluG1SOVEr[aQMo1Sm8PAnQWi>ë'|v~UbKn4 /`O#O e2TfӈH?6l!\#VZhnqP)uDձ<`5Rm=pJҿ񗋈wJ&H0tĭzT/+tBXqVh䗔 x`>Bi??`mc:ҥlTJs9a}mn84?>mx|PP&100644 .gitignoredO pG ꏑ&"m)F'format_tag_test.goma6X~OOQ aCWTR 2xUAn1 Es K,Zj]2BH6K\2(7aQ4KpX^k>LRT;3y ;X&*Xh31`ɖŏiJY]^]-) wbQ.o?$FNL-W0S ^Evk 1_6.Ԁs~ҕ^i DWvKf xpjJsS@^=|:c=OoUW$F-[f#5{l#d_UGDžSYQ83{;@o(HggJy@R@򘌂K XKsz`??&:=tlH(#߅xԼp9]|>pCղ>"8-\#`D Hud8d-3 P3SMfNs;dZ">`.R0C\c^^ ¾a1i1x~z%*Uidr,7iOG tc;0ck^?a+,xK&x ~Lbn>0&JR nw)70hM`-LW1d^Z$>_G Of#oTO0ɯ5Ftzt|j34>3'fQYZ}?C`Hux2"(yԓ"wPY∅RP+~/o@J7 $:?9+n5(4hW.i}-jvl ,lD] c]M;-*I\l Ȇ%3B 39E`^dfHꃒJWa`⥢U𐹲;d^՛Z&ѡ0)=Gٲ *mք-zmoƬGȴskL23)x}S6 0"x &|HH4N^e& ApԺd#YHe݊˕ I`|e[MSnJп4%IU?6CѝIɪ2w i|ôhXǐjL`_iے&ޞU!mul+wi(0& A">y-E.ByO$|= a{l=1<:a2U"-|,͙8?B -mɈ'jl`PTGw  qV&00f ۻFQZNυ j.Gŏ?ŗc 8soR UM%u񩉃RYtMQD^o= + Pce(7%)+^:ǿziCa,|ܔSz!zѓ6Ξ2Ke(32C7j78nmlJ+$*Im5EPEM.i[UaNiV(k I9[q#eeʞJ;r {jZ#ț:b-5E# gMva篾 28r˗@> -A\\# ª\j`;j[9jmh M ~ q]H]lɧ;^gkNOځPP||!}ONk]^guJ-{hnYPW$x)rT,WxS}]@ ZNp O5 RtC/`2<8 B1ڒ:PC%*Rqvcx6^+7 X"ij> ^B1reD͇("2P?ӛby |aPDnhC|K@Nj3iH TPj/_8jݣ)P;ZΐIk4$LyG1~ޞ Yd*VosJRay^o{" u#y"T*ʥW#]OOM^B~/Ȓ.F;]cǩKd0dP}0_R~FpW0sb9o6UfS,Lsm ɕB؛4ȔUy,N,%NT,VNj*UIi|:%j)ْޚ1̹ۧ&5lMl'{*miw+a)}晣̖;&&׏"5E@Z\ސ>hU40?׵ 3Km"ԭR3u=UĕuMaLU:u gbB,lɈDx-+!R_[c\eK7̊1B.f^iA[lQs%3{]Q4!&乊ȴ*ܪL\*\跩sr{+틍ʾG&fPXձO5-HrtYrxuMMۜ`e|Fm^TD5&Ciciy?Bc}}(@8LlMfōJez4D]'^C!#[k쉷|PY1e?hjmjYs1'vDbHiY*'k )=΢NP&0-L]b<{cRIhQpn:%x =+[mӤĤ$AKMrp ]h? )?y XA1\ ?@X}?[ME~[w:Vc u=Z'&t|0T0ldb0T Q8CNU >~E2dߚu7tl/Qk_fj>u .P響yNϮݝZIpHVq xi5EӀj xgRq|]k1ƹeiYr `)?Sm:ǣlE݌.Y1;B{^+.h;3 ^ϹWDw_n>JB777Wx믫rE_aT 7wF.V>c;iah6 IO #Csyqfrfyޅr p]SƏb:! ȃchBCʚbz:KU _1bF"3VAUO$$OLc851{92*.(S7F`$F;k+h"-Yݩ|@kAw_vV}t^/=pَDxpo|z&֘"৸{>Mrkq%]X[8d ⡀/89cE'S#q\htOL9#AyW!_)BX= L4ggLkV Oi![ #-9O\6{@;U7:e 7WL@J+m)W cREZ8Wk猝b|l@e49VT.7Ai aݝy! A|k'H+6>`c(N9eeeB'υQGqSXbw< mֵw@lK%/ "k椁TG삂))gFgGd,;K˘%NTVX8Oc_RmmP_ -p]:uVǑ{2UW/,U_xR`wYr[5)KnL\MWn!7GA* sMsi=m~ .hyI01WY H0F+ 9Ehcm변kt(uM2bCK͚T Y#nWwb^f|yf/ yR4M7f l`#͍%t.سDx]R_o 8X7MވMj4X4ˣcɁȐEݧAҵdɺԨaTk!e61}_|4km Pv p?fY8 èg{٠Ykp{n>hAg_g n:c=@=0"wpfuv{כ`p2fkowdB<{= ;@+a6} t͍!(|={tu8_'[n2~$0;M2)Xn)"ԝK3 etF?)uFF>N߻irhwv0ёe M[PUBۭގءk`ȋvѰx?9o_*b6T2-4R<pG[l*ZNHZ-%z ?x]`?j*ΰZ~W |3*YVL%t+\s*Ьe#ZEVK,ljH hKZUQLrl%**6 EŮTh*(_+Җ@n6%K-劋:E$]Jou[FJޢTXJ1N jvEQÇX[`B6.~Zxp# zip: notes for agents `github.com/zap-proto/zip` is a Go web framework on the `zap-proto/fiber` fork of Fiber v3 (fasthttp). One typed operation declaration is the REST route, the OpenAPI operation, the MCP tool, the CLI command, the call-plane target and the generated SDK method. ZAP is the default transport (`DefaultScheme = "zap"`); HTTP serves the same routes. README.md is the user guide. This file is for changing zip. Checkout: `~/work/zap/zip` (`~/work/zap-proto` links to `~/work/zap`). `~/work/hanzo/zip` is `github.com/hanzoai/zip`, a separate, deprecated module. ## Commands | Check | Command | |---|---| | vet | `go vet ./...` | | tests, about 2.5 minutes | `go test -count=1 -timeout 10m ./...` | | tests without the ones that compile programs | `go test -short ./...` | | race | `go test -race ./...` | | collector module | `cd contract && go test -count=1 ./...` | | example module | `cd examples/local-service && go tool zipdoc -check && go test -count=1 ./...` | `./...` does not reach `contract/` or `examples/local-service/`. Each has its own go.mod with a `replace` pointing at this checkout, so it tests the working tree. CI is `hanzo.yml`, run by `.hanzo/workflows/cicd.yml` through `hanzoai/ci`: vet, the root tests and both module checks. `TestSDK_CallsTheLiveServiceOverZAP` and `TestProseReachesAServiceInPackageMain` compile programs offline against this checkout (`GOPROXY=off`, zip's go.sum) and skip under `-short`. ## Release Patch tags, one above the highest `v*` on GitHub. Push the commit to main, read it back on `origin/main`, then push the tag, then check `curl -s https://proxy.golang.org/github.com/zap-proto/zip/@v/.info`. A published tag is never moved; a bad one is retracted in go.mod, as `retract v1.36.21` is. ## Map | Files | Hold | |---|---| | `typed.go` | `Get`, `Post`, `Put`, `Patch`, `Delete`, the `With*` options, `registeredOp`. `invoke` decodes the body, binds declared headers, the query and the path, then `run` validates, authorizes and calls the handler. | | `openapi.go` | the document (`buildOpenAPI`), `schemaOf`, `ID`, `SpecPath`, `DocsPath`, the Swagger UI page, the `default` refusal response | | `mcp.go` | `App.MCP` (the door as a `zapmcp.Handler`), the `POST /mcp` adapter, `negotiate`, `MCPConfig` | | `cli.go`, `clispec.go` | `Commands`, `CLI`, `LocalInvoke`, `Remote`, `CommandsFromSpec` | | `call.go`, `here.go`, `ask.go` | `Dial`, `DialApp`, `Call`, `SocketPath`; `Serving`, `Here`, `Ask` | | `sdk.go`, `rust_*.go`, `cpp_*.go` | generated clients, MCP servers and CLIs | | `zapschema.go`, `zapread.go`, `layout.go`, `internal/zapenc` | `ZAPSchema`, `ReadZAP`, `Layouts`; the reflective ZAP codec behind the call plane | | `doc.go`, `cmd/zipdoc`, `internal/zipdoc` | `Describe`, `DocKey`, `Prose`; the doc comment generator | | `problem.go`, `ctx.go` | how a refusal is written (RFC 9457, or RFC 6749 at `OAuth` addresses); `Ctx`, `HTTPError`, the `Err*` helpers | | `authorize.go` | `Authorize`, `OnResult`, `Decision`, `Approval`, `HeldOf`, `Build` | | `caller.go`, `tenant.go` | `Caller`, `CallerOf`, `WithCaller`, `ActingAs`, `PeerOf`, the `Header*` names | | `declare.go` | `Declaration`, `Described`, `Undeclared`, `Declares` | | `compose.go`, `walk.go`, `build.go`, `generation.go`, `host.go` | the program (`Use`, `Group`), the walk every projection reduces, generations, `Serve` and `Host` | | `transport.go` | `Listen`, `RegisterTransport`, `NetworkOf` | | `load.go`, `remote.go`, `status.go`, `idle.go` | plugins (`Load`, `Plugin`, `Reload`, `Unload`), `Proxy`, `Plugins`, `Evict` | | `resolve.go`, `graphql.go`, `docs_gen.go` | `GraphQL`; `DocsMarkdown` | | `middleware/`, `wsx/`, `js/` | middleware; WebSocket upgrades; goja handlers | | `contract/` | collector contract tests, a module of its own | | `examples/local-service/` | the README's service, a module of its own | ## Invariants - One registry. `app.Registry()` is a projection of the walk over the app's entries, and every projection reads it and runs `op.invoke`. An untyped `app.Get(path, h)` has no op and appears in no projection. - `opName(op)` is the operation's id on every surface: OpenAPI `operationId`, MCP tool name, call-plane name, CLI command. The default is `ID(method, path)`, which drops a leading `v1`. - `hasBody(method)` is the one rule for which methods carry a JSON body. GET, HEAD and DELETE do not. - A refusal is written by the error handler from the route the request matched: an RFC 9457 problem document (`application/problem+json`), or `{error, error_description}` at addresses declared with `OAuth`. `composeOAuth` builds that address set; `buildOpenAPI` reads the same set to pick each operation's `default` response (`problem-details` or `oauth-error`). Schemas in the document are objects, never booleans: `CommandsFromSpec` and other readers parse them as objects. - The call-plane body is ZAP, laid out from struct field order (`internal/zapenc`). Append fields at the end. Reordering, inserting or retyping a field changes the wire. - Doc prose is filed under `DocKey(pkg, method, path)`. zipdoc writes the package's import path. `pkgOf` reads the handler's package from its runtime name and maps `main` to the build info path, because a built binary names package main's functions `main.` while `go test` names them by import path. - MCP over HTTP: POST only (GET and DELETE answer 405), one message per request, no sessions, no batches, notifications 202. `negotiate` answers `initialize` in the requested revision when it is 2025-06-18, 2025-11-25 or 2026-07-28, else in 2026-07-28. The official TypeScript (1.30.0) and Python (2.2.0) clients refuse an answer in a revision they did not request and do not know. - zip validates no tokens. Identity is read from gateway-set headers (`HeaderOrg` is `X-Org-Id`); `Authorize` runs at the invoke seam, so it covers REST, MCP, the call plane and the in-process CLI. - `app.Test` runs `prepare`, so `/mcp`, the OpenAPI document and the call plane answer under test as they do when serving. - The `/docs` page loads Swagger UI from cdn.jsdelivr.net. Embedding swagger-ui-dist 5 would add about 1.74 MB (bundle 1,552,209 bytes, CSS 185,784 bytes, Apache-2.0) to every binary that links zip. ## Known issue `zipdoc -check ./...` from a consumer's module root has reported files as stale that per-package runs call clean, and which files it reported varied between runs (seen in hanzoai/cloud). Run `-check` in each package directory, the way `go generate` runs it. pʩx\vFv|YqH/ IxMZYmʖ+ћl$$"`P">DOw)iOMD;w@0%V 2Ia""3vd&yY~fL20V"OJkdKGeY:=*˽Ẽ\$rUd?{6?IJ}thr |9^ta}ƔY6Dž;:4l|Gʙedљ59n s%FZa43S[)^̸[/̶@ͣ%͓4ŝC9ںk9 }<~Cy'6.7ua%A.w.X4ۨpyfū3 .]իn̒4~ ^ZrGqNwX]eg7Na$V]h?D[ gwtMQf9VN?R R¹+pc"J`9i2{N;:09txXՁ881oN_=#=vU$}w&Ko;|ZtfܿoL[Q>;j Y[[ا-gro-g 2=tMxfNH[d@ݖ>/QdE2V3 =HuN"kcU|1dyb?e I?N{Byi\&g].5ѥbLr .g!Vdl&}* Hb0ШDlqwm(N 9iP^o*\UZL`FD)4P ?RuZ \;ф/l#Lwr<};1\'W䬈8nm./Z}lv>g[M€K;`A~GN;qw8#LWg\a HVv-.`# i7uhfρ&T -h ,=V&s^t: x+iH44j:"fǭ{w d=7-nR8הҹ5x3n|l2! bʪ:,|Kc]qa%8ޅgBY_T1d=c,(F: ww1~W3譤Oe;^NP%!|zA 0SgYVL%`RW)T <RYe!F@g" 1]RG |3^[ fB:}5 äyvGEw}ph13;_6*}zWE\4'J/pj6kPK51)44:h~l`>>Y ]LoWZq5'5iLaH/qE^W~ uI-&cg)vAds*{ ™Ezy/RRj`z@ -cۈ6K%7NCEk8aF<8_j:gLUlz$P>ȧ4)I ov-⽹3|}ï1p-Q0|Ɲyan ϫIv~weg-岾&܃nLNya}xMlF5 ?Pyx/7=k۰0B*7rIQ*O(nAS+*X\p|yS+9[V(xơs0r9 NV9==pPijҬ/Fs2ճe)|:ްLܠv :J~Mxw!b F03g>ʾ&3jWu.GfP8 4^N&A!f(i*8[qR1%)P6Iۥ0ydX^ ʙ.i'tTJ=O M.[*NbsE&IDwΪNsfqz^E2JU9mS<88GS&_}HY Hs q7WkZkIo]*R$'3LZ\bu 0LuEc]ZsE~}zsG9U`F_ 5ۺ7(4_o@+|v&UNzz<; G^ zPuk}^ZU IXkq^䡦I4Jjfx8,C,5өL5RtysSgd?ҬgHT>cnLi˳3̹ffg8&bgtf%J؏r6QUn2AГc䉋M.H!V?LUjN?=[5^\fHA[u)z^v=xk,)gQl\ljFIj>oXJ+r&b_ZS}FΟj[ϳ|ıM59{%c'ltoK2ܽC~FsW`pde{1lx]ibO= J5h֫b+FP[S$R,;gK{ka#֕<0EK PnzBsb1z`CE]>B zs/f=n^*tF©ϵP=LxՖ "?~nv[&`ZցaJ(;I5x3u/n'is٦ړ iBoPgrB]28/Eb74xilвG3D!L:VN;Ok^ bԫu5Ba)=w/wq_ ]1]y ˜%~$QZVk}º\8Me Jvݏ`e4vsJWq>)~ZZ8XNMQWC)f@| gL,=9HLVXpQ]Ǡ(no{t* I*9?~S4<7u~֥ GSFiGl}POK1x쑪1q݇uUG|hCtp&ks~ߎM?$s4[Y7g:LeOg6F0v55.¶&ÝKPBrS˷˩+'_>~lAq7!T^3 \s821Z/Fb8-C#B !r>{ӐczaubD/_;O,Q3BLy^`zY0w7Aw0!B49],aVod*͢5$5|SE9NOЙ `4'ZR-ݰ~LZ19ẮIdT/-C(8Ҽ%W6ub=8>Œ-5VΚZ:0}ɱ$"zؐ''H3 (ȊT]RPZOb~*D%w,NjE.h]7Cf#t2&s͊y]iM<ٟp$($vꃠ&a)Ifkd=t^-nb2ćĀٕEua'ѝ7.avVLZ|k ^B*=foY/o|B/A;O_=Y?VW{I}y_fT3 LÖx|Qc;m` 85ЧCs~mjw wt)guB=+k]W.(Lix]i~ԁ&K jqwKApGC2,T-<](mP"fC 16jmI_efFhǫ; pb^T C4](kxpɅ ٺaՂ."^.7&_$Sr !㙤DǠCl͏Qp RdF]o=q΅De3 4~`@y,l쯢„?ONe(6w,y^šB %4MKMl!KWbv%G9!}dJO;?\`K#6ѳEj $bMEqH硏 4#VS`e5VN8d>}, >)]t(lSFK<iic!=˙ƎbpB7Iҏ#(@J*(c/QPI4.t}VKB&qTYMhrz]*ml6\*Q;_{Vqj]đ*ENe!<R/{c q /h$YPlUƬWIt9C[;SU&kOj. l-;y4|{a04UC) woZ z tTK(;|آ+g3EttJD));p1!S\{,8:RR2O9}ᶭxXn7}b"]pa.P;p jҲ^-$% 'KznKZpf83nD~+ƒ~VM&6nɏu'k^P?kspzYhc0d0ս`$c^tUJ–zZ;+&,BNCRj1Kj%Um!C1U#-i3Fی-XI!&kʍ墪H~IXVDյidUX*tJ.5 8'::ne Z2G,(I>Ii.F$w\S)#2Wx5f4,:@dj!H:/E=k qjZ" OWW8DŕQM|fW}~xO΅ROK?aXzg+<#xa/ k|t1 -n}g;o8wxy kxҡCV?{CС5/*~ h{CڛO>d0xZlX)IW]96tbznS>ÍDUYJbֆmU_OPqW%ض-QEJFXe%Yj 4gk0l:Dj B#r&vYx.| k.O}؏bNT}L* :^1`*(ۿpEX+ ]od/YD5~4Fa™Ƙ7e3;aL2fAc#&ep6s˶+Ms/#).~lj~ۊ )|ӑO? sƒr71Õ\-YV#)=cΔfR`#nA'F= <[V8Eg&@K|}7x5H `ثe} L;g/?ٖSHK.-9g+Y e/q%.zb~R+# Ǔ^h A҅VF#KQщ|B~yU )>,x49 X%KJR9]f+*2 tMM&Pls*l+83oP`OTI[O.ߑSKʙQ{r&hJW %&s3㙹*_&ΰՇ(:Yz&o=LtC$_ 3(%Pܼzט8Sn ߈xK(W_.|n  4`[TD~Pdھ o{/]"MJsYkczPm B=hnhP٬\m)uU1 FnCDk|na L|pg8{c5 k![ RW ‚#AFU Y('9Y҈8 x vj^u&J -s痪yFJ-g`3H(lY8i~*a ׃! j]<#?>R]`A E7g&:cJI:{:+;[*!L\"zqgpUAUͣ .=[U[[ 57Q@WK+Λ: 8/f!5/>XGc] . k^jӢFA"!^KK#;8͕h^x0[&?x)K:3%x=o&}.ņ#\i-IyS</n?'>MYu a B9MS@ukKX0~ h#:y|5u.!ߵY JxwԳSgzҾWAtX'oIgwKRuYc+$ݕwe!;1m>61eh]rG5+$UA5O.P,G U;lQKNW@h0E,ĺe%9- N _J:H;Wh8HձGJI<*)w0Kqiha:#Ǽ>$D>R",zǵ~#p܀ hS:P 7> ԁ@ȪS&'2xـ/%0CISA{O>"Pa5GmAIbW9R#,Хx5QSW>C$ct{.u˳Aw^Z(܇.(3ޅǑHUcΠke0OA^*AT%ɳqyLI8%dP.9-+Z0ctƺ ܕr״c]) !iO$gV(eSO;H|FX,+,gU=3F& ŏbAe| h@D~MP: N=SvbjӉ͒~~~esM&Bhgg{q7 QDiL2gwv:kѐfMl_5/\*!~?Kxو'Dž>n9?X|g`=!N"#z/PI@e>flZxRT// Streams — see adapt_stream.go. ONE adapter rather than a buffering one and // a streaming one, because "which adapter did this route get" is exactly the // question nobody should have to ask to explain why server-sent events // arrive all at once/ on one mount and incrementally on another. //u:adaptStreaming(h)JwxXn-=]F)Gr!^؍]IE~t cDi%k`O'wHJrllZ0s?=kWML}á)zF~y_֔Ǐh =YIUL?0=锖vxڔ3MU oj3ZWֶ*R6MtįUڞTTM ?%U65;ښ",5v1]5ɿ2uocޔjA>jDS #kQ#Ya,MJj=6)"MնjrN'UNh$\ą@ DTV>c8iqWj>Λ U@ex+|Wt;Z,K'bhոWp, 9DzsYmBuXf8Vl[(cr\Y9gn*=@Th<,B `XR :WMmt(G6׆ePTέۖ =BE/q:@obF߿S x!MH#O-kKTڽ'g l4P(t7ȔxoL9z?ʒ%Ss Sf4ꁥYo6,p'1ՆEFc, &||H쇭'NNAl,35rFgʵ|^"y ]?7eF?b\C3V:2术&tjݯq!sY`tUXKŒ g5<&,XÐ̫^J܊H:͊Yqبc*=tUqC#Ԇ&(i__<چs$ }Y3:Oe<0 Jf0GcFG-w0?$kR 9r!mm'2g6|1 )_oS|t}9T Xl}_c0-I[ `̑\-9&@Sxt<~& GdS\7/9sLY㣩ӊ@Hpp8gXOfOWK\W?sUA2a/_>nyGOz!=RZ9ɡ{48o@Yw(wOu.bN@ +HA[o^qss֑X=B֏cgzqX8`?iD~ˆ/br~0Ytr :6e&B&A+PTdUau362 B687XӏP>HG'Q7" I(߮e t_/ J_\]޼}b'+>D.q=Id4~*L;8iB/^HeaF/g4.9Z^-RQNNB RAj!\~_H/2[*,A–Jlr e2Ū;Mm\*>dismdBUnIDKhfVuT#|6*:p|!Jn6kMJڳ2)dIg6en2jc.Y\B6 HXU*& Z&CѮ+k] )• Dnn nol*sK!'6JW*KlOtB?s-r$]rsUT8Dj!B:v~ v8l\! d Hfu 5 AdONdb 5X2Cۥ UbŊ o%>əqX  tKĿIk]#s"i6Ff`YAJ3} 2tAtl1 kr CT/ 6y-Ԧh㇃eV䇃 Z YShfX/X?:lW\Jvke 1AQ-=uc2mf$[WmJxf>Y RĻ s=8[\}W6ٟ0PNb 6JLDvMޕF H1I:zέ{R3EN_* X:AKMIl9}3]m||g8Bō6o{`Ÿ S^ 'Du>|Oo5FnKxܐnx6$o0աgwUڌd͞ncFj0EmmWj-¤.3 wL%*JO鄩Ɓyݚ^< ~ۗpEL*"2Jul.4mh%TU~ p.߲w" }a9 &i*qLX*BB^՗JtM0NxhgLጉxJGH\4$4^#Ծr?єSzG2"t@QC3F_(= :BF@j`4>= FZu)8 B{ y8Cx! p1ٿfr:l9?>^-82Qu4z/M.g`x5.4D*LM]UvNNo}S ąb'֛n bt< = 8hM$z/:ǢQy _'RPSr4`A>_5OAцn}/#n'FftS(}WDwDQ~qa{;c+fw*N a7tS%xnwsl#E9`w7-nP݃OJ WkALC#~L2P*،*+[XYI'q]CLkn쁀B)<{ItT8x\&/<$\?UXTWVB+4e#1s' NNU$x2>+C-1 14D<:N4;ýC =3n.YnO NlzF -zG3rڭdmƓ^Viv/TU"UN 9qq| gr#DyNw`VB.Y'0  xWn7}b@][Z \h>Hݑъܐ\)#/t\ٺX$(`̙n%@,v[*mV4'RG ?_puF K/ 6-.+qYﳨN&r7vf`0΂+DUV (l.Q! Qip%c?B.KBH:m) JiGʒ,R<(f01zR_{Z!͜$iϢ7i?8 31Ŵ=Ub;Jc F<VUCj\zvT@c`wҍ*\VEhЏHXN=%k"U'‰2m:_[أ8+xO~zIlԃl=j"/K+%A)Wh-fԸL`YBUyQ\/.D^1?>/Ps)JnBa{8/&_Ji''7شسVkL bp;<]mD\^/[i/ <([$(裏B%G A]//D/Dv%Xį:%Ѩw@8sQNG7q$m3GDUb沉-B+TƗ ,]v<)k[#`?th~Fn *3 N"X8k:ꀁfcMu@OY"]#ܣOm*!h[gFlkD4=(+4v鱶D^}\ HyK8q6/fv85)"I_xC7։YQV퐅\Q1~|)6Z)eLo8_' E~Ҍz%Ahy'L"~)K_,vwLNՈ<ӑf>} ɒ|G? bNo2YnVBMNGf@|j?C3U4HK ~@>XKvGFdA~5"l#F(*vHOTeãgW9ĸ6n;V~Quc}sl!1Yf3_.Oٝ;/=u%3oLKhL_*v#ZϾiU߉n'[OVP!A|mM. ھgԭ_)Q:ox package zip_test import ( "fmt" "net/http" "net/http/httptest" "testing" "github.com/zap-proto/zip" ) // AN ADAPTED HANDLER IS ASKED FOR THE ADDRESS THE CALLER NAMED, and the // request-target is where a net/http handler reads it. // // It is asserted as RequestURI and not as URL.Path, because http.ServeMux // matches on URL.Path — so a mux-based test is green whatever the target says, // and the property needs a test that reads the field itself. // // The handlers that read the target are the ones that RELAY: a proxy, an ingest // endpoint, anything that forwards what it was asked for. An empty target // normalises to "/", so a relay asks for a path nobody named and answers 404 to // every valid call. net/http's own server always sets this field, which is the // contract an adapted handler is written against. func TestAdaptNetHTTP_CarriesTheRequestTarget(t *testing.T) { app := zip.New(zip.Config{AppName: "target", DisableStartupMessage: true}) var target, rawQuery, path string app.Group("/relay").Raw(zip.MethodAll, "/*", zip.AdaptNetHTTP( http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { target, rawQuery, path = r.RequestURI, r.URL.RawQuery, r.URL.Path fmt.Fprint(w, "ok") }))) req := httptest.NewRequest("GET", "/relay/logs/livetail?follow=1", nil) resp, err := app.Test(req) if err != nil { t.Fatal(err) } _ = resp.Body.Close() if want := "/relay/logs/livetail?follow=1"; target != want { t.Errorf("RequestURI = %q, want %q — a handler that routes on the target is handed nothing", target, want) } if want := "/relay/logs/livetail"; path != want { t.Errorf("URL.Path = %q, want %q", path, want) } if want := "follow=1"; rawQuery != want { t.Errorf("URL.RawQuery = %q, want %q", rawQuery, want) } } HxVn6m?U@0sn7)5NS u0EJKTF&Y{=Nrb'q u;~"({ݮZXNLW-ài[*P>MvELEYZLzd~~ ~'-5 R1(NӛVCr((sƇm[G.HPJS[lekZNwtM`t0:h498֙JRln>Vm%$"2J0%0xXr[| Ȉl7ɰV:E;lI#Rt4)XG=ܑf! }>I]wGISa ez/Jם^mQn 1<I @ tnZ/$ t:̕醵x%^_~27oųSq8mPRѿa!a+M-<)so_keFn\@Д] [B|4X'֚<0JBJ բ!:zL=B2Tbg;2zhtq<3u4r$*lZ7ws%׮'jiqyk3 g~֞qvgrnuTZ|KM!cdDfsds3Ae k%4䀈rf4 ZM14)v,K4@!o;8Vȹc7dWo304\$Ed#>j̮ÿ>.5拂Φ0q!&H_-}zYo7%C|?q$}0)V$7.|y᫯) /CZjM%~ 9{iN0k[Dh> O{_,ǹ~zMڇ{u=J~;N8â'$QubDL3L^݅goōVߩrK~6hu~#O~Y?}3  jߌkjNtd_ڔZӵN0o&+ |هU.j`D  6o F}k }%,=:Ѩۋo^ro~P|3O/^<|nKoOgg:~{y7Twpy/_a`2pW֖$!?t ᩨxZnɱ->E{R%= P ˜]ɑcDapf4=#Q!y|U=IKuu]f=3OQD, a$a:YG&4Й6Bß c :NFߝ.JήFgjijop$FWG*I g:J,Bc)QEVtaĨeFMeS(^EVs26d2ɍj1.xFO^|b@W;TQs&kƝKDd ^S24&hꡳ7uhuuM_AP$a k/xh\L4}q44(&k1X ֝δLB5Ȇ7^qĚlz/LyB7U ?UcۡM{E,| zy,-NnP#Ga`krC42%"L<7XRQuD㴘ItiUx\Fq̛y؉Bj#cTwi( < ?p\:0 |Y %䦀I(e*Ȋ_)!5Y6r/tpUPCC\ I-aa9I&&\ Gp-cSeIP`#Dr!ȥʍ1U`0n}BMyX <$? sJgui"%@+~Ђ0*yh2LH"NX5NKDP@1G#K۷g R/i0l&Bf[ 2$cxƚb#2J(`vJndR{VNF|˻Vn'f˘}n/?GL3׷~ hnޕc ٫1-xpV6#"վILf_euY+ T)mؠ?\k<&C&XNbdjXp*i9-Ý9C!yY!ck`qa`(GcR"7K?:җګo" s?뛃>A7auk g)a" alPNQYǘs6]@CURR+*}ՂӇPAguFSGՎ 5$ O_O>{pzkAEfr$g4K*cO;S^6Pn嗖 T9TyjӋ78;})զf]5&-"A?{hJ6= L^Q s`kȋ(6],bB $2IYKs{I]<K7"*%h놻@ѼJz"=Xe~r_q"a('ճ|y;{* ! U~`x@eb?u-7m 5gcCl^qcmp.G]d&9y7TE0 %hx˦=&=r3ը1B[j"O>!r08sƔ'TK@_uz ymZPou.bX #2Bp86s6'9VcD1AɊ}jN W.Ir,&wSrۏt%eMLIv[>McsU(z%4 @6 zoap1ͱ hEv]OF[}FN>.!3Wm`v.e-K suq?& ٙ[X;j )MBʊ!C'uޘɑF2-c-r畘ƒ؄[sVۑ%H΁.9*YWw_7-E"F #|-dp^Lv(5 wmV|^:  w}%Hw8eҺ =f YD7h7W Bn2hWLK911Iv=.<VH|:V/0xZb˦ O[! ˲̈[+t?gC;N'gHi`fT5`UEG\"шTMLM/s"%5J`D'ܖŭl#~E$‡~y9D[BotpC4GU z!Ek#J`vyL_&dv$e[#᧞=.y)Jc rw<6̣oߟ]Ѷ↑:xEq+#hLB4Ot>"kop1œYNgn?=aX1mmʸk*'dq ߴ"( YP(ňRA4cܖLCیaSFef"R4M钱[nY ^ekC`07¶q#IīQą=섲.$iH!#ZFՈqyjMŲ &Nd8 dWC,38Moʬ?eFѓDz {ce4j(bd|lk@Z$R]13u/_6>yu4 ~w2ToCle۪&O5*ol&nn><1q+N "5,_ t:{iF77 <8>} O } ;/?/եb*yN8E̒/Fj;5J^4HzP;P^q<|#]JD'ݲM%Fq:($9Gߙ<ݓl#kvJnMw4/;e왯ZI5GX\W^&U!!DT0Vym#z%H7w!+4%0ȿ]#j(J*v*#%$?V4i2.#,1=$IEF¤_4.L|bzH-x}-J0[$ʇ噴l\`T6m'tTRLn09)F,Bpj(6[KF[~K^uer|:eb˨UFǀn<)|Pq'|,uOH:P"ʯu>|u-*>xuhdR$} xC1`ƽ@7H'8IGwV\bJr)(4E\~jwe( @r{ dWEp^MQ([fJdNPQ{i7vYĻMH_pc6UY$W|اpcHcz0+nJf_".?dg% Qg37W#jѝ:Jvhߥ6rxr9_^}p+<UU\HE}~ }?f3s\si?H8$\D!0;zaP]s۩`S{ioWg=ٰ^FrZ;Mam]~xpackage zip_test import ( "context" "encoding/json" "net/http/httptest" "testing" "github.com/zap-proto/zip" ) type traceRef struct { TraceID string `json:"traceId"` } type echoAddr struct { Address string `json:"address"` } type tracesAPI struct{} // Spans returns one trace's spans. func (tracesAPI) Spans(ctx context.Context, _ *traceRef) (*echoAddr, error) { a, _ := zip.AddressOf(ctx) return &echoAddr{Address: a}, nil } // A PARAMETER'S VALUE IS ONE SEGMENT, whatever is in it. // // The address is a URL path, so a value substituted into it has to be escaped // as one: a trace id of "t1/2" is a single segment, not two. Substituting it // raw produced ".../traces/t1/2", and a relay that forwards what [zip.AddressOf] // answers then asked its runtime for a route nobody registered — the request // arrived correctly and the forward went somewhere else. func TestAddress_AParameterValueIsOneSegment(t *testing.T) { app := zip.New(zip.Config{AppName: "traces", DisableStartupMessage: true}) app.Group("/v1/o11y").Get("/traces/:traceId", tracesAPI{}.Spans) for _, c := range []struct{ raw, want string }{ {"t1%2F2", "/v1/o11y/traces/t1%2F2"}, // a slash must not split the path {"t1%202", "/v1/o11y/traces/t1%202"}, // nor a space widen it {"plain", "/v1/o11y/traces/plain"}, // and the ordinary case is untouched } { resp, err := app.Test(httptest.NewRequest("GET", "/v1/o11y/traces/"+c.raw, nil)) if err != nil { t.Fatalf("%s: %v", c.raw, err) } var got echoAddr _ = json.NewDecoder(resp.Body).Decode(&got) _ = resp.Body.Close() if got.Address != c.want { t.Errorf("requesting %q: address = %q, want %q", c.raw, got.Address, c.want) } } } // And the same through the direct helper, which is what a service that builds // its own address calls. func TestAddress_EscapesEachValue(t *testing.T) { got := zip.Address("/v1/traces/:traceId", &traceRef{TraceID: "t1/2"}) if want := "/v1/traces/t1%2F2"; got != want { t.Errorf("Address = %q, want %q", got, want) } } ʑnxWnE`FfM.Q.شJ#*Lvg!lnC< ߙ5nSd={~;gQ܊Pmc=e07~G S*-t}M> V~Nߊo03Ck$y+ yy9T9a䝔 '7xkYYZ{*EZ]P㝬o(e6?5}1StBZcǜӰ))_6ˊeB"޿Ǭ>Ly3$~LQOJn&U͙G3\}O.WϏC)QQ^x)a{ և#BмT [:"J]H Hy䰭Kgt-dwgXtV4,IiTƵAmd]+%Ai=+_R<Աg[Q"<N.Z!bS7ŶdH(X7>w+q& % U> |!1;ZϚ9:QMh W^X6_#ho˶43k&Mh7ϤczC9Cl!@ΰ(c`wsv)_|6zXABYG_|7Ψ*%3X᠔m!hSO?5.?C9%2 KkQ) ;7U8GǸ6>3WNh? v-! Zp/W٨SzzFFn>20G#m;6NR)UwI @P? )U+FIw m, ")TFUlC)K' GY=_rZl>\\]],W%0YZ0z c[8c`R ԗҵwe0 +Y(`QG<͍ ZaJ=; xK˻|(/,C>Y |;\vxy3?W$cWx  tVdUI `@m.X֖91Q &t;3E>(E{+m J)rX7!1#e(u[n\ .n#qL=0GǪAH}MW>=p2[m: sC/^ wsG47s؜ sezh+yCa8=~A`t|tK\Ol+J`IpjՀP"EMڢlcmt`\BxB`y R L" &:d=`Ϻhܞ]"O9Vd.438gKg#<,Gr#@}oR?௰FղfϢHz~]_7s7- C7htI32],ōF>8`YUuagȾ5n4 p<]Ni?\ۙ?A` $4^nHvN9h(=4 Jݸ.Lŕ`uuG39.D&wU)\E7ݻw Y `o?V9~Dx[%͑:yW4ϣve{ۈuLmd6 l*mg՚za-?U8vW֏= u]蔵92>tiF$Ij@Cr̭׍_֑#ds;R} E3+6٣9*ԍY&c2ˠjɿRדPI Tm7վy8>zgu<gԣ/XsVI㿮`(SXS.oNʑO.ż*Ka"#z D2LBYLDž|(tYaPy*pRӮw)c ?@@DYVM%zFBz4c\q !ť De[)s >|º.$;Du {n}T4Bd.JAh,fnĒv)֖޶Áztl0N\ykw(۱}1dr3 ~@^eWJgY q~x~ M9A:o7ӱ*"q# UBx/#Kcҡ絳@A̘)N>|IA GGOvt:4ޜѝF"ȹJLiO I9z,Of<[I_7(bYN9ʇ:Ϗknb{?7|JF,Q ]dE$46nlX)T0dv|%VS nizm1i3zፃ!Vc(Z9)/D,2u ZʮP=sNG/\,nfTڤ㉒Z,:I'ҥ҇ݏgm- [no7OzD^ 5<܈K!ψ&*<}M@a`'yI 8vt4/FThq O md1o3K'늕O[2u4߲q1TYTcڍ'ߚ9ꠝ0q4M3$xJQMpAE,3 b_t#d貙Yc62)3줶aޡ5m}=%0U_zF:MlDWB%{׏XЩ+PANqM0P|+xUMo6=[bCc` .`4{0|)b-*Iq%}3= 3oޛvJЋ;Mɕ.tbV>.C]x;CsQg~˩螖l^66> atqhH֑==>>RP.2lnDݘdI|Vm{KUu[*%uT'$9pUK6F(0 0ANfdjT!ٜLMC؆=\bH*!l0Z7Կ 4 8|r8 MN̸If\xm el:4C˯լX`bKo] &\Ǫ804UEu4C?H7-hq~grwAa=62lZT"]7@AATM8Xmnf߃T~i)MQ+_>|}sIWkr]SN7n6ɯܔ\ܙv(P(a҈kژ‰瘵cT]n.aQ6vۣ3w O1E1 )CW0 ×va =bCVBCJ 7hʣ*M-"$dxgr0cClm&2\}Bh% R5NJ 3k=b{.YWc0?%E6Z'ldt[|^GS]Ld+3It^t9K_>+3qJﲢՖ߻j8{s+\^M4<) d;|~ay[ M;d>nnFӛa}D%ʔ/Ί݈lnS.b@#&SuVA7'cd !ʣ~TbP}8Nv$rNΫ}b~XJ YwQ42"Y#,li㍲g9'T2;XuUc4h]OpuO"xm=o|1|M>i&^u iD-?#:GxVnF}bB RIE aCQ(+r%mD2K)#/̐2'EEs3glkzoI!&YGʒ^Z8Q{|'2v&xh­Um]tCJ~mI幥}SDKz7z!~^W~'!%@qip&7ÃPU=YK8Z #Z9)K祶O֪j.:,TJ ~Kq Q[e#ySj)C\\HYAYpMU"Ab\Ѓd؂g3pr3^'cXOcTP,_|'8ըvYFvf9ѽnlq7byNꚓ(t9> jZۨ|lX5"Qm 1Kgm72+;lj7'cH8ԧeGNBF9ZB=3Gv=c-YSby1fO)EGޥKͿiSށ#.IoW8{*t3s҄ PI[mZ~ˤKV#.X[xLHYl+dTTCCS ܻ}t;>ݒaOCg ~WW0TY)I<ةDmꑪ6jhcl  U*K0Hzib}_WwߴpGbSFuG&;eArN!&a#蘛/tUT,KbDשNQȀ .muxۜ6b$Jת!@ĺi2YC SnELDsrёk6.XE?PIoϸ}3[+OH{ġeG^A OpZ>}$6Č>A [{pp̻Ձt]cFY.uiWf& oRVbՀ n8 b fun e!QP.+H{9>!R+kYWe\ x k|J}SL?'~"v_$ycMZΉ"1 {?s}DXM {|xz(}\vgu\ 1DVp 8F#\,\w& 9Dc0[ϟRC%(pÖEE \Ѫ6K>g'W%צDߔx>package zip_test import ( "strings" "testing" "github.com/zap-proto/zip" "github.com/zap-proto/zip/internal/attribution/buckets" ) // TestPkg_IsTheRegisteringPackage pins the question [zip.Op].Pkg answers, for // every form a registration can take. // // Pkg namespaces the process-wide prose map, so it has to name the package // zipdoc read the source from — the one where the registration is WRITTEN. // Asking the handler instead answers the same thing only while the two sit // together, and a helper that composes handlers elsewhere pulls them apart: // seven metered ops once published with no description at all, because the // closure that wrapped each handler was declared in the metering package. // // A scope's verb method puts one more frame between the registration and this // package, so the three forms below have to agree. func TestPkg_IsTheRegisteringPackage(t *testing.T) { app := zip.New(zip.Config{AppName: "attribution"}) buckets.Register(app) m := app.Manifest() if len(m.Ops) != 3 { t.Fatalf("ops = %d, want 3", len(m.Ops)) } for _, op := range m.Ops { if op.Pkg != buckets.Path { t.Errorf("%s %s: Pkg = %q, want the registering package %q", op.Method, op.Path, op.Pkg, buckets.Path) } } } // TestSite_IsTheWrittenLine pins the OTHER half of a registration's // attribution: the file and line a conflict names. // // A scope's verb method sits one frame further from the programmer than the // package-level function does, and the callsite is recorded by counting frames. // Get that count wrong and every conflict, cycle and post-seal write in a // scoped service points at zip's own source, which tells the reader nothing // about the two lines actually in conflict. func TestSite_IsTheWrittenLine(t *testing.T) { app := zip.New(zip.Config{AppName: "attribution"}) buckets.Clash(app) err := app.Build() if err == nil { t.Fatal("Build() = nil; one address declared twice is a conflict") } msg := err.Error() if !strings.Contains(msg, "buckets/buckets.go:") { t.Errorf("conflict = %q; it has to name the line that wrote the route", msg) } if strings.Contains(msg, "zip/scope.go:") { t.Errorf("conflict = %q; the scope method is not the site, its caller is", msg) } } e x[r#Gr}&Iak?881 i;I U.%6[]@ډG %ΓU] Z9ШK^N,kg~߶MכIԽ؟GuMi[U/Uk|ޯ ƚ~ߺll]V3}clm> @L |S~w{CÌM:7U/?_C?Qxvc.oή3bcVMg~c|->:Y>D[ s6w? DCoS72-YhHxcJ̶򵭪==\GbLy _َ&)I>m;kT> }VLUv7q$ȴ&ɍg ;OlxrOhɋ'SL(g l\GloosR*"ʕT/2Qչm ߛ?~GjwUp֑1_jH$vFo`Pa `;>Ǐ =dd4CU*0_ّQkQbxvSCVɬfTnfy,d@%+hV+|ci+lxL eyMny lrzp-g(z.S_|{b"_Z%!WƪPw؋>;#=I̭R5>\Id%"ȓ $qYss e,rLv9>l,n3m\]G[gr[6k*T?<ʫfH4|P|_7;EVSax;>&T gUECMMo cR;>p<툅tX.sZ>/< -]˃Iʆ0^/"⒰v9yՎ\7:ye͚ 2(H4/JNQl\y`C@KfCe%{(Z_G^gKSހsOCW#bϣF;<凼O3S fSsjםT ;ϫ̦-9m>=(=󒵎`&;>Rӌ'SkGyvAޕ4FUEcٔ{(R]•l(_AQ&SPC.׮dj0C6,#בHZ'+bbt;,+Wi)X[Ə3>d& $fCy(>! Q,L#U|I+D=S^4RB4ra^s -X jxc$ZvzM8?^ ueT8FJ=ù Ɛ`#(SΛ ѧ?:>'GdZ=8IK{&xT QJ?4_(}N=gLŮ K 2:0 ~im U< EN ÚDMb|"$*gvҰ }*2=v2EiVftęO0cl/U]c`/U]tJO5ڻ' ňJJ 6'V+׏R v洍! 2fE!єMgٌijGn؝]u4<ʆܗىӉH*dx}{2J >j"p`f v2M1U53_,Fec.IiS\ m,h~̆oR_u~fL^R%(JId4֗AJuה*:=!:4<*rjW]37cIi7^n\dBD"^J) m}z$Ue^dQy@}hFր? IӦ,}QB(á%B"vY i Y0ϾT֎) F2Xg/̇wn5MkswSJx݉n]̰JӼ\Pp$ ͸$S! `'ԇ6aSf1x 1?8Y6Yp"$ 6' {9qç0Pa5ݩ]2 ͎< ٽc$K9Ȕrs J pGuծZ&)FS'h-jJ {H=($Wq(#?6ݣ˳13/vs3rmŇkquD;.v0.W d"Ϟd>- ~X=-s('kPsVT8< Z7>: &+ 80^#"w"'3UcK1^Jn2.HC4@:f&K ؞_`˦H{}_hrܬnTy26 mK>V𭹽ZdѝV!ljS1N;_.HZEy0r\jHAwOavcV 2 ^J"mPy7{>Yefq( N[`..oξ^,ęJ% qw*$̵ K#lR!.HŠ v8KJP]-,t:݄v .QZh0 ~-,vapF (B=~[o $Wr /<i[P? C̲Cs{BɤH-4klHTJ f Zxy() / hbLzQ6i 'brPfV #5mT6r@^>PVS#pО-)(W/fTV%CKBJ4?YD_3:G-DL 7D̾bf,Yi>(sYLk"a2i^U\,M9Ei9 nq%^-% Fc{ǜLANҏ%2ͱ|#DK^J^)g sOS\H=W~q(18gn`ZzkzTX4*bq0^#Wi8 ~O7D&ӗ<` #U^ş'GhM,_sr#0̒f8qA!`,j!`cxtƺ.;M焜9Vx-#FVT޻.!2{J$J"(`!g>4JH/)mq2U1c Y&M*$+DZLrvheb~ m'Q<}Ka#.|]TUAJϙ?~ڐ"f"oLc*Vy ^ܟm\~9ŨZ6fQT㷵o5zHE.E+.oL*eUYAC|8؉2:. 0p)U>s| F. 2o߼@&{vdg "4߾ksA e/f3cԌN6vB%Ք~3مRhtm[9m̗a6"%\޹V0$1O&bZj1F[]%٢8^)N$+4{;̡yx_Pl# on_+ PA\s!4K|w<"ؑ`x5Ugs8q ,q/Ad)]IS;tdmt %^w?Ik2SzQ3'J7gO{-#zpp(B?Ɇ1?d:xhkDc̸QMPE3;=`SaL4&}y}^׈+wַBZM0WߞϸzhHz M3"'_G'SP)fJIT-6]d)ˉ'3+tKd:cqtt2|&8c6h<ϧ#%e8 ~ Pjx({=3$V;& Uњ͗}w^ V6o+| T<81=|dJnH6Ufҕ)JSN.PPE̒ޗ$,=RyCN0PSur#x {-`Ա-ƌdwb[ rYzq-"<}V~YwIBZ cBdS;DzR~+f$CMs t5ɸTHH vk7Ir`"RHi&R ! <%_H^e}~BWbv];"? .gɲV/PM^RB"6,ґ{D&3{5q*UԾ/qWҜ) 6k߿散j׬ ,;#w_z(airWǦ#UJi'/v󬚤-0b!@;vMiq)FNbuX-]U+4@,j.>_2&3K䀂!;]yL8 w0qmd4R[#X=DY=^ĞWy'wZЂ' Ԃ a[K)[? K)=+;MZܫM~Yr|>5%\w%o bjȨ=rOXNXBscBJ&gu"MT&+R62"SL4yqxYn7 VI _86Q`{ ðJzDN;k`b}}}!g4 ݽhw>T2?3%>+76ƣdr?rk2-mYCFD ŢdgϛI'Y=jK6RϱMƣQ5}cBQXrq4n|/bbmm8[[hjsaϕZ#rλ}Q(\N\ĢK]nf(&G!K})'@/(,WAseV):luJ.CzQ Y6= ~odٛRUxL ِh,†dؔwMlq%P580"ۘ6&GNk pޚ;ym# p+ zCyv4 [ȪmU^]wך]T{P#]>1ebO;9)աow9r$`[u$`O[YtTDҹw(k2h(T]ۚ~;cOX|S]zKl(K LW^[v/MZ#ږ vX#Օ{=<aS4Qe8> #`Й*]wup4W4W&0|difT< -zWr&4^<9Ki|H}4?.M$|m(SEg=,7dC*6Qun"~-lf4^ө(-%"8P(IND$x]$Yω)K{:BE@L^6,<,@߁+FE¶GN2Ε$5j/duNxOvewk8=EzЁ8B n@vg#8klMpRl;&W HdR]A1 BVlWĩ ))$$0~vKT:X|vmHGSuA0i;xl~LeS'glû}HQ|7'_<{³]>) r?~= {Ҥ phAn|):H#P1* !ُ\qԨM9j{EGt9z~|,R]-6"-VHzbYϚިfX]`{Sz2 nAjOqC_"(J8 diN̲ȫH Ӻ*/2b |<ǏY0&d9r0ja62{CaѿMf4) 8G$$'Ynā$'9!RB7mSVɬI[8 ǹֳ-ڒQtsD&caWr xm][u)ud Y5M )!9GW*iՀ= zgn.Z?MPqɲ-Tea&J^*HZ9DNe.n r "mmˌ5j.:K??8t?:N?_t_Vm@{3\6> _\kRdzw l,~"&;pۯ_'Nh׷dmvw=b_?|(8z/v>^U}ONTmϿKkA oVۦ∋Q|(4]!z]tF/P+{E[D)OUZ{O*!qt&~}0uRu>'WT:wPw*KW=-%ƾpp p9*jM>B4&I rX\lp[%M*W̫FlC + ߳ZV.-WokdszUt{7m'SXʞI:ipNҁ) UM;KΕ鹧JG0M-/=JHc #1ٓښC'uAK>1O2k0%uܗ"ԙGcJ:):` '8XG>'h8aqV( -|^8CgEavrS89N x|fq'_H̔)'O_>/lZzF,AtƵs-XOTN4?|Ke-`Z@ T 5YUjN{!G6 _=\B-rw6Xg?@1Q{?,~\Jr/9 6hw©o_Ѱy̽2*mg#JںB|EpUW@PҪ`Q}B(S2quBAq7|/mt~{UT|]^)Lh}Lh ǻhnW5$hr'S L1ܹPUbDȊ,J%A+m*^ 2v,ֹƄR溺z?5"c* v0Lvؽ6 01:`keNEE\~+? %}豈ǹ 9ES z;0S ;LI'q҆W$pXqZі;Ue9+;tʳQN̋pQaMh_eN&0C1i1ԛElX\Ɛd~7|X(JUł)pECLd WgyP,7W\)\ `Z@ݪ$m/m\߹:FIU v h( ;[m܇]+uˀW} ȴ5-? |<iSS.}=ۡnh蒀l'Kꗂp0aDWLnoAn7!خN^r%;VzQC'wF;MAe:C7M j`Sv5lvn⚷Ϡ)b\Y.g/vn"Uų?)h"č.@rR]BH-$~IPo!rI`>!QEB:mx7dDT * ٰ$cXYqvf)M !}sgfh C$w{~{f:]^wiZ׫tݴYi獋?X~o=v_Wuc<ƅ^\~י M1vPZ5Ee Qyi 1Kd;w+ŝPU^튲@O~J_΋J6,3ڥ*薄^ߢXt']wCMp5sHQ.A}(!m!Aͭ12OsȹZ<:ew£I"?XPh_$.'fݏ Dقg\I)`(TY Xn~}rae_,P3&lo\$. Hu7n- ?IebO߾=xUH/F |9_^Բ(svL`~x߬mwd5(:vU#+΄fFO-ơE+}&2ۏwDӷ!oyze9*rz]!_`AݠL3-uAUɿ?"*X#F /6Cb0];J۰ &B$ZT'_ci> ^O2*A0( @G&웋 d2vu@1[`ւdnDgƤmpo]ʧfuY6f Hk+ƹD|!pKZ=]7յj1kLwbj' M Mq&NXuc,ԝh:Jt<9ta~ѭ4@O@0+jbUQvt V#.WcOZP$\082п~K;O* %&f˷AsD`[~PhV X7 kJ<ĤϿӽnY&:sei-Ĺ,9y`+[<6,nMQ4G>PR-S.}sAЊ2BA_Ueorsv0$m ЧsG*;Fi?rF"f0{!("(236f4+> 2zx!b|&C#-' o#[Y~83e?۟>KvDGLH_A=fH6B͟[T3A^< \f#yd`71 d O/E_']qxɺ(YL5'hd#bf#њaw4d UA.2%d'5\Tsq$"R|{k&g` LbX2:Mu/TGc`D>܋7$Cq: c?Y@M?8M5{RC )'-9z輹FGx͏3ZPOMWSI=7iqOؾϽɁOB>S[=s5YB` Nnol4_-/qsĊdL'*\G \.aRAnA$hy nI;y$[pi 1u;ec*{%GTL!C?M|8/}lpD=I;-w- yp$k ̷8b߼HAƒQWh*rp0"j("nz3KԓC{c!K8`0}i:H4~ yx]Y3ȽD"1 u64i]8LYb#3sNgrSU, L/'%> IGua 6`]Tx UA; kÇ[ ;PHIg2*  #!TG>`pT"w)iڒ! iئWXl؟sa z Ojݣ+ɪ6M;D-ZxkBYSF7vaʏJ;5nBN Lۉd3۩HL&_L.%,UT['G\LCp|2 S=xZr}b*䆂v]~\:Jݍ$gT*q IxAK˪G %9=rfzzzNN>Q?gխ3zټ*k() g>H4+?ٲjH"I ]. Z'!!&( t=7ѹvl/]!nz%VݒGӻ CeHBb E9-jߞ D<0sSE~4%ly`|d]^^N˸9b j:_Mܗ9a17!ikzae5aÎ>3'xx X glR'ui-IG)ȓ8sk䂺CDlaށj \SI = |wv>fĦbgD _Y^.v!s'A>' zޛhaIyڕ5mzs@ ЙCU~gn1 P~?_XwoIIy0=jGXkMFww's(!3RjCyxnG I!CAQQLg9[Fm4:V8Ltmg:]e痘H*Ah]1 [\vEJZ7e6}JlGǕW M| m΋PD6V'3u~-t1@rH+@n[ {jtp0]#,j04;8>a$fֶj&U㌀uD5kģDdB (L66YjS)$!rF^JRr˘dTB+FƤ1q0"?YבN>ސ OjJZh %YkꄆJht5WP'g^ѽ_(f:LoROӞ 49:s;ke?-\/؏uĊ | +vKvm{nz;'m8-OSa&aXNⷜ+ w*8f%~f$8iBQ C0~)Q^M0ڈR[:$7Br!?J;7fC.jR.jmd]%?^ vz3h8( er4:$,Nx3^Y65]w4\CViAc,[;?ZEyξ}FSB؜m`V>^@nu0Yi4uw7"wF3F>76uKZ6?_5yV RδED#'LhjGp] JIFjNTQ[ˀ!g$yEB'_"3BkMrm]=USHD֐L:d(!wX¹}fߖOt@;ؕ7HjJMxjIoDex*+@2q "UVlaLطYCqJ_{,:a/ܬ3d<,u]smf%}]mlMD;j0`.6n?>G? :<ڜ,v%iz]몭^ȳ|r<<>~¼E 7ͥm^#SV-ZV^=yꝱumښv~Mnr3y|rc*t7t}c4Ե+Sǡ"OC8SW#\Myb-34biV_]yv=5YnVl-ڴUU/XSͯ0 V%c93۝vLj¬ [Nr5v"Nb)ZWMN`MY&ٲ1H6)wX:J6Qʵ*; G[KWgu^EyK [[+.[5 a|AvS&MJ 0_ER˪io]Kaen8eK׌ȴd\p1~\Y[kZ8NTORQ7. ~mPWp'~)G0.3~Gs%[Wv3Xy]oFbhvmLY0Q>U]ß3Q6.k8O0-ÃcV'EF}UWR),٨./ho\]WuHv7!@` 5<9/#`(.aʹ8`VAy̒aZWbs69 l=%֒g1I 'F%&Ɨ[M2pEb)+ev[UIm]+ ގZl9Mɭ[TxU2 Cz>5ʱU QRլy&X+Tm d7]72&ɀ]쥩a@)u(ڻ(+Ab眎oj}PaGq$ivR+S}Q;&P^)Zn=;X<-_C4q2a yÈ M\\yr~7{mwk:eb!tMr M|3}rX@՘iqq5pfIOH782mFv:xj۽졡M>.9.EÒTg+}x]%JV!I(@B%2!ecE{p-Z*n_lDa|E$T E~:ɔ[2>_HUwE&Ix:.@C,uO\0lVt]v :Db\Qh93b_5I3LN/t 5P6jblZያM"}iMPLŽ8:MiZ>T JA?4-[he%E%j[ G40ȅ)#"Z| m "LlvxgR̔uTi 0W]>ܝwg\V|V{x-d"RX@õ[ 4y[.SN‰B q<1pD$D;8|}v15MiͲj{ڴ-v:i,~B"`yɾS:!6YZ teP@j^? *b5dfr}ne_J' v,Q(~ 8]m,,*}ײ=4h6{4̩1u% TOnxFt`Hby*#hdL3叀k0-d^%\]=qWSn"@90- P{w/; ߰F3եAeΦnzS_=H {(w}X) 4T\gCcJVlԬ4e/,/m( 񅞺}P)=ك9   ׋͋L.O*'%~,u*BuR,`/ pѴ]6: }G4f`m>&%VӖKD>W<_ >PT<<> ޅچmbP$4,c)&?8rP!K! {pxdFPy&1,jpC,;ajx@wϨ}ӈ>8Y;e*CKE&EbnC5D!E T6չ[9:d$)kιxr8׮3IyEhQA/wƮ0z`!u:ק DSaXՆ*WSoSy^$fO^ ̓?&I|Klq~2Ord~7T!N-0Ɏr(ϿIԗn=ܥ߀{~[mCdŞ䀼Yl^r3>.aJ!?*BW{%b]^3ܪg|J)Om%EGO)s.؎]Fo{6vVN :4UIXF(ewK>Ɉ{ܗqwX9_—z `Z ͦ. b_ rerƠnuybVW/?\y,=Rޑ*t[^д)78e̅ ']Q/ϕ"(KĄ3M@[bBbV.0Xlk}mFsd /.'@篝Mw)2NZ{Mv܉*=-f=gdYTg[zr D46KhXe~H.|߯Iks* .')+H*,y' b\IE^ W&* W4u}o9XvCK382WS.'rnrq8BsGQJIGu)E\_HN/1M&(gay!>K=0ürA?/Ӌ k8: pIJ70>:MWcEX :owŝi#)OHWmrpYt99O~&i")Zkޝ#$:PwVcO]r=k ˱(hHꭼiﵫN%eE_%EB"bs_j+6O2[1r>qV=IoLbkK!soPnAM %1 $$aE0IJܼ=7?U?}u-xU5:@+K1FØՅx L狞v4ƻ&fu.Uގzt[ْY~k򽭁%;x\="vhn^oo߹h̎JS;4BmOoY/0'z 9oN9ϻSkOe5kN+evB5CI5"Gm{(RmO&OKV$5Duq1\W[ڎ!n H'~lo|S~א\U['8=Ѓ:>.]XYh!.y Ϻ+"zTgstUv]ZKIڵly¡eōJy " ?aII AЌnLrG XɯÄmtWSXQJoߴYĥ(&_nݐ?DŪx5JNzTl2;&f8/Y[m-͓?gRgͼ4x;eK馯D <[ǚ$f?xyS=it\˄o^#6þ>r#-w yY,Gf}Tm9zxUQo6~~UC PxhC6tIѤCjxJFv~~~I(96R@"G;$6ItZ@$p6ؑ/_d@SX|T QB}`leF?צ`]Oj d4K ]Х,xtKڃF5bf./ހ+S[@P0u Y0F54vaZ? z? ~\)s Eu{UIuyi <-Dg}jy Lg"Ɉ,Gw:G_4|=Z4t R7\WAn&Sp*(^ Dw"^ 6u5sPpbѷx.[x\LLiЕ1?UWv& `ǫ}!g%1NkQpJ;/شgڑ1rĖ%:bDݾOiiYyвL5km3@ݕ\G.J 6|xv# tg@m8;]F''`t!?A֥HicAbV' qA% GC d{ hRX+iH@e̫ v.z1d=R-Ǚyw VAi{Xzz-F{rD'=Ieߎ7 z4m?AF!.g:43jɖ0 (LN7h?g R@aIE*dbxMLs]bB;~_8jcX^pʑ%6qcE1V/޼y/1lAsg>Q:H'<iI @ :0fw4P6ͤ0yiKd |$|LālЇ>Ca|4OÞ90LḶɅ*0OWom#!İG ,r#pՈIyx$ PX ç>fy J7΂=u@Ù yAz&2w߶ v BcZ<5̕Sqzvs[*?l |7.E& `D0É&Ⱥ>'OMw''\# \a)f!R(V췼wh:O JA$L#yoWloYwHÑ{NT:-GzI!DQ[XK FTWvEJ#:}־z]$gg cr\Q;i7u0!!?tmƑzCq Ig;͔uVU{hNG5UjmmB]4"]v"eB~$:ۨV5:ÂNAfm&QvycoZ,å9}wi2IcZ#P Tz$Uщ0[B޾ o@J-Oݢ6 1~l@#7e= 0\ ˂XO*/ERCR&AW݄TzS޻b)*IO0kf)7^@7JQC֓b $q,ϡ /(6Ԏ BbZʀH.0Fr_[^䁑Ue?IO8-Z>i9%$)gȋGV"{{A8ʡzpp``;)/ȸMPLb0ꡭUI$D8j{#bx%OaX%APaهH{sM^[$@N@C87 }Ү{"0@_`lбWy="LR8Иۋq7K24״Px;K%*o\6"HzM\6>gʼny~v36ҟ਱610KҶ|J$ދ Tcq^%uVY} zJ;IsT J[]ͤj^ &[^㞟}u|xsH4 ͜٨z Z6OP*6$4?ƻOf+MƄϡ1C\?0ds Ҏn7Wl^>H< lbH7.^k $ ʤfR ôf< Iye34v`=jH@ S$AUP?P|(cr}[hwIkpdOwF2ȩ|СS6&2!l36ReeU 6O[&ZgDG }rt? /`AUԢ!3U|Hg51-`&jOX(lׂhD4Md/m{E>SɎdkVP^ґ\LBhgN @rIH]x.+CH- }(gRMH3̥De蚊Aqd։S<CI~O 5^[ndzom7A21Y]U 18DMY!"yErhu6!5U%Dl:9La^`CBOX\02n-4c,o6y+M;))6:R<&PzLG/|^MC|vppF)8\p]eW:Dxa:7 ӫw`'&ŕy\1*u]hLD`\-% D= ݿNӞPٺwj/9K_QxEbC2x9)CkH6TZxZ֩ ɑLp_ώ.O"Ua>_E07>|Um4cd;5!c^M2xOM)8 F|&' !rm|Z F8K/yU:a;g7^"W*%.Zy55r;:vwnl7L.X^pWu7[^mT{ n k '.0IJK*ݜ7ˆsE Oˌ!k3bGC{~fα3 ÷_ &ko1 鯻J)RMHK%OfcIӐl3{ 6+R[*4XieAO'ʶ-:>93T񦛕:K1>eS:Q )cK@8/J^v SHf-P(>3z- K硓W cRy){1ζ~࿣L-hk"Oٷ,iKo>dzH5z6w)uS8/$)?a>%%_Q/;Lϳ& ^i_1rE |=,'EAn)]fŰB˙rI*aRP b+&9yx]]Dr}WFl8Cmm!{%a]Bhha# }:* w;ʛߵzlhR{ G:i{P.$  g)mKݡreGEPjnp!uR}]z6@۟DImG mObjEN*?cGZC|U5 a9C,tOr_ZB07dgi$s#iײUt5& Oo>Mz| *?W8>7Կe? }x[rF->E[JHg~0l)lkjl$yNJnMcEQ''@d;ٝڌE/;23%~IRe,2 &41.UI*8ѳ$2Gyn%弚Y~NҌ(\˔cgxb&hEc~Gdo3YѥLe*GSYþ@ez8+!LT:VB,fKLubab(ԕZcr%SaIA -,kSq1WY")TLSZIQ*^6c#-**T΄xq0ţ@I,K5rJrz[Lt|77U@t'XP K0ȽU) yr@,Q 3)T~rbrnx Xo ^LR&FK* mJ!*o&Jb!c%,m9"VO7GD' o ƒD.iOa5 T%RES%9W2 Wp&ѼfBW,x,e.uA&kpGrGU¼'k^gƩLJH 憭04-Dl_BqTzNBHb,q[(ŭxD(bj!޴QMPOH N _4Sy" kӿό&Z.X0`(yVʼW1|ԍ]*<1EFOF68a p\j<[3K iEFIb2Vz 2pN,S."vjaPj ? l~Aco-.d?@if9ӻphk;]YJ9JzƸWӯO~V7pVDD1‚ o1myNm T0<j0dyEF۶ ^̱:cUJ: *!MlV"a%zaDjLfc]qgGu3S/@GF9:W8 z> -NyN8v5ae}[5Ԭ)0[p;V=m!-TeEx fRïdo*&?R5Bo w,`SWMmBc+h)&}"qf]F^fm˨lyAȭ[%m@l>B[0sXC28ʚEN}eq~_ cEe߹g :)Zxs0S2ץ@PkI/@eF#Fd0?i#GS^clU>=<;'W¿7l𹅯HEEϧY rfTd\8O~t%cd3 & `6m7W-!6wp-N"#`9A)oC/H\%XӀr_ cx"ߨLSJ9&WPG Q?ziý?{24g%$OLhRđz@҇< kVNK\J]TQbF39HhsJ*Mwh6z>9SegH%YA'η%gy[dJ/x^毗ga{PSrl*ޙTIZ@GҘ??p݀{S .N`>g\/吺Ȳmprη4#b`xԪۃٷTpEt;n/;c3ւ?I?QV5>9j&[6n.x &׬aݰUܸM:ZtmcQԸ7E7;t on^0qGMΝ%mi5ltKpZ4i{ۏ/imWhݸ/N;<')66Q@d֬D=QZL;y/c @.+4{pgU+fݔn\Y0$Jʠ8xqqѫËSFyGtѓ]{ݠkw~6ute xMx/vOe۟<7r#:1]/|/szRNTQD9^#̤RYvlRl4Pn psmnt1g.dEoc@ _(EN;'DIp㛙3[<(R-֊ҎYRi>~`jonfz[(+Kcƪ> o-\qۗ J6vؗ^5mw*MbY}/qwxݳ.kN%9v/Ab(kWo//@xյ&K`-/B/+ۋ@mN[__5ڲ x\z{HT5\`cx:j,|FHVV| "z3CIA"Ùy?-ʙ}s~7Mh{3>?f u>g׷qt|.fEhOK뾧ۿiC~Zkz̻u03*_~LK׺7ۺ.f‰_ѵ4th~U޽:5W7Vw;3\˘Tma1~/vtmg fg;@l Xx~c.W ]Y_êmmc ,7mv1Ӷ.ֶ^ƝsyqŶui&nTYQ=v+MX.iȶ.v{$xpqT S5!,ajgΥuu&_fDL,%&^(ne+ڻ>qld KdUrSe KzU3sUۮͲ+G߆zzh[oC2`I-L ۪4R @ys?Öp2|'V׬ 7ԛٹRJTujv\ 7#IiWd(:PYT)m}E_uYwH dt!O{fŽʺQFДB Ծ)<5> qhr7 m6%djj2%cLClQ-L}gȀ'U;Eef›hm VtEhH` p>^0Hj05#3f@E* ()Zըjd܃V0 žDu3Ս3o*7>, ]m@m_r.p 'w JWQ 5ɈG=uu=W[aKS5Lū\dLhiJs,ᄃ~4EmQrŁ%pt^?O y1/GzEL|[ |<< ߃(=FotAWh3!Jsn`hZgD C#0 <\u'd|)UK_@ǜ8ҡ! ;E s6Y1]xPd ]Ry0L/Ƒ5fmFu1F|Ɛ/2@@*{bZ@"% K" L/g:\>$W.TH@Vd%hbڰ]Įl>HLv+d o(^gNN2z<18[Suh^;]FVS?u8Yn.l >svEPkjfY 5{h^g F;_GG#bm֨V<6yٛ;% ƶ%^G/_hyLi{Q:g2lOY&ҁɌ?ޢqA0hf+G#4{ $ P58F4`$%ޤS(}K\}y`Q1"^&۱D#)+ ROGЄuأ.=!v 1.%%h?$~DbY-y(Oձ.O!y7Uu7ݧ$- liHG('D2"y8b"GaR4K+Q&/iĥ^)94ךxAīqRR4[T|f=;_nbȍ0|(+0ma.e1KOOM z x8PQIko^]&f50#HMF+ƈ] 97{DolyD!~mc.Gfe.*W6BAZB v R B6Un@+D 㜮Ӥh>Of5%2b~;|AY2ȠEȩ%+ cwy5)4IɁO8Uި6CMG0wW L̼{~{/'ķ1 >:%Z_PdOV8ϸaP\^x-+CӚ-u1xKOs>iQ=n#n{?L&(?kLآ- 5>MFxYU )VKU T(^es;3o:GĔN`0*J Ƶ-wpoк!/S3ZaB5"6AcX Q-TkX SgDmj4EAHPc 0DlY j\ F9G BoJ|?Ƈf ֎')):9Zq j3ɢX@sY5;wvr"m }[.o,[tB(UV՘7A6BhRE#g0p/QjDWj|-XzX,ul=4"00rQYKU5e^`){jy2YEH#f\}0*AƵ+I}֒g8r0X';2Aǡ+_i4ʹ.&D 4)ɗ=ch%)|76Zƶ/=,| U|̾[+jAS (I#u6(cԱ $gM=QIM1>Z֌ 7(r}ՆD4Y)*HT#`laFqO= sοf#!6MM1S]p;gԙ<3S'̿г߸l#S2H3.N!M.0NkaO AL5eoaD19MI晉''ױNo@R054aUfC'p.Z_<&_? ;!R61z&BƔKhMSm/Kh,Od?_zb5 C zc,.:4 y < |>L9cIaf) -GMp ͜=dԈB I-B$AKlLʓ,م!K #(BhV deR1Ԅ ~|Kа%e v B6 -P-s43dizNt%S$ ~u)~fжdJw-JL)=.pK[K%S` 9nΣ-iۢ2ҡw9"A H‰ghO7-D}8j~AcdCpxLa pH0U}$D~P3lڽ?ŴokPɥ^z 0V݂ n ee9&FM@ﳖ{"E8X>Ăm ǰ%ƬXLPQV×/r"9E<"1+Oޯc'yt֞mXs:V IZ }RA92G|jg@ !իׯ}WtUZiZ{6P&/B E:5hj?w}X} ;K;iT8SA.YCMF+Z'?!,cdIH7u\2p__EMyɑޡhc]`ƂS٠ (;ܒ0D=xIj^G݇-[c&減ߡM{9NnҶ,(bg \ MZ[pO0 +J&_'a] ,uͤu\Kip5᮶[SsBT~襕' ܇цq QImĒ08w831IN:z,:wҺDJⱢzm[XtۏԮEP(ѻwk/wkfJp+Xvm'_DzQ|xa's3ul4KZ Ocmu>BX\Jw,̪fRr̨[_|f+=`+572jPs gZ"f0*<@7Pt@bv,okP&̑`B'@)$fb y& Q1Djgj/UcN[(q ;) @-[)(y141r,[mOz]{iJ\,c{̩$:iVH@0m.+V9yz՟$IJN)q<0P\r{οm[ZMKl1ʓ\t\ tjdi`AӨ94x%bG,+1PO Hv엍/'mQ%:?mCE:,moIMQ)rGD@Ub.!*$WBkpKJ Ir5a5a tOjRYVp)?R s `W2@bހ{82h]\)X L&:@_'80k&Y]{HU3NtxP}g[g|t:Vs#=vǡ&'X4I䤞Y*4/^9di%9K:B2(øE7(O81ۋ*DeAܿ4s@qVE'1s5'n7b~goR"o)e {!Xǻ@,/iS3g8[>=%Tf*YbC+LdhI~+{V>W|x$tnhEb )McJToi BETv_R\}-%xl :,zp+u5wbS#!DX{QEV PZ(#nkKtG9N$wTM6yՋ GTZ<(KN&\{(!O!`@0w?]ҝt*;$uQL1"u a-'[59Wһzvsgg{5~Ȓy)sR/+t* `1usP Y*: [}s#GrU(GOlF;]lK![~^pD.[q'gJ dk9gVlI씇䐦0eb a'\^bX] L}>qǫuk_Բ():RʬM,^G飩!`&*{ղ;GcUy _xo>+VD0ÎFT!cڒubgkDK(%jx6sPқλ05ASS6͜שx@ƒű}m0 6hr_y :,S>ŷȐG3{x[ G(y/Ac]33FtRWhP;l\^>cq௿ w|hA>??272a:@r,}vZNAtQ8AOeJZb>u6}`P ,/J󟱝4~L1 rܶUL`rИex KӜb.N7*M5|:2l|y츙'pudaڏ'Jk 1%sXA?!@WQ^GעoIeӊz=[>}2tqpxZQ1NF =*iv~d-W3YW.[5*?M:tԿq&%C7 5X1\gjTZakTxؒU^n1R;Iz4G .m=3bEh!GF߲-2Oo;qlSWx2ɭ?$1bu_dT^3` F\x6//go:build darwin package zip import ( "net" "golang.org/x/sys/unix" ) // peerOf reads the credential the KERNEL recorded for the process at the far // end of a unix connection — the same attestation SO_PEERCRED gives on Linux, // and the same guarantee: it is not a value the peer sends, so there is // nothing for it to forge. // // It takes two socket options because Darwin splits what Linux returns at // once: LOCAL_PEERCRED carries the user and groups, LOCAL_PEERPID the process. // // A non-unix conn has no answer: a tcp peer is an address, and an address is // not an identity. That case returns nil rather than a zero Peer, so "not // attested" is never mistaken for "attested as root" — which is also why a // credential arriving without a group is refused whole rather than reported // with GID 0. Every field of a non-nil Peer came from the kernel. func peerOf(c net.Conn) *Peer { uc, ok := c.(*net.UnixConn) if !ok { return nil } raw, err := uc.SyscallConn() if err != nil { return nil } var cred *unix.Xucred var pid int var sockErr error if err := raw.Control(func(fd uintptr) { if cred, sockErr = unix.GetsockoptXucred(int(fd), unix.SOL_LOCAL, unix.LOCAL_PEERCRED); sockErr != nil { return } pid, sockErr = unix.GetsockoptInt(int(fd), unix.SOL_LOCAL, unix.LOCAL_PEERPID) }); err != nil || sockErr != nil || cred == nil || cred.Ngroups < 1 { return nil } return &Peer{PID: pid, UID: int(cred.Uid), GID: int(cred.Groups[0])} } 荵pJJαM^r<,ɥ[rҖ?垮$޹l:T)34ë4*Tx`C!10%\! U Nb1aZjv@SyJ::| 8/NbdD?zW\,-5=)臭 kd= 9F][8fzq^nXiciM[W`R4f ۴6'$N/ǹ:Ux}Vr6}b˙CSvC8M;+c+m3iHPDM,JVu~Iςح_$\s"KIU=Umx8[/]h/=?J\wg4/(ÿZq}~+?Lh8i^JR^-  ktjbJ,+iɬsVhvh$SJ;2ngf$<wx &jkjiu`w˔ p%`M,Sۓw.q`K)W9;IokK px~^_ҢQ#whuԩLI9]sNEF mJR0*EpӓdOuBI5+QKur`go?PbBC\-|V"3荩8P0Ǯ%;V/y]K:(7%:zXB)pg/3M%/ MHpW0|荰9th%rI5+Rgנm$omJa"- T~a<&ut9:S}ۙ]=scaY Mi[g+<ҙB-o^:kB[gQBJ^xa}SaN0x}SXKoӓ8 p}2)[cF櫾9ZtOy_Qep vRn6c^uS|41k-Y>W~b?qVm:ǴvF4=wuGmI>c0.wb|TW!|<<(wzSc,#rի#ZiJ8@iV4;"AO[yK^K }iQxmTN@}bXFKy(H%ecOm];&/tfmZJrΙ[Z]~k'&ٴH>qH㚨] O1[%Y0TkM<mYvn, ,b؅PzВэ FKc`Ṿz6f^6;`N~r3[EeG?X_|Fچ-q5j(8V;vɪ%,oXOmuw+2B@.b1%8W,2xNFmarWMήyڶWzPT9 ސԵ0wϒZdy\ O+y?\GIxFӎjw_٤>(.R5~0ƲvL,u%=° ż  c;y[xg@%Ay8}4 [Cu+Sei+4+!.Yg*͎D#1xR#&p,.Ruqץ3hs^}q#[%[d0Lm\!;9mwpO}0q66!MAoM'ul T|Q|\F2=>r9ŽlðR3OZ{YqYJ jdX~YJ޼:Ok1Y|7-XF]s0AxVn6}bVvQ.vas٬jY-PFlviR8n`/ %۹](9<3sPȾUEjQSu/|G#2҅EUfG(R*߯7Kڷktu~)Y3U_E(*j}Y&Ztڣѩ5uiیӏRJQrZO^T.q>2H.H/O܊{ĮQpz3qN]JB"=Ue.Щ+C߄d@BkY ɺGF騃ߟʚY޻['<} #7JSd y#)n(rY?j)\8pp\a"oPy`}AxȀ^dBVM50?&NOlJOudXk.[.xp@'+'a62'r4/RzoVHpI^z,]K-<-msZ/E+F+Z[kx>H6Uf 'A5S'&G" n׶=Fb!,^l |÷黸)=w97@NEx] ҆Ϳ\1q/KY酀T̙3gR7#\+aMAguQ Ҡ O<(Om0\SLתzU9Kva`c= ^9q: }p뚜"m X>β!L/ނFfڨ ewg>SN6R*8BQ;Ⱞ%Gcisj@~\j\zTU0it0FJicuE/$nG><潮դ3RŃw\[5_0-S5q؇pA'D)ഈn#iM#;aHE1ư|g.BCS8VX9f?Nd&Q'Qa7-Ti]ƜM^$#QrH(!l]>'K4mѱ۶ 1x;qq5v-?ɛV4m]a 9t:5{vB>#[&)xAn_CAW ڗcHUYA _?~j) kWeUšJ ^|/ɽ!7 -dKWJ˨ژ8+f aZl}RVuuG+}r\߳);'RݟUt>tN{ pQɍ :v69 XbR֥ؠnr< 4 H|{ڻnCz6.I, H.l)qPRMt?oڥǩ2xen1)F$Z{$UUD /`aZg4ԇI:^HZǿ曙f-xAAN7?ݠ dJ<#T]+5Cr;!ƀ5A{8Ӗ[ C[X\ `Qe6'KGh`gmNO_VhB{||u{ "mP g1t|n\(4 :a 2W$`OYF .4)j[F60U#y,2g)^Yvr@)4NjxS+Fģ:ݎ&^\.cZdcHib>P4%$`-қ#wbCޞp,=Edʣ8[9uhg/7^$3и3`bv92rz^ËH^I}N)bRWO烽Li?^rzUxEN0D{p ]ChLZ@;5tӛqq K,mw.i3ᛳsf-֑vN΍#CߴC[BHX%B;Qy v pJ ѰVSY0.y(Me~{ltUx.+T@W*_X|u%4Ok1sx]~~d xV]o6}~ŭ`rP`Mk";ʝJ/]G>sy|o&ȳQM&4Biю*d6$JJ'5:'k4 jZ /}T5BP#르Tm~XH<l5[FT~pʓ6`f%$vKR(I9"Jp?F4cyKDx#݌6 9 gj6ʉ6H*kZ(8V RyD8K;M| x77~E!QB{C*4 97.u( xi>UcL }煉2m҅>lSQ)2lDA5ȗeJ[vLZ1AKfok@M96|b;\c8twUE}pFZ5lV^4"VhJ_.;wVSӍ@DRH%= c) )- Zρ@ -R&k$F ^pB~`uv!*g2n')tŞ;j3T*y.^.߄^1/j< 3܄]P;9.__y#k_A}HS򶓻Q@*w4\V>YNnјQ"CH㍽goC9SRK$OQhͱ$؞b>^ LأIƼ!JЄx8iw9J u8leM\az/Q_+o_*@@~uw?ns`h($iO=b^2wߠSx}rGS;B&`@&hkf A tC QG=>=.&Y~kUx0uV,Gq1{,=g/eAzqVe:cd&K}ix=dv̒iR7u{{EM8H`Uϊ|*Q}H'bu&sGd>w{Rd9N+NΣXiビE<&x9O:J _|eTŬcDI$`ϥFey:֑0J4J8}}Y,2ϮzQVWQMt6y4%a<7Ig obZ,_cN918'eYbSE'?GD&^Am=׎1bCm[Ϟ3LhCll2"q斤$@KF%)O>cBNbG^6GՐ =' 9J-^zIeXX (r;88M)6DUi殬=4h8!j0 ̡h.X@x a5J3bUSm@ӦZбQ+<)Fd.Nn}m6ANn~Gn:*bICۣd'#!&0:ɳ l"kcɱ%$d}K `/Qa$J'eRa%B9DZ4Bw5[j-H"H0llJCC5ftlED}L!o&bgL8$gB]f+Yg5hT($SNKN kyej 8a,$)rmDUA*V ƺhqIwΠ>Wlp3O-NE4X'D/=@!$#%hdaԋb:e/ͷiH>\dm 0.9B˒Z2;Q4C8Җ.oU;DB0`˹M IJG;'!Dʧ kkrIx^s"bqu`ه1XF]& :CZ &PCN%Φ4M}%|N[&odYYQsȭg)i>N;+ˊKuV/"m_q`"7E?5MKucE[^9\,%B=db:uQ+{*T%=˙bhYQ* g}iFQLIs2ΟIAs":tdۿF]`[9Jayfhn2Z #D"+1wF];y3)ŢX%Lj^g"FI6qQ!JÝ F>#RVK|)Dk'^*V:4{fR.׏UL|ĻA~ՈU3HQB9Oy@]6L]RM}$zA_V(\ ,`XDf?L4zz0~SS86HYݍ6|ץp9% *f\I^U cfo}۾+ ,w'M3o nuۼ Paz8 P1Tl'\̡;f FE$:;|~rQ򇝽[ :.$H !@)V!.5 ~|Z E9,g0bY2!-j2_Ww"XBbtZvEE΃չ1|~Zj# pAP8YxhSՀ[J-`[%+u +_L<.)_4䑎2 :_~}xpdbX;#EN0Df&NC\B4}}*4FۗZ0QϭK޳qfӜ6bSek;q(v{^QL)Tx#7i݉EydN3pt&Frۢ_HJ,yr堣PtJ%O8 XA[v41c^E!Ww9A;r$7iQD:Q?i4+[|^.fgMzM z8* L#Dkͥmݜ7Q.Y0W ̎V_-ًb68Eօd{"(tuS1QS365;4fHok`Qr . fϓڙ(ϩ.LCOAJ;qDb"l)&6yFYԕVW~S(BmL-Gb¡[hy{S lF.;@0TifLhߦDӅ2MDa/&Tڃ mU3d"47ebYn׺N!z-k y" L=E%Vt,Sai 9}n(F@i#D4&NgB@RYs.i\eЪt\N@;ėY^l-_Vxuܩi? x-\g(21 ۱ m,VGR ~7Qg)SMse2xSlAtnZ.@!p'/OY CG@d "uVE-F a f#i]fOW+U%OyjL"XG0ʴ.Rd9k eL9RΊfu[{do$՞xUWLH>uo(}+,/3yrv$]̊ A>4ăXvo,nuZU,bNl#b`٤Bv+|N/ɳvs ']v Bƶ:kP tlT hFWhqMAReGKTdZ+rğ4UN h$40ƔV3xu!ؙ;:YHf2UHHZ 羥*3<0bFԮ)->. xX :dAk .q!GN'J=DN (QDBnM .BكEj911b%jIl4`Hpb5q#InֵITn 㣯[O*r(;'UQl3b;x/nXX~}U?Tfr6 T*?)*S R (䯵AJu|ݼvͲ۔Հ$@c}hb)&KՅ ;uw9E&eQ1/?V鸯f ZG~_!E]U~R1>^n˚^&ѷ'=go&XqR]2zOt(788>xC_G!3g'+~`m97rK9 %66*$"Q.brpa_ V‚m*^ l:W@~@Gnlejy,ijY̖e2MK;lFÐ_wAXxȐ*OcNs0ncGIUl!a;SQj/곏D~ a9Kx-Z"jHP[TOMiYI aV"iVrsrk-ECg)hNB$d?y,?@s'r֨^O3.=΀³IDk>,=f>dR'4YJDQbf%6$ q!8iʒ)ʁDEPUqX"qX>:S*?i<8mr1 ۩jnm2۳.-mnü=ZI:.-dWf݉_?ACw{*?s[{AhpYB/{G<_OS+v _v@2Ou_sV mo`MH>v^k54IcK9J=A߷ DZ?* yn}b^^>:M1WcbJٕf!Ut}yw,(yg\8!Y " *ΐ{۞&"~:n_VMoѯͣVں-W]s՛lreq([X<]g\ysY5U7̎mޏF5n?(œ)g vRr5\MN% 4E3I!)^* Rz3 $Hh\>{c$q&^4vŒzzr$EEX4{놋E aXxJWP1>|0gL鹽a+qtr9P+)z,Ղ)g:0X/bl:bډUѣYA- >I!q8ءKi)؉|w]=L5x֝*<\=4~X)f23PJGc; c ͻPz':_ty6_SV˅x۩+V҇yJ֚'<]A Z+*'ñ-b GƃyS4芒?Vm$fIU#jbvNkTvlJ(~T^]Oeup&nW0>:-'!oU T7Ɛ3k20c@EߞTwߤs7NTJ曐4\6'Q2#'ĸá%l m1H2x$x.x1*qyF2Mk_P vMpfQ %΁;!8"i]p蜵(C3V(0+hW^!.cGܺ$K7]BبL ezH ٬ Y7W|uuX؉;SiF#Yܩ *+wP 2A+F PNDV: h SMJfhCfdIa5NiGzqznU`<Ьj-I^W_N("e&B%+*-bt!sZ՜y_YEϖJpLeqQ:2fE~|0LtpvvVG>JT/9;d2(^eԓڮыOx֘i?V(H*N Ob hP6uzதi~ki͵8LԹnPP+hG" \pD j3I8+f7ֻFČ|2[}Ǎmھr= rଳ6I'ؾ/ע3_bBԶiY_Fi{z\.ۀ0Ȇf`cL+;Vk1%W}j[AJ@jI!tYV pW>*Qt n^ТswyZ)~^[/8u|Tpn~q{1fg;:,ΗҦmD>NzYn|qp]ĔE0\ŖntkJmHq'qƺeW2Y;b#E7f ׌ zV>Wi κ+w T?<ۓ.IPk,8ng`l|f PV썅m 2@F& %%JT_cɇyRd $*O WΞ`kG3+~rhX&mQ%DZ\~-En]A[EN熠S z:pf/J$"h ~ :4PDHA1zW8VѭW}')а˦JFn78?zAczT\U(&m{դ Wfvc4^0xh\'N,>1W9OJHNgIyCFO6( ^km!R|kX-k}OkNAt.KDmø^Yb+PUR: ; sYNleMBv!ҲO-Y7sEt6ԭGǦWW}~y7S7=Knv1՛pf~P7;B{P4n@y! ;zs5?6dRޏu' L+cb1Jdf'@-/֪U֒NvG)D ZSB`LVE7&#JȡX#mvjw,~L?db:͡f=xnXc(cȖmSG~+éuAC|Ns^ zLQHRM.,K2f 5ƫʕcGoêX^8VI׫MR 4o8w\H hK̿!!]@1+~0GP Sv.s\ᨡWuZ,_DhN ξ)L c[i5=U;}0K-V@ժbpuʭ|@^!WKG6K*My "Ccf \Qh3N+]xO{E/k1PG0O(f-n04oc`?롅Q7"1nj'Ղ+i8Q1ƿ n `Ԅhu+ (FG~\5C -w[h 5a#Ś!ES u*(?Z7'^,mYSug¡*D#1ɩkNyͽʛcNqbn.C,Tg\3l%pxr{ X|sSé*,G m'a9]&[pjչӥ(kՓ ÇG}lI0WCm+ CW h׏ MJl.Uج3gɃZXj>rwpudzG[)(ea{Ͱ $*eSHM[\{=??8[2cßƻ6 let ek&0dDž?:&kn|3Kd˼^eFےHGC|fe[~V6} %fw96ʺUCE]6QtXM7~ς;{!gUԦL j+sUHpWz,PmM-#eUnfGȹaVVnV檪 P쨳-&ٖ=7'+0ĦPi]yfojfǜ"50]8! mI\Ot͈ݳߝsU|AnnE=BӺ~qL,_nZ~Rܪ.7"k~ĵ1/_!*yFYA^P)%}{;%$6z}x !BWt 4ŵ^ !L1E8<7F9'w?"@~د5ֽ޿b,D ]{;^Fh|(ۢ4/IJtvP[o 36ߑ}cǻSDKH7FGF3e&b#PΛPFiG’ Dl0R4̆Bn?ިx fZk`D3.F n~0n?G]PbHmPWլ0^)cxcٶr8ⴿO C~SU\@",3^1`79V Bs_R3UY[.Lh_s wu\zs&¡# k]GV+ḲA~89qNhOь){ ݺAPYA.Q+MōG6Z x\nȒm?EG@2VK,d'q&> f Ȗ1ErHʊ1'M=쮾jAx̵=?Ue:M/G?, ?ufQǿYْ =Kt?˪ $wo~jl9=ȇyU٘c5v@B2ץRJ]\ġVerdՂƦ*.ճW2a<É*W 8]U~H-4JJ_R!:&bKb kKt^ RS 8C[>Gݖaǩ}Z;J/Sg EljzB~^ijJi%DPeLoR9",j=$T e$l̄A0 EQP ojиZ1+}BEE,췰2s6~z,lE$~?VVyl.⋠lzY ~ͨ9q#Vqu9b J gf4EPXe@ ""jIy<(br&Gs̊ hwOR>cà$<>1"*R\5_~:z8rlFx_< j]woO 3m467u!L$A1(5%)ÐR;`EFZƢ=?zuR8ח483~o]wְ{wKx1UV*?xʣy8"M-gk6̮fY> TV,tgh'PLvnFY >p׺,)VO-: D|d:Q#\FT xT;O#^5zTA2;-rYFVdԏz jZ:GƺRWȚ/_{ȳ$3C9*CQ??347whPa=_iZKnVKe{#VYXaT0.DMĤ)TU.(H F:5,'ePꓺ_:ҁX`B}V"UWƉe)q.VU,O:}[x]U~j** dsV~Y|0^$1F4[Ė;/"K&S"7_-iE( )t>˜rY4]MTQr(^ĺ+ ЬZr7-Bb*{AQv(za;u̷a"茴GBRͨiR}3@& "d$PSi~DY̐p &{$50XZ`:[%Zg4K##Bɕ{ xtX̭%Vd|Ϝ"1bIKuQU7pD"Z 4JC#..Oj:kק¬?"NY[M`Ov:Q8P/Ѓ{zORAҚA_3^$WTmB0H_ډGc1a*O\oXwgM:H&_+ىM$𽮪D#ke)E ֢GV!|!ŵXF6_=K@>TޡW-[Jgrk1)؆9G4uDEs.< 8;IJ\ 86IQ_(dPOg3KV@eYI K:ͦބ%D!Ј011ˠ|WYԒ=-c|-(i^2k"iK뷤.'dJ+i 0'~]K%;2V"(p/uH'&T>#f7 HǁFOW.*'1[WV@{DP ɊɠAx>',Fhc#W=Xu{&H \ ],9i8SHj"~n P1eug# ML4h3p&h62fv T RONق+FD7C &AD9j"Eصr;LQvQirXCQ9 a㙁rbh\Jj2+ X,J,(&{M޷ދ82h^FqZ·wN0VѶh2%b&bZ)^u|{fYֳ{.gv`rnr}=Uix֌~Hr%k@4Pcr[mލ:><L+1!r UBќ}k#XY(/=1{jW_HE5=`_\icz(ġ y( sW ?ӌXKܘ ҉_BDє$NnT@@:Kǀ|hhE6LR礙ZffN9$Gm(dc0XV[j܎-'J˜IlϰrJ_UzBЍ /oG6UG>rL\2L˘ސs]lhjwg-lݫ!DYmw+ GYDu{Ҳ"0 M%޳}6qH!b>I<.Ӹ68AD5&YHz\A8>Nn'XkeM%|⠅-1gCg, PG1 @˜ я$i)RCL H6$l(S:$G'")|fK<"/4j$9dݜN}t[jjO .Eƈ){'\HG[xb~.+:d5S⵫<%"҇KxUxؕ C&X]NmS'voα/|pFƶbEGk AEPڙU ddYO[8Z̵yьh`*hڍ_|c8d.f> og vfDtpg6 lXhf,DӠba~ Y#QQ&pL1W8O](N9X]\ FIY^6v:ÏMNFƝm./9jyT֋a\P -uRUCed<"EѠ z I.k??6&LIXLlrE}LA^H!Re ּW)0!(1xeS #E~F%./FٹNESTmٞaP=*9$$UxELF!abηqd1terGz-W /xJ ꜏8GOff6V.Cpg=i,G52ˁXk+@) zkr J7!!I2q U-D'v#ZU$[;h#.tP UwV<3^krv|/K -['WPgGNE_Γ8XG: HTѮz [,y9lmޑ`4UṡpMzbN<, 5ޣ4>z`сBG` I`wǧTi/zjz\JAzi8I"wrYP& @?ɋu;Jd*dByr52qQH'F. ~d7shG#8~9u;7{0}ǍZ03O馽ypadL Gh6vjuJ6Fի4wXT3KjRgٴ/K),$ӫ7Z[{}.v'fU_mjd^TtUpz 3:lRF[h. vA,;ϭJ+ݬ-$*&Pd 00|M6d\gE2GUh)Zq* ?*{әlis6o8:Klp]h3MbLcY۳`)wk>G+,Nđp"%eWeJ ={ q\;PN7 #,r M{c ,AOQ0lU)Kzs'+kךLhYUXD¨]nԪpvH^*hFJ.ސ@k쮫5(JoTy6ݱ쥜 xmc*Ig͞x*[L2֛SܨGN!me8͊Δ?b\h殪Kh N=|HS3QU\ʊ-IǘUmPUVk o.qe≮wHx[(S_RYOvWq `X8GEKХ?ayWk;2%mz{:5iݐP_$Z2$Ŭ 2i~8|].t-; xdk~4Cy I V+uEG΅Q㇏2| fޅs]؄<0de'b#^?MёY# j lvd,d )D~XGmfƍՄm8]PBRp)j,'lQw]K|^Op! ͖S:Y+-Mi'b&P̎1</e.!&N2ۯzW.d^{Oy~A( 9+Q4wQsŷp)?<c-g8ӷoDuK8#[؃ZAXdey#\WB|WG>5%&Ȑc':\ddJ/^p\.bA^9@-*fA%DɢQwqP4n,@M/q+d>Bqj=Tג .. >^2djo-oURi]q$3iLԊLΏƽeVi\q9܈Cli{mG0Ғgq5SA3s`">c;D(ow9q(1i{P|霧 -#AK1Dq:9#!y&pM$N#\]-*ǸF}u CIFŪUS r^tƣN!'3B2A8~ tʱd:`4]by,vźz|9| `dڑC,8bGz-& u݀f`H6?y]ƈs=K!Kgn| Ge|/9[ԤkhyD6$3)gdGDl5_/5ȹw*d,WWoJ/_h1oqǫR {$ },iBB77F;#B$ή//O|:Մ?Nﯯ2$,qkvTT\Eŀ߫"P.%fM-w͵!^%#*Yp <\G2k`BE]aHpeC\#T1͹u8?YW9jGVkiZ!!B+ptݢ"c2\x@#8KK3 %lND C՚Ɖ]pDɨ`9)mO%y&{Rdީn?v"t׸3жiO!=G{ŰmZ&k4>ؕX @'0\S6h#0zݟ P }Ml[Qƚ!\X@~zSAvVk+ t!rv| XbLi[s5ho o[{ /C1pYlQCȽc>mcʓsʸ3\|c7r<;,(! +3$YIS=$]]V2[{%@*S;1$L߭)ZY] Fё85,s6i2Z?(+B +WJdBZ)1'0!KqUB&[To,tս&r[K56*Tt*uGl-UA[ 4 tP )B 1S眈5rIwPDHB)uYbהNdtܤU\6|j jʜ6%-|DR- ,mU>&`Onc<X) FA+AkL,tSa Jɣ0s'bUX(Hο:NCP=ҥ嫏u=3MͶN.BյGqp kL68sɱ ?+Yۅ,Y*^|w,J]Aܺ. 29χ DT@1&a'r+dt-RR m+,ۈ,IP[x 0EyT=#Ѝ?}钬=H7dO6aR̶Kl+!g0`zohf S&Cf&2!xڞ_(o`XUxq6!λ }g 3eZWӝA6z'KE6~K=aԇj(,"IU1׵uS1Oհ̨I}oɛB[:2#)+*Cfg<>,WU /CS< pc牭A<V0|K?x& M6ΈX7Y09.qQIU#mKMԄo,Z+2ke U@UP<5ʆ1c A^bAB䣍D9SZ]`/\{۝WBպ) e6uV),UdeJYz  K6B$?Dtyx(\xsP%&]`C!P)SCޠ-!܀Sfv]]4WeC 6v^. AZ}̦\WQrWu?\s8訰&Z*zא B7)r8rPf>M  {Skܲr+UZ&rQ"Tm+rO$ertTntaYڍh񖗂wa(TDB&Kt\G Z,J{C< zoE[9{^Et ;(wM e ֙ùrn:7Q u$qI~*NS\D 8cE Sz<|nqM %s>h,ꍖ!-~NqVSk]颸\#i ůOO>N+j,yYL7)"@bAQvm@QyrGFu+Z>&|T}Gʵl0=->>(KF:&Iu;-{}~? DZƶ!E Dy]1C}nr`:P·]"g2[qW$%X? s=0ǎrsIE;K0(;Լ[j܍#K %@ P]~,lMQB?T/B<;JXDE#4?t4%v[n}=V c\Gm7e}u,( QtJ0"gǕʂTN*:S9,G\_:ا]\op8p|7 C+TyȬC}:̈́<o\hw_V&7:c>-nqTo f '|iZ0`佡V9IS#,dV#餛lL3Y:囅!fg8{0y=MT[9|#VDsk"t+v{۝ m0U |P5S\nۣf,~>[ؽ6rbHM*j =MݡўΝG=ω*QDۡ㴇_3aXhڪ=7QD9>3r+)Ve\h:[y`3̳V*A/fXӅլ^돪/5ť[NtF3Va,6}G _x~1t&#=50xHF:Rmyoރ|:l;V7 I>6i\M8$0΁K3>)N3̪|5%ׯg8` ~悆F1F;4(K2)1IjNݫz5O(,IkWě![Kڶ:뫩;9}w7xz{~rW7W=fxL3L{54G詤荏WPA'eO W'jbhs E\ g *_6u3f-)rԥYc2F('8Sx(i?v?>Tt=OOV#h&DUT?N8Ύ~٬# h;X|x31̂d3wo[wΝ-&̰}lK̸jsC|:[twX4C1[Cy "tCf d$oyCF>d@oԉoU{zE%7H[^f$IX٤CB=Ҁ}HIނ]i_)7T܌rXHF*KmJRVM ES^,*GC/E)mx^^[ۼJKV~ksWbBFtt<gwl|~,qȂٿiLttBU *L^/ m#MP T.7K[B*@ p"@@V܇'V~oWy"F$|~Hv7]q9Vz񀕷8ѿ\R*"\R:h1?3X_v.MP$s',`޳ٸDpkb7xY:%0j-OR8 Xh<KQr`(Ҿbi^ⴕӌ&+Q^[7 ۙGO%9uۅfjeU9W<`Wys(JNqٰă:8eW&Uv^*k*UxLLIŃ y-Gn-za8!D fImf@4Aek\M!g13B2]E +x~:g y =8O꙯3dz&ߩq A~QIf@UJ?\!dІL.5I>ÖVڀ܊mVwv6>#v1cIb[3RF+CbƺZyRS;s*S61Ϫnd$7hIW1Ge,U7`40dE(c:IP=+e -O"0N /:k.ճcP O݄IE1@KHKxpKn;NV*0TR5z+?2A!A֥wK3U 9U-th6NRsqs)i:tx ÐѠý߰3[uḿE2qKmaq89nmb^V9/oq/-LE-ԒMg }f"h5Ѝedkv Y)֡.f0Z6P|x 膋;Qꨮ)D*jI0igx1;FRbU)$!ens ׉@(l{hbhXARkg?Hf'tTv + 4+bISZtauȭ:*'P筜w UU9L ϐKLI &5})}IҟOP=[>y_4ɩ~+G/INbe+{_[>Ҟ?8x@foKUn k][t@myv:݇j054]y@yX腧Hb5ڑ3׻p?5~ZK>I79jPy#Z,^#,hF:*%ʨDY( 3 &y8.\%0!c43^`?H.vjjijM0y Y (`?h 5q%_ULk'bW@v "XE{Bm\&]}tD Fq{o#?ʈUwo|ax340031QMKgة~vϫwZީ袂xVn6m?M@1S84M j# ZFl"2TII)qZ"}QV>15mŕt$klIo$^|?:kIlʵr v0rJ3]E.A)Հ?줇ku)`>ݏhH#* NtC(!bWםU>$ުN_\mϛ j.%@i+zi͖,{L/# ?:j©JCP{nbʿ 2t=%;Dt@K}: ua4FN1d <0z{@r1cmL;%@vGCA;7o*9ÃnJA@wb+Ė)JP߉jkyW@ɋPZ#>Bgk lƘۊv,Iհff,Rsd9dTY{zeHtVw苽&3}mgi,j-%Tq9vjQ"璴AЊu` 4 bI3XfK'uj3[S ;ţ=G=WUm4IR-LmTTbmL-Uu۩2鮭TmN2S\dɂT0ٶNL>ʩ$Yjkm!)(h )6W9&W|D; pQmYy ]Pe5))\aiej5 <fn䅆=%|FţJ'X:+Glݨh56ebS(>E?J7y~0'Ъ=awڅGGhޖMG[\妌7Qߨ/yyu.eMt_I}8{4xtڗ#`dx?$&5vxu["">~Hn [Kn!>R3mPV80/qC7sZe7f]R}3~mDpFH<7)#(6$ܳ`f@yΘeB1dhג5$~$zYDIլ d>8G6>+o%$Ck:03?K "d#vq4Q5U2uy ыT ]ܖ"xf2<g$\?34TefQ]쒅)43b(afn81&rdDpG1Dgs ɈGSz'\`T0f M)Aa1?6H-̈́S3'e3fpq7N,TbpOx秀{ 7RA"X>_ aQ)V4%P1x@pUxTj[ aX=0 0٥mZ@bcXg: w`'\1V6V D_*\p*[oVbx<#D0Vg1bE8ʖgp xPAU}z}} Q:Qra${ȆMQaە=cܖ%ʌYda-ʹ}[2 2EbsZuXaAV5V(Bq:$HV鯳Z])o#ukPVSS$#qsɟ~RJ W@ʱdxK˘ߴ5$ϯ@`(ԹyX-1l%Spgn<-N/}\wXwMKʇ&@]] [KQt5R=׭0ܪ=IPv05lc{ hx-H@+$lS+DBBb#{ F(IePNJєFO<+⨶21CL)%TQ $ZwIOD] ȡ?Q5֋.F}a`SQ:mk b!*U6y(aCLB mfO#vO"Gۢ.nxԿdxI˃ 1|~}&1mddN:9ͰL4dճHƓ)Ǻ[(f~-OZCxN,£(m ļ"ך\ Ì GhOߎ;5UˈIg8˹NbqQw.&\1>46h74Fp&r芐?)O#Qcz˚FO88C6! 9 L4Ź6I,'# 4׮DD*׭#[{qƿ(FZGnB"f$i5:ŇK0M% s\햫X[v8tQ9P2+sfG^:}ya voAJ*}l.:8*h£ C1ۜUh1F'Č JF^2{.C}P)c)X4`!Lro\{dHK$ AfGL{1kӴ'n;0l7|j|J<.`AHA˹uש:fXP*rD,*fG(SuX8֍FS {A]w/*ȝhˍtTƪ1zWqoe)8s&eݯ·ѵWE۫-sH[vqתRH,]=ӣ7W 8W4Q/ù{{%O`cg vVb9DQfSrn NMyٻ ({՚!^ V)`pFg'=ܭ^m!#Hھ!)AxkWx(package zip_test import ( "context" "net/http/httptest" "sort" "testing" "github.com/zap-proto/zip" ) type rootIn struct{} type rootOut struct { OK bool `json:"ok"` } type coll struct{} // List returns the collection. func (coll) List(context.Context, *rootIn) (*rootOut, error) { return &rootOut{OK: true}, nil } // Add adds to it. func (coll) Add(context.Context, *rootIn) (*rootOut, error) { return &rootOut{OK: true}, nil } // AN EMPTY LEAF IS THE PREFIX ITSELF. `g.Get("", h)` declares the collection // root at the group's own address; only an explicit "/" asks for the trailing // slash. // // Serving was never the problem — both spellings answer either way. The // DECLARED pattern is what the document, the op key and cmd/zipdoc publish, and // a group that could not spell its own root is why a service declared that route // at an absolute path on the subsystem root instead, which put it outside the // middleware of the group it belonged to. func TestGroup_AnEmptyLeafIsTheCollectionRoot(t *testing.T) { app := zip.New(zip.Config{AppName: "coll", DisableStartupMessage: true}) g := app.Group("/v1/function") g.Get("", coll{}.List) g.Post("/", coll{}.Add) var declared []string for _, r := range app.Routes() { declared = append(declared, r.Method+" "+r.Pattern) } sort.Strings(declared) // Both spellings canonicalise to the same address; they differ only by verb. want := []string{"GET /v1/function", "POST /v1/function"} if len(declared) != 2 || declared[0] != want[0] || declared[1] != want[1] { t.Errorf("declared %v, want %v", declared, want) } // And it still answers, at the address it now declares. for _, addr := range []string{"/v1/function", "/v1/function/"} { resp, err := app.Test(httptest.NewRequest("GET", addr, nil)) if err != nil { t.Fatalf("%s: %v", addr, err) } _ = resp.Body.Close() if resp.StatusCode != 200 { t.Errorf("GET %s = %d, want 200", addr, resp.StatusCode) } } } // The root app is unaffected: with no prefix there is nothing for an empty leaf // to be, so it stays the root. func TestGroup_AnEmptyLeafAtTheRootIsStillTheRoot(t *testing.T) { app := zip.New(zip.Config{AppName: "coll", DisableStartupMessage: true}) app.Get("", coll{}.List) for _, r := range app.Routes() { if r.Pattern != "/" { t.Errorf("declared %q, want /", r.Pattern) } } } type ingestIn struct { Project string `json:"project"` } type ingest struct{} // Envelope accepts a Sentry envelope for one project. func (ingest) Envelope(ctx context.Context, _ *ingestIn) (*rootOut, error) { seenPattern, _ := zip.OpOf(ctx) seenAddr, _ := zip.AddressOf(ctx) ingestPattern, ingestAddr = seenPattern.Path, seenAddr return &rootOut{OK: true}, nil } var ingestPattern, ingestAddr string // EVERY READER OF AN ADDRESS AGREES ON HOW IT IS SPELLED. // // A pattern written with a trailing slash — which the Sentry-compatible ingest // addresses are, deliberately — is canonicalised once, so the route table, the // document, the operation a handler reads and the concrete address it forwards // to are all the same string. A service that resolves its runtime handler BY // NAME from Template(pattern) is what makes this load-bearing: if registration // trimmed and the lookup did not, every ingest call would refuse. func TestGroup_EveryReaderSpellsTheAddressTheSameWay(t *testing.T) { app := zip.New(zip.Config{AppName: "ingest", DisableStartupMessage: true}) app.Group("/v1/event/:project").Post("/envelope/", ingest{}.Envelope) const want = "/v1/event/:project/envelope" routes := app.Routes() if len(routes) != 1 || routes[0].Pattern != want { t.Fatalf("Routes() = %+v, want one at %q", routes, want) } ops := app.Manifest().Ops if len(ops) != 1 || ops[0].Path != want { t.Fatalf("registry = %+v, want one at %q", ops, want) } if got := zip.Template(want); got != "/v1/event/{project}/envelope" { t.Errorf("Template = %q; the document's spelling of the same address", got) } // And the request serves under BOTH spellings, reporting one. for _, addr := range []string{"/v1/event/abc/envelope", "/v1/event/abc/envelope/"} { ingestPattern, ingestAddr = "", "" resp, err := app.Test(httptest.NewRequest("POST", addr, nil)) if err != nil { t.Fatalf("%s: %v", addr, err) } _ = resp.Body.Close() if resp.StatusCode != 200 { t.Errorf("POST %s = %d, want 200", addr, resp.StatusCode) continue } if ingestPattern != want { t.Errorf("POST %s: OpOf reported %q, want %q", addr, ingestPattern, want) } if ingestAddr != "/v1/event/abc/envelope" { t.Errorf("POST %s: AddressOf reported %q", addr, ingestAddr) } } } "≯ xru↙̒Lȳhe-C$H""%k! }lVyXwٵ&Gq[@$pOMk+QdSؿkxVyV&<妑oZ&$?01Oe>Ϥ0ludQ,aZ E=(اGdE4Ul$dcmh+ThϊTpNpa 7)e:-l<2 Q_5Iγi(ʰ^f:X-kB1Ây^h\uvJNQ Q:m>n 3`g?nrjBT`8CA XiНߊ+u^Hƒ &F{ p:3YkQNj]M,&\b!6MUJ^'E`? RrYB2;KH'c&Ÿ VcdUKx֛!l}?c|wsv%Aqc{uYgOr8QP2iPHƖsՔ]rDͶ]hu9eIIwȲӂmUF1iFɻ z*)aᲚdmn6lZ"#;(L 0EWa4rY9w@  9]Op+V1L~12h Bau:kal14^@[pQ:ɘչd` g 58aXDQhoLE* K<V Y$ *O^K;ϖŤ %ބ[L9iPY8CNYcZMW=MwGMdKΖxg[wWMI{6Y3aVB6 8+fWp!,f̞-1 B;(EOH$zƌ/7yId)5)CϠӘxBFv靹qהWkηCsW #ָ.b"ܢ6>S!9k |K\|٦=fh{>{A7 9ƧXT^ F{D\?c 7mj$Z/{Wm~{ı=Kdݵq1dMEi=`"oJ&赳;&}1B3xCwc4$qۮ@H) ;mxCRD,ef)slNӏe8Z"7W} |nM n8^/v8xY] fKM]7Yihn5[U=/h/2*zGiJB/Nx[U#ACח$bMnK 1rZ =;R"ؔ'*d$xj̥uT{XX,sFh~Z/2z܈L($hD( 4㨓 DJV7>0w)!ߴyY -@MH3 `ǝJn i]0RIg -\'֘mv?]P]Dtw>q4e/18WAi tnVΕS#bFEhGa]_9 n1˵=6*LHӬN 4_~cmLodKqy]WbO ;狝C،V(M6r.5V4ѤeO3n#M,Oj؋Q{=X6wy¡etTa!JQe3BND{t]ve)/vsK\Jy=XFL]Ghd7Sd=)ISOPM0E;xR1acBRrFPF)zZzvͮTppI*JV5:NGcLy:ypM7i,ZwQah@6: U|Zd6yaֈJV6'[ $廛XRgeuvIMbya4$- mOT//l&n6w{Դz~&qs燯DhnXUz&R3؂hS'oр+6xUx6-dƘ)bUK }4aкN,`6ʃRTEC"gs$G-_+dhSޜHdO8`L5{K塖Kak{NN3I3l4%̚PځH UV {í4%g u բvA[߿yΕ(93&ύ0S8T[$`?%Fm>`}ʔ q7Zg#撞%G$^UPL (! E&!]-Hή~HMg1Iۏ3ZE  a(4唋Lhe#)*Ok[Z 쐔PZErTI7S+Xfn>W (Ρ}͍- J ou#(c@mkrte+Z"DUmۉC *aam2T}Ve|5ȯ='="&(jzfSYEށQ\}GܪZSsPGv=c+p5!G(.-%l­r|pPc_F`(%I=D#S0IfaS%VbG:[~po˨Y> U[1!(pϜ<U58}urb)=UbCE{edm"hrE(W~V=9n;_Gtޯ%ѰBN cuZ4-y 4zv:F5[PlHN6rksVlV*\nAzn%#ԠN_z:B}=UchpL8/'k !8ʙ2M44)mm)ұbם] Dl94> (V Y%1| El:粈 ur_Տ?< =! pe⧤mEDzn:(ľ*@g$~ rf-?٘({Q#8>R͟QΈ .g( w"W3 i&Qzբ}Zk(hCX]_ط.}1)TaQs@P:cƁ-'rGCE\-uNRn{GGhiT*U[zC&x;^qmEUC ;?Bf?tӷ!\MKS5>U-OJ+MXLl-N!yT{fCcml4$4 d.Y}EdlM&VD-r`jjYb4$i^)XCDG ZM$C3`)YT2{+Wtl 4lm-5schrƧ5ov}~sGu;>x%G%G;a^1#"o,wOnd>tD8p?k#d0F%Lڮf zv7tCgsXiʾsTv̧,jl6X:RI_\Z},MV bqc lL gd$a? ^^,eEbMvM,m" wWoXe8'JBO<,JoE2LAY_bt|Ȼ?= dos8:tZ~>~}Vh9jSC^>Ij.> y{f?s?Ӕhz5 v2:%)Ehb Ko^pU3?ѱP bPav;!N%#n/I_]N{)tx gh>ld۸`LНAn5`{Kg O|)S܊BMcGlܣ FtuJP3 G4VEzDW `'ؚsEP2$ 3\ >1aM+71nj#ͶdhɄ:ϯ) QNhŐ jh;]OӨ(\yՐ _SØ&ˌdVgoua2`!UT΅ۗ) (G}!CBj.ʅyæj% FA% ~EI{{ٝ) r?3}xq?˿dțEL!vfq-$1_iԦ#miZ85J$tBJN3C.rwGn1z`WC=:1$Kr7`!ZLgʦ2+)ZPF=sfHIAmגt +5^zKtN9<&h3v+pg\G<:F7qµi5z}ڎ-|NU~[$g a3-ԡF>R;A7߼iKַS=Ś/a4+1<]8-XERXǡ(I$V[e%oR)(gzZWD؈|9jՆJŕ߯p߶Mblq$c ^^S,옆)@52H- 6g^񮋿N=oiZkլWPp_mzCvkGI5@ ^V4|iUH4|ޜx@t dc>ط1߄,[x_ɛK(Ə3&FE7o-*#|oU707К2Ly2jM†x:T)āJ=Y,jmݧĞ$ǃr*aHZ/u5#9%\-|W:hWyvo0h_d$3տ)'Z4Ãk-\J*s`\͝mDƞUx5\lF&j6h!!˥m=ƠhpE ru: n:(jP{gl ;hG$2py\}`L E4Ch)_8H_@Fg"^&Iq+BƿvO|"Y k5K"*Xn,78Z!C+%@]h11/}˶Fʌ~M*_ՔMC)Fffq^G=ӛ2/wh5q& 'mÄH_|k\\Șa? cef )1Kr<(4\.m6U*㙨0n4q&ly̶CF3`u,ZȥIOtLO*dCA"wHęGz6ƴ9j[k+j]c#P-63< PV A6u``?7#pAqE$6 "OtԆi+?HA:v+4c">qа:21LK%j(G=ul8w03wq/eÇvE/H7x( 3*App&3It returns the concrete [Group]. There is no router interface to implement // and no decorator to keep decorated: a subsystem is handed a group bounded at // its own prefix, with no method that reaches above it, so what a host gives // out is exactly what it gets back.G;Ki x=AN1 EדS|VL'`PUz:Sr*@;T}1}5ZCU. H ;gARjlK;|e`ʆ(`yӛۜoIz[gͅ3-JV)>͈{<(GHa_h*{x/aiO^:4 Ma0j)^#x]Q0 <| wGBB+m#R'r\h%>/KpZ*$+NO!Q*\Xr)O ,Id7].EaG\a1pА|⢲zM@s63HJ'ZR5`C7'ڶLX $t6pk!xpw4݈!V?FΨbN EQll3-dF r=u`Vxd:CFbOɞ$@([C73{v1d=vm^㾕{-I߹qep[:q;qc^|c`N4x}rƖo)0r6Ӵɞ0lsƖ\}$$@@ъUUW+eN;;0vhѯa'; {gyEgJ=KmN5,+ph|6>> 4]tn-ptZqI;@cي5:9<(n|0pW0dz5” '#v#@2%CL^& ㄠguKk5~ 4ΒL^ZhbUt|슷 }^@޺n hL :==x;GC:~~҄NG{EsG(~W?8>A?F?eIwK t;iRVcU=QYgXކSWQGU#! _7 S %f80] ~xE&f 0(Px"Zij{"L/,L g|\: B#y;9>;aQ(aAG؎@6N*BB`d]bО& mAB0?[i*uV&lI_FFH,$q/,D<΁$EtV4pAN.\X`McF{l☎&?Llo"3#)L&\S5XV8lSZ3 kWPL["fو@;Xq N_C'hAˍ-hv)n 35`t5//q;.4=չ{p>:M1zd%!7#7 J_j/cUzj C0SB--Iv&?4gyɣh2N<]J'Gts[IVb]Ûp V:'l}dAO?:khM4dsF*ޠdOAAnwtf-={oLfڬKF7"ɈD .\R>Qܷ2'`1}X85i: q4[q466J7&0fi[;pNRD@6n9YEZ!%RqK7$H8~Ahm0"Zuswgo̸qs縻b@۵qč~i+Q3߯*_3/vPAjv{:!B^T7Zq C@Vs~\܏7"}E'=EI!6#(T:h3uR($aU/"XUEC'~i|y5"IT"m$>@s! =EgL!=n4]B\ր*QRk.pa@]&a)$P'<'ʂD偙Q/3(v̫V3jqz >QӜJV}yB_k`)Mvri~'+)^/Bֵ_\[-men/lME~G^xJ_-X.Qv{Ղ4c~Ss7\QϑEmxO ƌhi1<ɺԆ^OϚO0 }\ fӥ0y[t|&]IFL)%$F+p(@|M܋PbfPk Oo0`v'Ҽ˜u\*v&WMW"&9)V@'1h HAXf)h_zNKjW6z3&a~^ "(т!NZ"EF !6imTk6d0^ ӄ/7˄'i)Dco<~΀H :1~퉊(³qyQT(@BXWIjCl0׀X>$twYߊ]YAYf {LsӈbKILm@k8u A`׵AR E0 AYRnaS$J{z[*CdMǼ@?͉a~$,{ ֪? !C tm:{EgD"N[.BSM̲OS; ~ti$&j/X)4"3vRjexDOԏ^^ H$R}2g'O"qN`(tɂZMIq`KۡBU6%. L#IfWD9RqS^PkjefV@1@tTg$쬪GyuilaOŬ$LSC lb[2mzxTNϓ-[<IJMlG_1RrO<LT#' AQYBezMd$k4^Z?lvyb (u6]S)ўAC3nL3r M=2C-ԌC MD:sh%Y,a' L}nЖض)6# 2!_*f6OX6h$D4BI)}=|ROMM03)0u5~ɰ~6<|2OWZ50)F lxNδ 03;P YհAdPӫu+9 /mYRM< NսND$F㣳ãSv<n5x>#_'GN@c*~Caуz3"N$.]- O~Б@&S H@ vaw[Ko;nGTH|r~}(V@Ka[B|N D9oBBZ8K;Q`&⇖@1 OlG]@Ws׮qyb%x)0hהZmT &ljpg KsU1o||4zE! ~4`Zd=:34x }%mh+MX,Dd">{ K5vrCDbL Io+a\0~jtXT{’ZGxW%"+&BsB]IpLsDV[<?ػS P;Yz:) ?dɖ C_l\{Hz[≷)Eߏ~y`|tr ! /jfs!6c@"H~@`*ÞE{݉F.?;! ~!92ڋhR^ls0-f9zJ́l׆)qf8THx8#)` #V KC WZA.a14Қ#8BNߞ<$דT"/'8d7&q iZqy"Їjs4_%pcx$(E!}ܔx L!7'Gxz <vF9غ`.-IY8(.JZF P$-5ʜG@o]I ::lq0 -0Mu#2MNU@Eݫ nwsGjs.K׾"{'5mAmG\nhbc؟>?m;xI:h ߒc]M*6]Y5ѧ.o[to͑^7Gz Ԡ(' sUHqׇ`j) SV!8k F E07rM \'Xx]1'AI (rLbl䲔Mio-S4.ӕv{EɈ_ݥYdWXl+68̣S&w/My͒] 1PΨ=x ֝mR[NҒ`S( ".t<;)uuj~FYj۴E?_O~ 6P8*Ә:l;贴8$[8{ ÈCK͌k%љW* [w2͆M:!vghs bE]Y<Vq 6)дX@fPH|[.7G 6I@M~=;S-vNquePcXlx]2Mdc:5hS{0mԣ:W$LiK:M:^۶tPo€=Hl"kjGKVLEQ izm*\FWϝN!@Mu26yӎch`o~n-m_C3z78*!wMֹR Gn|ni2MoqWxZ`v08N2ù÷b. ko|e憎|4-Y-)-WU'#~"_X-3iʶ}6[(7uz]QMahđ¬YCЫQmGrp!Wr^d?eR[5ۘckB;m>Jcn] Hh[ϸWf-uMOȧ.Gx5"9'ɒiy>rU?PAx f/3~=?# &]{eȶ̃Hmeژ!9xv>86{%뇹PCG ͂Y)u=`7wVQl2͐:%q #$ r-Sph:VVgqO;XnW-Ru@fFq4a;5WU"\8B+2FoℍUYdfp> !FLXur vinp 33s]6[v"&7'SR5/S+5zKdW68-T<*tezD<>KȈXڦ,/|yÞo6lقոϡ;97 Ou[!m,C*_䏈eɳYPpHn=4=ԹUD` dL &a9{fJ/$)]4'p$3yD M@<ЬVw ˏEaeQ.. 5aOg/!aCa o*[`4.+RgDRb~b[ e.;M](],8]o*٭{x"GĂ {oEn|,j\ad"|QIwip(q—hV!_WpG.O_jhٶ}gN9(*gY ~}do\u 7qd48 7yv(0Ը Ax!MsZ Sr O'Y/΂ól^gVpFÝn"ʳap @/ v n0>}٣a-+ʩx t]0*{(6qVr^=޴ +;6;uo,X d ,(%ű$0WԬ/m#nwKĸɬ`ԮKlo0kT\s"WIR4JBW$$|ML0XT/h=鴁 <֊fhNF$R-Ea"*/Cw7[bThY[bݨ'ɯ A?Sii?j!n\T;{ծhEɉ2K8\Q'֑ 4HHiΕdDbtL" b\Xse]Y@R)8"p4gsoajJTY~-گ%e=U*JdVt3/.6"ܬ(,hUudggo\Ux/+tf4/") @c!}<{q2*XHMaV%K@RhN`Y :;ww;FoU۔'lH*WA>vX̽U-~y:|G`. s!1\ND BGA/-r{ ^w>4þϑd/:N2IbJL%!t†`Ê,S_$En݊uPt{Xu{ 9s7J"gYĴ*a8#Eg1Ƴp!O^۲4/J*M.8Bҍ`*8q9[*u۸*o65NoY ȹ1sThabZ5{/8ڔi>.j2ܺlx-:|IhLCIB$Z5"@q*$+PW)|ͦ0{t|&\ZLm!D3PFaZF'oQP._S?<(0tdKeӴ"֔uӡո)f{SnGkB??>9;K*tEVű\$|:2Ω't=2WHp q,Edy[m83/pRpDba,K˕pi^z!s!_ښ۸lC A*op Ó</CQ.5Zw#x}[Mזt\V;(dL9jT%|\E1LtGQ |l΂ Nڒ McSK51p$ <9i8my&6;sFJYߛ`C뱧ق=sMLka[n)b,wGٟ :?1SOmv^%/8\#a!FytbJbYVUЎk8rRN$㊍Q@io1{f}2D >8XbVXd}U5r#ZWe4?Yfb >Z F;Θ-nm[n0UdVoW`3Mxg.\/?֕K7sشy#X T>؇wB ?E}q{]_d?_.IBWHMAҟWPXE}ԁukjNSUk23k%Ij^LYLˡ!_}gR5 %; }u-opw";:f n'A9I],m엞&ۗğ*'_F_"@^=ϋODEU:dR!q BIX6Q "xa"_9`_39A5 J.:}#t̑VoCS [Be9"i7\:uBKI@0NzXXuֶZ>䒬(*Ty?*4"F'.Mvw1ёfgoC陧$ I:(8`rʁ@P/$:[ w*,T9LʅӫLLEeF`aa:_f6:STm-AЀd/YgŇ"jwlhN"`3d_ʑW;;Ư/z]\]Dԅs4.=qZ N !n16(V*}9`$ m-@pMվ:]6FLs ?K&v~ZI'}BIo-I\@ɿ_hVD0CbK$T35fkNjr}J}7>MW$?$f#+GB6%2UV]s.[/'J}-'f '|':;g'o_6o;ibEcv޶EZ{ #C0|Tt$UnI?dKvu;?I8' qW8\ZN04ׅ?vaB3nUbjjլqmoI?ѥwUIܔxw?2x hIk'-7/ +j+^Je;X^c M B:Z~[#֚-F5vMH,Xb0^D£n-6CMVҷAQupsߕef 5We"JV,rRZ)RjS'OԇCٱ J%KT J؉`jo(v~Q(|x4oroZr-yf uI۔Uq}c .nSmG|*^E qˑ7|G_ ;RE+"f3%aӫA]I$,4:Ic,=Rf0v9ic]\n N -F]~ZWR uSd;Eo)5xXq>OW7qT>E+6ݮ 19H+yJ'CH$ q|ʍWL^RW@N*;jd#WB}^J';xmrae-=,P&&Duk/cTnϼԮXg["&tc&x3:63V@e>QΡB)XQU%jZ$Fv_B1pr^aC'yeRY.p ܤhșAqy-EV̛֫OT7翜yښL**˚RgUIE 81[LQddh!B?b3B:bʱ ;'&0!Wؙy̡z3B@}NU= Q&DR,i9FSikOx/^I@;I[|ajc[@3'LLMz R _dFVh"Z[ɯ"]A$hpNLd,@NJaZ̧Fɽ kxT8,(rL^ ӮvU.9$p"թ8;LW廓+}E(2sb<8IVK9e.c" *x\^%c٭p|5Nޜ8aum}ɛ0 DvՄ*b`~a\O6٤JVzSdw%T%u )h6VLT4p ]{S]J6Xe j=*o^K03vo^'|w|TqM,5xQoƦm{`4qEyVs)AfjaJ CP|bxXcݣ5fPs a>7xpE Zl ݔMP٧,~4B7!ϓ*.DM7[P/H3n~CD&u7R}I9 iYz4I {=˖Yܷu֘,#+C{VᲷ;_jj~[P]'jw,ҦFRMXou\smVfWTLa\)奄2޵ɡ/^ʌ_1_nk1 7H LjcōH` TBgܔ{U>آӓnnsԂ@ ЗZI9S0%8?6+gj.c&'CT淤iY]9٭AHO}G4y7ʯfMVTN_X̖K^bܘ0ءcF(9?zlKE5Yx8~ho\rSxPׄ]zB}`vFj)HX88VOjRg#Y~F(e/?7$Q >=*5IGMZj 6O~H _!Nÿ~=}6:sjuzx ~4uz/Ԟb!,_6i7KutneB 4LRYJ]'@-9Cq垘5!dRHijQ4V =d[,?z\7 :_}oU7YtcTH.o 2X lsQC>094\,]϶:tf룼WtEwN8).H2Nfs@=X aߍ '}cq ҟ@$vt[!eYi*c 7)B^U=`u`>#cT!&=s@+tmH{G/W J[r ,E; {ܣr?w؆K {+<.HaEo*j8m .HnkvH}@ŧ^>*p Hk EA >&הy>F19nTIl{-i]=} &tNK5g ﳾ2%!ia̮nL'2տ hHҩ]0IE*kE3@ PY޻xɨ2mA!KQ_]lfu W7 _z{_:"0T5עr ~}nL36:iп[z Ew,18Wnev7kݲ?4*+;=/|uX̨k6kMRP 4mѯckV:j?\m o.SѾo :Oy~ݍ:8}Ɛ9 k@у).ڤKX*mCRSubm`Vؤ^]Oa67 ?IG' O3.$x Jpackage zip import ( "strings" "testing" ) // A host composes each plugin as its own definition and asks it for its routes // before composing it. Verify is how it learns whether that definition holds // together. Asking must not end the definition's life: Declaration panics when // the program does not compose, and Build installs a generation and freezes — // and the host is about to compose this definition by reference. func TestVerify_SaysWhatBuildWouldSay(t *testing.T) { // A guard composed into the plugin, with nothing beneath it to guard. plugin := func() *App { guard := quiet("guard") guard.Use(H(func(c *Ctx) error { return c.Continue() })) p := quiet("plugin") p.Raw("GET", "/health", func(c *Ctx) error { return nil }) p.Use(guard) return p } answer, verdict := plugin().Verify(), plugin().Build() if answer == nil || verdict == nil { t.Fatalf("middleware guarding no routes: Verify=%v Build=%v — both must refuse", answer, verdict) } if answer.Error() != verdict.Error() { t.Fatalf("Verify and Build disagree about the same definition\n Verify: %s\n Build: %s", answer, verdict) } if !strings.Contains(answer.Error(), "no routes anywhere beneath it") { t.Fatalf("the verdict should name the rule it broke, got: %s", answer) } } func TestVerify_LeavesTheDefinitionComposable(t *testing.T) { def := quiet("plugin") def.Raw("GET", "/health", func(c *Ctx) error { return nil }) if err := def.Verify(); err != nil { t.Fatalf("a definition with a route under no middleware: %v", err) } if def.Frozen() { t.Fatal("Verify froze the definition — it renders no projection, so there is nothing to protect") } // Still writable, and still composable by reference afterwards. def.Raw("GET", "/ready", func(c *Ctx) error { return nil }) host := quiet("host") host.Use(def) if err := host.Build(); err != nil { t.Fatalf("host composing a verified definition: %v", err) } } func TestVerify_IsTheHalfThatBuildFreezesAfter(t *testing.T) { def := quiet("plugin") def.Raw("GET", "/health", func(c *Ctx) error { return nil }) if err := def.Build(); err != nil { t.Fatalf("Build: %v", err) } if !def.Frozen() { t.Fatal("Build did not freeze — then Verify is not distinguishable from it and should not exist") } } // Verify answers for the definition as the root of its own walk — as if it were // the app being served. One rule reads differently from there: middleware at a // served root wraps the routes composition brings it later, so it is exempt, // while the same middleware one level down guards a subtree that is already // settled. Only the host knows which of the two a definition turned out to be, // so that verdict stays with the host's own Build. func TestVerify_AnswersForTheDefinitionAsServed(t *testing.T) { def := quiet("plugin") def.Use(H(func(c *Ctx) error { return c.Continue() })) if err := def.Verify(); err != nil { t.Fatalf("middleware at a served root is exempt, so standalone this composes: %v", err) } host := quiet("host") host.Raw("GET", "/health", func(c *Ctx) error { return nil }) host.Use(def) if err := host.Build(); err == nil { t.Fatal("composed one level down the same middleware guards nothing: the host must refuse") } } 3r>4xW]o}6-RD5 QoְP&#r(NL3Ci`;CrMy1s~{|N˻/6UNnJgE#z.L2tl1Wz)FVI"ΑNڝ,s޿|-Rۛ7k&8˓ţJAuz|3''gԅ)z3:ʭ|;!ouVi?nY'$ajI.*&-+ c͕ hCKM'hGJWs\m8NhgJv9п/_Y+ kRQUmؠ5$tޗmNC ЪBnHK^ݡ8}a|}\Vi):XY^f߾7v8 xC-¡M7Ɯx^kh Txʢh.HU| lt8Gڣ֨!঑2"Q4k'˜nUB5!PҪ2P#(Ѿp ɩRt"|#Zd|d VIta/$ 4S ۢe d9DJD{C#aZ@@P6FSj'N0ýhobɘ, XE B+[/$Y@o9ڣXi:TD@=l!'\&mxG\?qC %glVdLhp#/Fl[YanL: K\#|9K Ŋ2ŲߴukQRH#`W Õ5{2P1O~zb|7]R; 944ۇYwbcE2~"A x@LCx%OvbN_ >Pbd?;dz7|u0a?ů6[D%`=UvxZ LJiz,YY0x旙c>Ї?/xWnH}VҖ(YdXA{1I`ɖ0![}_ȧnRbdy/-u9uѱ 5Z\o4zE*qzQh-ŒU&il SITNB)nIRfcDhU"2*䤐ev,-%ʔn᧓x$&f#wz? X[Xܔ>_]}LVjYPbrm8$sPn2v̭dOa.fLP/[NE.(hHX^۰ !C,KE!j35YڎP); ]Ai4@MJ;[RCX @|jmr:#g:7N/n">lj1{T>I:R_9_i\ymxKEǂ0-yLW 7`}).~Egc="x& ~@WF=0KrDvjp;jmkpj(cr4 UB$0:;nM|auRuCuj}G9S"#ׯ^1شp D1ؐKs>G9g_j60b+^h֫VW=a~ؾ7VdU=VJ  M'T{D#2ŭH3Ru>V|ʓ#tp .{JC~ 8=l%XaoI]}\aF@a.'T!ԐG${,WMM<>GDB.JXo2ݣ\[Y '?4dTIIP. 0PPN-ಊO|3)3?~!ϴ?0ؘ^^3%vo7^dM-ħ7b1UKj܅`f\ӽ3,($e?xcOs6uf~pn.!c8axzQ Wghu li5-L)z煙7 [i^!Qu$VSb/ȹ‘.~Y>jKк&BiH^C#BǛ!  USqZ.$lJg <둣skT9RSq?& j9Ǘ[6x~z̲mx}m14ӫ+uߎ'ݻ;žZz LqsYtJQ-\Nm?Cbn3PVL68֥s6(4{bȆa/:MERxhF'EȮ[2.ʡi8xL{NQfϰ-,jc;AOwƏLqw; 5gEh\)dAD Sh֕lȊZWyyM9Fr|Ar@>sX "f/eҗ ٛQmC[@0vrTokR[;|2KFfk㓋]2[bP7/xkZA X-{hnU[%t&2*>u ~QLcz3#(g`%jʘM7z`8Q#:& p{b8Ak!%Li/w?.Zѐ%,[q/IQexJ qӪI8OJ\?oQ:uX|RLdx7,pܳmB-s!d'M J *5itiH^bԅ 23j|GnB]9.+zP/ݖFD[M.OOքa. yN/)j[몼os\q-&9*܈r>ɏBeTADYsm(&{: "nl &v|A߁mTm{uV8oT7KKU\ozK~ˏ\ }V5B٘M}2Uf3?VY~]!PJbσ}L,wt/ ; uׅSFR2Ð0VDl%Semt17a#|Q׿WʗS^_~U\ßZy[/b3\D|xtg@L&st{v{kxr"ieD2W4"5ķ ಞto ^Q{j:UA#^hn%V/'v`˽?>CC3w]\_/.ɿaEhX{Wx1B9ð cx]UAn0 zemr zʥ(Yr%yΩ %9 zZ{<7xϑLSp&QBK tK31=ۅxYH~-!D6Փ<ɐC$#C0:D6Y0N(AoOcޔ2)FHGoN!O7#F1#X'Nitt_ 6H!MDd>iƭu'|%/e%$tQXJVGw(^UjO,ttr `h !⍡Cuta7!qn>},2yhU+z5mPUz&_0JQz ѨШ} (I欈Ԫ(r7(Whع_ We8Pw-l+GwA[e=\N#9kI"gmG_FUڍL) r0rEæ۩rDo %T8zی=2#(GKA`XC;0ȧ̹29KaB"lc7oz$} ^47 >QJQEvJv 9vE{r@Y-tW/H͊(jSmWNVϳz(@iiV꤉;- LJhLkD 苶DI @*k@UlVL- )?uWSC$ ec*:w?Y %WxV[6_XJdB4XI>-}g`NO?`Ú^,B+seNۆ^)4T@GOϺӳC'B0%'&mMK͆gVHz! m +6G o'7?ڡ ;,M0 _yT!Id|$s~K~l}Ff+uW_%cEӉ5z2 ZR99Жe%kYҁ^[[qΣ6QFivbv\R>TXֺ'jQa%G HoQXю1 6)ӼȲiK7yU<*˞V9WQeJ TȌ+89/ژ*pJ frcpr@oWYr!#$bv2+j4uHٍcI2; FLRx[M[7Ğ|ARtܯT,(Kj#Nu\cWZІ0Y929oy D񂝝I -ȱ@G<F!۾:L$.w@}Dn en|p"y= Nuea$ Gڕvd{vr[.Bb)Cm :+{/Ȟݸqg~OD7Όlfl<ԚPZz zݐ|gk Y\w hFI/ '_R풻xR c={0Z>\ה~ LB$  GuWܩPU>FQcgZ8/׿f6OIqԆcEbIH0. }-;s3>0As$tC&!;Ii?z]co{ #ųDX^ e_BrY#$ԓD*`wײu+OA#'iB {I{22Z:zVPf$4?ΘNL'qGʐ sת;@Y6S j8 gJ[km޿}L8 v,F!0F22s c!Ii0hqrnN89$; M~ qxٟ$gVE1 e"5B?;TpS4HCϜh~?_mH:{G [3}0*aΚL3p9AـP`&{:uC!sF 5F -!t2pJ;S/c|*~wCP:б]a.R6}@xTXA+*^W4w ܖvήUWiuxV`[ZdO8j}CN`:=xz]dS.[~ЬMr vU"Bb3q7xNr +Fh% 'g)ΝH/{*mgf.nI$eȿcmF(^Gt?7!z{Śj_"P4u=;WlUb 5!9j/c }s4ƈnM>]d#P鹴>N07MT^oCO8Uվbbht4Ɯ|4Uٟ?TYsHsN-z ?hsz8u >HԆ O-]Sm=!bWӴD`_1+r~U&w2+"$ *i _<uٶhҢ:I1C`wO$dLOm^-k:3xܮ׏Ϛ?$dUtt񪆢(kn2)oc@nZcMhipD-b: tm4n)Swec? W!6ANfZg&v1 9\:z"& qS;T 5ŀL=? lC`{y¥ ҝ⚆0KZ^\ `woPE: ^"_vJw(h-#EpJ?W0+JHWxJ}&v1!1ȐR|jֱʭlj{d)~5KKcD~<9m?6"A؆34' n 2AoFnË`^=EdT|M_`aa(>8t8U]%8^ֲrN5r Ggud݆/l6HK.2'M+W)R1 ['$BKXL |`GX_ϲƿކb/+D23_NA8e7}Uva3+|09(d')Pq(6ك~J AD";!me wdYj([ۦd6e!eοof8wDϖϩ }j@jƥBEC, u*ثyM}}AֽQB G][~|pBx͍9N *dg391&yiow;7jnmՕ_h gGՐv^cc|$!=o07tGk uP /;fX7]{HX1[uq1 ?}M0h:y Rt/LoP g7 ~!$T]V{YcݘUFMw6l}3wWejK _q!MС8ԹAkaN;1{䎑]}_o=q>"ϙ[f%ΜvBuقX }O?_!HM4}8WW=h樜RrZ/~[λ]vcbR{;('#$S0;xT髥 tiUgBy;ߋ;_mHcMfk$K\l%ΞcPr^wMj*P۵+(^*Ohvq-/Y'ϡ᧎}]ɥ^6;.Ⱦ$/ՁuY!f;9-膰ȑS,vٷ+1i~0_56HiG0\xN8u9ŌVnې`LyM)jy}eegP6G6 1ݙIygX3 Eud*U.]#愇IK Q p`.P`3ěkG.JVX!Q13[/uHMh nZlPA'ކk^@Qy6Y؂u/r0e[N͍6^(+PZ`~v@h&Ep:BΖ/lqe[{ ]QlfK10pzScjQ+>F2~]T1Qȅj:SH8,`id!BԀa e\LI$Z1bFz~yz*o*#zD"5g(àAg{@7Nj{v֪xr"h;%YH{G5uг\g ^G 9YWdU q7 b+-9"wZtיw"as:;_s!Ce"v-awgc87 6tC:hV}+d/NG`I] JQd)>/'pF#Ba̙ZzZ1$4 ?AE&( Iru˩Jua4nR^bxsoYᬓ?g{*+ikc9 co4^J(MzepcBS_7BTklw8WgZd<3ʄ<0Z\PJ܅~ vC28iη (Cu?.T1p5y=2GلM?GM> t!1ԇ`7^". {& X Ⓨ)ouָ`h`?HsI*`6{ija-){JH$(*+87 יr5KM) by:OF`8@bkCO4$  Mʗefx{pZE{m>kG`Ek^| u~u\_ECQ453a)#Di붑Z 8Twc]R _ld{A:~!*yTyaLpk]Q3v(r/DxGda0;:8 6Y H"O!MW>2f E<*KֱA@}ĩR (wMiG"I@Nr@R_q;-ŮuG;wcA/y~oQRW8d8O yMcnrѴTuO 1zd< 2iσqjJi(ɚ1~}96nbf#+>u|ʅ6tq09i,IܳKCЩ ~6tVR97LMZlY: ? z%H0PS#LX<WI (X etC$R;o&v#0cC.Ãvzy/aU>(@E!zxJWˉCX2ԡ3&ZAv^_ZnتlU?^ Jx1}a&qkSBn4aV+:'&/,~# ċ^u5{\t]0OO/\{ \IV0V$ Tz5PQ j:b]ak< Ƽ-H "hb_9`wEPb9NrK`Lv"_hԅZ=vޭFbel 7i4b{&)JѷDi>+>| x2UYmz}ݥ:|{36 -H3Cz7Ly$L2hኛc`@4Wq]4>|ˡr_=z#.`}YC+@jCG%gcӃ[ozS5 Պ# m@vդ'isagV 5۔ѮPIng;~|V{0CeF- vG Uj}ƥ4z衙'L/8Z")4^~3voDb=v?x{``_18.3 h1:GWhb8y7ylgVcaVOR8XN/It56Xovm5Mkv+nQqiblnnoA98.3/go.mod h1:fbNeWcssRRbTkQEDCrmUmzqJA1gKcAlgi1z4QrtEFZgO +x40000 infojeޱb8$. ӯxo100644 ops.go8QX#ulw/100644 types.goԾ9qYWҢW:PB100644 zipdoc_gen.goUM4Bq''XH.xYmsں~$ℐL?H{!ks;;`%ǒ? 68Mۛlz}{vW\۝=a\˸_o4…#J-EƊQBztKyL£c'I$k׌5fdŢ@ZRH)1( Z);+6W<<5#P ˥7, Q[_8pKPc(r"Ib&'$t bEg YXZߘED9Xi,sЦI { j lpNQgj&URScGeidtvWҫk('s %"Dcb#8CIARu.oP`&a5dew X1 eoڽ.$[6  )09$Z;҇1g[}hI:EYah=Tww|Z0D+Qi~$g]m >F@> X 0tV4Rqxɤ(mCrbx_ /c`N䅨gT#+>|/&1D&<Э(3[>s<rx.$o3z4EC<(H^B&NͲsZT~ِdB( EfZ\!h~P7uͭ(.3eCy1G[|JTAa 1rt41㐯LƻT }@JueewD#|ʐѩĢWLJ9r[~%:[W|ƚ62+7dn V\غ!UxApno8=N/b1]T[3v7RV;WÉK2'<:Oy( }W`"_/Z̪i bsM.%p"ҁ0s(t.W8Rh|}Olt999vYyߛ=Ǵ03~zrt5QL8hSq'6w(˷Mb1ծȗ) zQ@rաIla>3 ' , UV=>c.ˤ0)ka#` vi`yFj_M4D' o3sM#blpIf4cAhAunSAZ@$7 ]-zQPޱ)TdQ\_MV5B[>[/Ds]xYmo|+X@T]'5P`/P*[%9 tv //3C.wr\_;3p葸8TxupR*VHó46k*K  ͞}@$XQLyRdR]p` (6//îrp$߀!譼Q̊N y#0DsѺV*}pM.oFa;!`od+(+LW/cqX)!V'?TQZŎtFrWaO5ǐz W2{4~ L1~{ߨ#$u ,#̛Jbh%T{"*D(7Tp!\pNU{y֙ƴ5r1WsB3x#ZvO!s_3cxi)A5'^QjInہyX8mUoԉu28n0seL/y#C$փ||f6Ԝîb@_N|]k!|ѝ; #p! INl2ٻIgn];M"82DķDHo= uw%e# RH&B[^fZ-l<{b_J(Vr 9֎{8#y^B穢 N:GQ?"$'~!;G\X1/vPJC?~||Oo[xEu]g Ă.!D펤w  | [ssFw~b=/d+X>Wavdv6̍l4{ &$|Sm$~b |c[z;f??Ń>_v6BF# zoͨbG(1m=Q| 5&'QN׬MM"l >~bj>O>U=5%ky:iO/z[փbf0_ΧsmVyMj@ɚ\Mg kM%_%gU<.ӹę>pNnŨSG40Ѹ8ڴ$y@"ԪͨgrR9|JM,=ČH2HT2FWh 6inHΠOYnTZ(R_\]~8AgpeG8E*[誫Iȓ.|BUiuKA*ϐ6(-<&$-w|d9XLEllzѹ(֜BXѬoMFب\wrٜ*K<ԗ~.mtE\לƼpn# :e.{ҕ9Wߎ7O$۽cɔu, ɎB-H` a=xXAcк324=KC_Շp}yJ Ў?$d3$ii,Sy z '-u*.&ә>?g&ԃJ~q_NxY[wں~.BK/]:%Bt;!YM`-ג+H4<$ KH3\4#'d#0=2X?9$kӵS̝'~4"Qu+jˆ#c&v&Ǩb/Irh|x= Y UIa?*#Urrĭ ,Ic#|>@C Y 䔰H~?,XhK+_p)M39;} e," ӟzf ЉHB.w2=FGd*z(8YzfE։L1h4fYgwH;O{,&n^'Vtt_-%=TI/d`ygYz'*+IVA>R@U }oL#1Kg٫~rWD)^цdY@YkhTWBͷbE) 3?Q) @؏le1Gv<(jg>籸uj4D3{À93~Vq^jGBKder+oaw܄C? A?o`J NxgQAS kCHq@’]Iɡw^WK|jx A}EWsLɥbS#ObgTI#E'";Q7CBs!\5fJH("YG &U @ǕX1m&jp!4)K5jH08Qx+s4oĿ+HЊF-h<92>CO _-2Zj5"hJU^װ)_;oOYD!#jVfA1*+Dˬe^,es\sP0,΋4$|Er< i֦qELLWTZ'c FϽ-A]:\FwjfLo"=:8_t7aj˭ZGN ?(|fMqW{A =S@ qPAw$ZM}䣷LcD( tk-t]y4MAxԆtaޭfԓZ{bWp&y]kc !SЬ Sn/ާ+>2l[gڛ ~.+f4{"WZc>Z̯p% U #6rh.W)V[fkpVA`oW4H^i8I8 :sS \6v?(*!K"v$iJ8Խ C~ $,LzR<fSi.LA,Nܣ,G 1ϲVkQk7}i-x"4oºO? a۔xXo8Lƒ-MoJtTvw! xMvq=2:b?o$#s X^!Z,>~)|Z2>WzܖJw?_S 89TMM.eFcO/ &G)er'kE)S dzCR>RN4w yN4cqM匠Iu"0La9D*Tfh]ެ)^(Dga<*Qu:U=f | UAI%^K^k#}{gg'ϤA/T9CAK,McԻ9rUbN gA{~Zvr=a&$T( DpRhM$YFSWIQ+RX<պaJU*YQH܉xb /8t!IfXh/mQN"6:eX6*YJhRIYkGlxGA9`sXwQhyIÀIF팩|]\[ݛ׽>3= 0.gmf6,fȄ0"}nZ l]eI}ʖ|)5Үk,-Zcjzdhf$4F瞜ݱg]/EkS\oxɍ ~xS_p^ٓF&?9ulE5`dSѣ)E9)A+hZbʋQK$[稽inKؔ@@yj(Q4[x8] 7di s['Mfgu(CSqh6@ΕQdwsRAٹ}_pzT~z&|ެ6NSX*;mRR?fߨ,m*õH8 6d"U&۷;ah81aFNQ85КO5>I . Wc+7/``s21Saz!;bTADÇe\='/%j)I8}8jl߁iz4Cw abԜ*\VcrcNOϘk貎A|lsW뵸ÖocEN.0D(?VEXpDWWXf>6?XTX: =Qf Qnj0wMF#5Q›=ء9Ů~f)("5Pn 6GJ;s 'cdB,+D̈ aӋxv :}dYFxS5e!I/*e * m -.)Oz')22D?OKK~7+.\VUT(خ8H% 7&I$_vgy1xVMoEVBbnM0gu$$8*-j9J Ů٬(lSĉv8p#'PTƱ$~\:&<3<"eNl{]DdQ0L縋ZI>ֻ|`c\[7݋(>0T S:HGT(HO~޹14< 0c˸N&d$ 0`~❅L>뙼|_vK(S<\Ϗe#"j=SE_)Bhjs<F/LlZl@=䰋 lmQHOk]qc+Pg* +Ph'_@>r0;"nt *jl b*|jbouuЮilpրuCtHxb(~. .J[%RSJ}qVl+H.DmwO|Dw>lD򨉺}ހŝ)`L"ķk'V*儺DOaf)n-xLF}=Li VvG]_'O(KtŽ-7 SċdV>=/Pz*}fgz9!Q7"K ǑҼu ½B5RfJ-HwZA"ѼLN<.Fi4)Z\"븱XĔC -EOAO(sŽP"5{'&e|Az#LM\%VB=94rSm|0= *v梪m9WJ=!ͳCi5 U@"VdP}!2Z7C(HN&!Zs5"u\O)j9TQAUД@me)wMHM^r119_|8$&R+S (2vweFriCR䑷yk?T"ePK'N&1r %, /2^{d=gޣ~vpՊWfd{xWn6}bE\i)b,}p /-ѶTH*l )b]299Cds/K ^"Y.{-/ Q8}/^n*m._ 9\13;20/JAs,eVp ) ܪS}Կ_%!'5$b_AuiOU^`4Sxzl3%`:ّ,1^`B܉ap W׷p>6q'|iZ"i}o-..Tp"yJs*XƓu)gEGWΛ6 ˎN:2D ƿS Լ{LZEP CLߦv㿤F ,*[}la \e~/lCO6#p+^(`Xo|W ֝ybGR{WM5 ]胂!o}GӌrKnM9>>N'MS![vyVIMJ2):fx=jl,\s+$<UױMCp -;QZʂL ]V{p-9;KӢsR`j+'{FR1e=x,ҠhϙSBd]K b3͗ oP"Q-O B{xu (w(LZw ވ w ,B]FdBY, 9>(rʍdzD9onjU)Bgr͒:fB\JQYֵX2d+;eJSFȚ !fVӡUa9LbBE`>QAi{x-ymJPK{NdQa4ȩOӼxZko, Bi [mli/p]#Ę"Y>쨮=gvܢ5`ڝǙ١0 ZqʳRxWBc)Ue}E1e=lG?ɋu/N+]aaFi]Vg?TYB+= yoDZjUfu ~j?ֹnYA:xtJaGgV_LוJ+Ʒ"1F MK̮Պ[d9E (WyW: N#S`z ZSBWuZAJ 5bo&-@**,8OYK:TJ!Օ[EI IDeVj2 _0rOҊM@?dJ̟̲K-`*by-BM{W\qP"+Y0,rc~./)5Qg" 0#:F dyF*##t/H:-@FqU#q /)§iIkB 45;Ɉg~ćhmey\WgS'_!ab1`isf[ahY!J!~$i4E&~ooـg[hjlIm7X;}l$ WDCґ߆w{d]B55^H_}i+cl'-{}{T8`\v^qXrR-?{9^VvH9.EJq*M,Ɗg-[Ut>Mc9 w,[ɂDQ 8t,iخQҶ8܅B?/|t8 Vo&M ꖼHL|pOQ'=P,{yɣs1sGpfW[ ½T2Dضa~pj*^FA@8 ,Ƥ37~mJ57B-|tAS>j騈 [; 5 i&~ كk{Ga+A=TvQ7'&}$F?7AJW'qۺJÔDon+߶%ɰ)oP]ʝ KLq_׸ҡg|J>þ#=HΙ؍\∓OJdYU+L*,i;%/z`5k c)}?t«V!\c%Dmj_O@F"ƠNZ 9/O a'U&)oxA`Lr,Ə*krWu vx2T$N,P*i*7 :-ng:f(k?nل܏HV+S_3\@wNR<2CZ(ZH#b:_V0Lfq"7ZDHJ=I|q9u*OpZ.3p{ƒGҧLnx?_bndYP0<0H^+q10xVOlTERZ-B[p]v4E@H݁f^ߛ^4ēċܽz ^/ƃ`bb&zғvi|77΅g #!EsǏ!ǣ $5vI};0vZaDvQV&{RK+{Lsr>#3^6"41n[VP!a`!Ia be&h-8 rP}F%30*A>qcQ`!Lȶ6ۣCImeouTF xSUƑ{g>luT~Ӧ̀IÞד\4v2n2KVǢפ!D0ߝX4W @q]Լ<0ǫ_ghamK 'dOvfSE }R%]DnRdek( Q3KrfXF@$GnOG[]rFc4?8ѠO*FF8B؍Wav{jy U'̔3tQaH  {ooԚ&qh9/VL2$"{ _-=a[g2S7vwO679u[;p!TnD=D8|aMp2<-p {'p8u@K(#ԫޔvydoW]9X #C'\/y}C٪JotuO-靓.}<:;devvt-\ !X! *{כPxKӵ3X>ݪ5Kf#w)62qՠm&6tE|nUK ZV,6TyJ wqMQ['T`Z*o#czص i^Y~t[͠G:>ه eyoT,ixBzBh4QK`g7rvꊛ;CSwIc7m2wh}^HCM@ 0QYj7AM% M*)$\Jo#x{k`o[TU,j%[؄ }G/A_fƺE#%y7GH= ;hLlD^"sJzܧN@]|dPcøizWgxAKT#bF4a:UBG<)R$A:ivr 3_ "ek G샕UiW 3'K-*%1\ñ'AZEJӂљ6agRBX H= 0AV1j8RS>\-չ:>Ẹ?BJqVW =Ԛ Iz0@6 4n>< 5H uBHj^Z),1 @'g!YiH"[{FELGJU&7QWVhҫQ93p= ]K4hF4ݪRu. [zƁIEꦒ3[: GԔ.7-r5K/aǴ+~%(ԂZࢭdI,iS?G patp &%51 x6Y[f=kd؂Дl d~pǡD4I<&]-r8=w#~,Lqo% `JL(/>|1RB,A8X1*$ÉtHEIJÕ3R4f5 hxd NlR}0bl4B6"̖2Ajkk-uo{() lF˽fϷWYœDݬ Y{Zaq نo.o>.l<$ , xQ:4$KduG"f8@f5[SqU?~ں<=SLmݻٺGτevou@$>S!vOOoތp.#Bا{0rxX:ߎ{jB}[qxԉ)]=ea劫gm>k>'MP;g]x ,`) ݱ`Åo/I"RTt~c%f_-+"]nw֒'2Fe]Gb@:0w53Ćx6&)0>tE"Di0N=<꼈.t~S;=c8@86;󩼀A0\(L㙊`S8 2 (g7;{0})߸`-\04Є0k+,.9]^-?tD0xD(jgkROK7/ Xjtb?H%8d)_E  J%!@|N^gͷ|$BGL>ogi:4tyίaܿ)2wsɫ?-/HQDWa6 C&v(χ QĬc$:7,+_Tˇ{MD_{'%[J44T@PϘA P;bP @X]q-&6(T/)_ ,5HG?By-VY"w9Eclu†""pFj-=h 0!|a =Rg_؆&:/`P ǿ]5X(%SSԾFLoXהZ"l=#a(N #.TD:BXP,L 8yCdoС!kO>M9Қ'?:1 z0|N%X~:`J]"6B&F-dR$MG5?pN kHF 1c1U.}R[v܎h9 }f17<<}jVv1 ٨ XԮztӎG餸ݬ);鴷P ÿCi ŅCqxh5$=d ¥x=UޅŇ0g'+ .xO}@kuYݍUyr_>[n4| Nxncώ:L/!|%.\\fTɫ}WKzpٹnN~[Y/,7kog[B< ||}j];.l40m24DH+Ly;nt b%OG;*rv :uok>wL _k>./Rҭdxgc;R6$j9`Ma).#!`Du!rkDr&Uȸ<ɮ 3ܛWAwp ] #LXubuSjv0LjȝeQ$)_!ҜP* Ci@Y==dM:5TQuAQou]ٌ:Q}u=s*vW7ze r: )T_I'b8Qp`&iBn!컖ސZziܰ(]NWp~~JFιF6u_=|)~; K8' n>HX!,yg+hI~|@إ!fpö&>11>z8$r)ݛ$j~gg}dzuq. ƓM,I(uiR%\c&Ԓ MIkigFM?e'DmUjPv3FW>*NNW liW"Bꭨ:/@w?4i-v Gzx %LW*:I+pfıtS~%ALX"*wMkki8%~\F?c3k<TŔ}xIz:0c%ձNX9/~pM/Ͽ;~?ܴ5o^C#Gk]Tt+J+ yx;* )m즨z!t\jo# _(?G Bd]PAL+LuDz:EJ>jI:ש:Mമc|ihΒ S*w`pIdʧiĽXtTAbECw >>mAիx\Ԓٰ(5 T`mBDaRKܳjAsXh@٠&#ў/iXx!6LSP3m=|n9w9oxV@!NP}ڎ,&~cg> TO@#S[]Vf^1}Pd>]G #5_ۭK-u؊:,wѩ3\ g"4GUDVe˒kT(Z"P[҉>`tr{3x*6 uf@xdAwlyY&QmqiN: wXBzR&@ZjrXz+$P!imk6gv|`̖@Fɛ& T?whۆTiw2rxNR2\2i(SmJWp̡XB3iKdo&NpZ10aû÷/OьZ<섪S5OѳtVӳ=="˸6PX&2nk9|P"f[sm{Z6L?Ʊabcۖ&=h˂ts-p#;]2w;$9CK*$*QTURO&U`% V$r]b[B$A:O7(ć`^Z,JaKچJwO~wj|ݽqӶن65JBvElXTW4*9rfx~ĊLJt/~*V+tH-T knIcb!\gK2^X^JBW$@rP@hOYŠJ2,9,[>BK-ɵe)rV3o67FM[(lxK~A#X6:_n{T7U٩@?]m+ZmxyYλqt‚(*h]-ƭZU/_*)x4h U'/(1oSmzbA0u={"8NBv2XĔ.âXĩGs&pxofR\\~f"K2>!Q;`Q2,0xwr~ud_KprZ^%`PJESN.ёxH哿g;vY鐈 3 Exp@iRnu}f6By 0?Eѭ祡&UM/EPЊIL~?E\N ,rf*=91@;1UTJ<Ն+ Yq[wuoUZfB"m܌3ӁP5)kEcZQ'nJ]#D3gj0 +@_ :mo14Yb` b_tcC&Į+6[g+[:֕({F ꔯ*ReðVPr"DU*U KǼ8"u5 [Kk'fX7)NCb.X{m&@X< wVJ+Nz(Aox)lEH%Ãf>̈R0@L+NqL 9#QA}*6;@1MDo7ăpږ) +ҮTxqyWJ\+yoBdrp߫w|ߡ>wzu&ì̎z{tzӪ8/K ۅ5t+mxӘV q늼CXwSaRщtreƷIt]@$uWj?"t9IUڱ#zDҠk$#xw o'0]u1HeVxyU- {w!9"5Z"bh^&FܐݨB(Zd&޲D?h@h}Q;^Y]ЩLā|T5;/+?:͜(v4oiUZ fI섘?VlVcMc#L4<*<ԈܵEO<0eVFS6uвv? ?. 9͓HZlݫwk<2>S/љr5Žp/d66ad.wS;r"FPCWoixg*A#1ㇵeY94WHlo}Ys`СfKUe%N9Wq]T#GU3a L]k[nLK⾯Ƀ ZFK>\X[bND b$H]eg-JvRsq2F*H|^*ЖŠ h8aϊƵܿU]xSt~W|lCv>K r =.Fj= Lu, =vLQ,x$弴Z򆂕a:2![0PvZW_DLe`%SOLfZVjkݔ N+|p:Ԧ6ͭ?N&'gn9O^N ad/x5`OԛW/>۝ Z?*rbjs'I~]8&(̷Ђİ^ʞny]0]e=T_PU+CMUŦHRb8k-=0kW)Ք܋ N(ŷ,LVP$p8w2⅊~ dbxPDZaKX ^NLPn|V͉NxܟUznv1H5Lޞ >um 76%opgii-^D\m#_jP}<.؄ 人4Hnl4 0{-Zn^f4rE|@m+&/.e{q~z;ۼ9d-RҾ󻬟tr_aʉ^Q[3&shC1CcönC^["]3%-D[ q][pNqke:ֳ^Z˦!ΰfzzƖceEmi4Ritb(Z|V.`tYu 5TZ>[9'ұ_5'eM߱H~GzSP%8ڷ |ǪQ5?Aߤ;lE* sl *cO e)t7W~W7ΎN/.bw uUclyeOm^h3xB&:8wu թ3r% 8H#_.ߠzm>ߦŤ0=;7pGf^A42ĭ̒/Ⱥ+r`a &ZQn9ݚ.˪4_lfy7x@u.})_Dk|=ِ9t̶Q-Qi8ʠ9A*a*ɻ>- uWdɲӌtv9!xlrqi`(ݙ7o^̄=܉Pv]m@]F0S뮻-ι`YA}ChVBOlsUY}5x5{`L%~úAA5-+BٸW"#B_o`i߁8oF~w%!wȎ]XS鶱xks+IB2C=,tWڻ9ʹ>JQ+5E|ι//)Kr)εLlrX΍}-Onjx!ϥx+{~.pcGqD\\K_Fv 7X$0ě??W Gp&L)@;S7N}r)Aّ"abf2ŭW@EfQ؆FX~D@ x2% [K8a;vMر$?`- QNNP81 2 1(0)s0pX% \K\_͝o3ut,Dw6\O_ &4jHab.> !N"'T%xnZ;^zBkXtb2ZۭN5KA43|L,dȎ¿⾵3ǧbaHۺvP.D(31Aȝɥ{%N.!2ډdFhk͕on{L(k.hӢpS"=~J$H| ʼ?Jq|TeXyr# 4֎=@Юq[&ԎqCO x8 CGюaQ[ y?7eedG 'EbGwba^䏰棡auug5־5 x:!۲UT=Qt.;9}$22HA72HrϠo ۳{C`85ɼ `G6mD׾g^`'$A 7JX{R ko`YfށeU:XH{VS#03+=08fo?GGmE{ne}$IFr"rc4syAS9 W+폜2x/䢍2Ѵ1q{7nJh"]?}SW~aę\Q+ /m.( Bfd܉T+`srOa ᧞7p įy zkhXjgA%rzxnsasY'؇?#>bN٫q>4N맼9 a6U%1[tb`|@^3LA}  )9Q]ikx^ r~vUȖ:)~g+_Ȁdc0ֻa_}zksO.K.n@u; ?| 3P_aJLI/kx{W:ZռԳъSZ5l{-~ħ;} b=qTF#h)5X^[oַBDXycgRMHė :ma!b9XB~oV,~d;ʁ7הz@"J*iLWz':U^S ,"'H͖`giS/\ҩ9vh{ ^i-qhw-{j10}=>YNZ-M чW-E]PK&X3|i{$ljwHtN>O.x&qXTJ îxyKB| R; b2~iN6Q̶ )iB''r&d:)m|Ĭ}R, 녘sT6ܘ(2AN}}Jcƅi<OlƘ^:+1ڟ); B ' a3sy. [̀!84 Dhb * Pet߽+C@̔u 9 K醳gp_wZQ&ƚLzR<34K>D:nhzg)!Yﮥ%8ӒT}|t((Q '-뚒#IhcI1~ 4`Z.;?l&R+d8@\-8Ovޟ9z'D/LjY 7哪U^eX>L>@哿Lo8yqU_~ n5ˈ@LډTg m#Dmk[9}8@K:==[$uW(MO5setQ0HStkob¡ JLi4>ܛҶόǼrFf#)/[*6]}rÍZ&)ʻz$rsI0{fײPa?^U3^s/?pM+YTv"`3go#wq7mk;%v'M70I<~23 ]Lm_~hG=$Q g%NaMlg@CL$I߀a/>l"eEKO;f&F$FajxC*:l*2C ߰ǔ2|Zպ{7gZ|sujsRQP*PzQc !u>8*5f*@4.UV+ &+g̃p8 Z±՜C[yoo]?׹lﯣktfbu5rJ[}G!2Xվ㫲 M9+ʒ}.Uk-^/l]ՋLܛTE[c-UfGEY<MXQrEYȂ >-vEjPN0DA"Sٱ`4T܅Lu;:23æ1iAlȦ(fxHTwXv/3e-\РiC_-+#E8RwzKͲs8@Ǘehw2}:0S BI,啁S% ҹQD?ymOvxX[s:~N~"e( 4=sNJSG2Z:gek픡coW# <MgT0Fq1֊=ig#)C ‡ 3)v#F-ckBcpL)GL,<@  Ӄ7-p^y1Jj1M Px~W^1ܣ:Cc$d)DqMG!L}gZcSff{LX/3ӡwO5'ir 0bٜiH `P{$+̔AZ"~,(5n|, 3]B_uF0a,ja5Բg ˜R([+BaЪpMwi΢ W;$7uӊ3IQnX H]Jjر @6Ϥ6 \ 9Q6'΄X~ ucdK<|0Es5$d[R(ljC!LʹPCq=x1'5z@ʷfX ߚ~~XSNX\@8jt̿a8AN}Nd|P.t`!:hg!464ڢϐ`2XuKy)aQ(rQ<&w޲ Sp+K5$xO^1xc;̪e Cm;ܱ~z)ҢtJ68 Q7F3[u8̓`AрU'44znTh}T"QgNeu+4/mU]qĦN܂Q3>oƥ@A9hM ^l}mm ܹJm4-ﲢxœc'}^^ڀmTWGu$Kc uSNbVmE9񣯸 me0Sq\G_Sq3EsPan%&-Td{jK."䂹I0g>r2?@ȱQMfE(3*h^RL0Zd2@&D oi_ᡯ+FM1m7IB35>+ɢFlIs},v3C`}@֒f\jy:!$-M8< ~) $DVNa 81S EÉɍѥj :B ˽#ׂ=; w w@Il4j=W~w$-Ɠ lp@T]5e;<gmgTQ\ə`TJo'E'>!gZm@*{D*NՎj]ܳ.&:WjUetC~ m>i b1ĴätwY[~VTX^-sU9? XC Ez Vų׵xZnȕ-=EEl^uKd0 cH2``du7Gl"؇;yMI[U$jJ aKd<KZ˲jMYZᇸks[G 7ASe|`*voww'knbihX,=S.=E*`NMupͽ A\g?"7y;=8P'ZUJLĪza R41ykejcƧKf$5ڬz䆉z?~F'4zqf|xxѾ|04֪ TXFu :?pX;#akZ3U'.KiYBPP$r?TeʝM.5LQRR׸͔Pȳz <͚O(\suij03 r5]$Y鼶dZŠ4Q"X% Q2De1 4 qm|DCq? ,qMDûu,)y^7 Is~ߎ2O%%ieX {9t +XMULz~?O"Yr]Ut?d0"Ak*03J"3C|Y$0EGhJ˻sUs4۶(%q Pۧ E0(VTWjָ[=q3/iƊ|0^di׫|%݋qqPm%*8-٩ zP*bd@%Ho dbntW-(Ο0'g49Fxndi͙^mش(!~9x{1>%[ԓ'jEhI  n +i)J~wNLplzQT,3ָ5209ڻ^ Ibth"kj&:j]`w. i Lpm k.핁n )j}p[W5{WG%^ )s}t@˖Vo/^*?xaUK:Y   8s3#ҭ *n:`[0t} LTt_DmEWƾq t ۣkI"g]~bX(>'DٯQLҹs( ࣬[& Ղm-604h:]A!zŏ*ܮ5 I } 1a~16sk9R (8o,p:zgլR~ Hol#?(w  lP{FJ+[WcqQ~"!XOXww#.NsW s؀)$T #cH^aۃRwrDX[R,:/ry3DEnRJs|(Vd Q=ayXuw;ڗ~M Yeݰa8r2/ک ̑fnIJbx~wati||t^Yn({Hv[ܲp@XI 35T$o'Ggdϑ\裸&GϘDD!jA0Qb0, 8028 Q Wrd@M}:B6z)!x#(f(Ջ?(Q3a%aKx".8{:Sk` z*:p/N^S[.%0F)MtPG(bWh8w huBNl@Y~X֌Loq5k4H2äG]Oa2-0)5yF9'Gs</=P2kifcRGGv$՘`Ĉ Znݳ]5+aWh1(;=H k±9o8qF#pCQ .g\$b1^}YHǯN@K'/π%!B d Zb 9FT2׹r#q3cX3.v wyO-yR`k} (d%/m.|IZ:ǍY3H8\,(_@~H, g*ЦԨ3Z>Vo+h1(x"pq]R:S*nFѕ7SD]%u'.PCFw![/;?sM#RoPfc@<Ӫz倚S=΀:Sl=h_qHRs~9G}xJ7O 0 !^7 9Ab(X@KΑ@8bЅɱKV6 8rW9g)p;Hmʉ_45N }Ƹfªf2-N֝ zh`KHD= }v 8#aUE:M z)tH D+,rEcϜ wkR;ڈif {'hM4 <=V_o'燰*f;~3t@vfY:7 3jK% bHG#E9x%PJž’X#3a~ 2{O.2`~A`Heh@߹@4ym=\eHlK ,oձqM .\@ynsqRR'-Bc䑦~ZSڍ/ +(=% g(F 0N*Q0@HKS/nwpx۬9Pm',, Sp4q+FBђ@|ሑ[FPL~֔VIv*,]_75Ecc]$fZY"&(G tkXe09 Zg:DMJ&gcJc-hã,RVH)9ā>ccO2Y،1{#"s7SYfdV9rp,7k k: HsgǴkif#VP3-_02Np>}yZeW=ÀKkةa ;D/ A K|4#+rN!hf*Y.]5"$w;_7/` ~*3۳sxځK/qɷx[rF-=E5N, i(hb[I3S[*$F A)}}}=9H}I6UI/~Gk=5״|[;zЇkK&$ͧ{ExUnY]ᡭ+ZͿ}v4gq_u# ޞq}UjU=32ev )JUZߩZ3*16RgSIza 47StϿM\Eiw̋V;?qQdun$Ye-#W&OL%[='5ip?EDGᴃ,+nUeLIf !a-ь²H`U_-<N:(:K{¦ۙjL$,Js!Nh4Q:{3Is0+ӓ8Mhy8iMĭg(okз$ډ\z2 m*#X_eʦ(=U%BXtoSFWLRece  _f&6t˟)ɿ ֌z?7XRr(1GjZ$."9جs\o&~K5_geRaPuy%p`wHt  I߭&գ1sGdJ.Uy"W/eUczOuKv腮u6 ,A4/Hb0ROn߀>KJ0^S f_W]Dd!tې;Xx7 f?E\}[M;\!M")5FvzO u]E4~3&4}KwR>o A_\Ж$:TMjnWH߱,du-*[& F z9 Lqxn3W(ف{;Tu S}dXG8wp [\;^ېQO=E$#؎R 7~Q^ۉ{Ӣaw= ([BV&;To vTDzCa!WS/-kOvWUfB-F_Kpf'Gd{8}}LN #Is{Ke;SHv(J5fi9DxƢ4^vAKa_$8$ `J\9v=T;Ӧ|)2yt· g"@TQO2dC:@fY$tĐO܂e[g%cf:-w%mnfAXq#IFr7K xn˖krc%.ތOcH푾qAjvBQ>] sYA) E& 4-ƶVbt h'(\{:b> - 9#~wP'p8Qӊ)daķ)E.6;+(o \9/=t7~\dJ,kTBeL,~R2cRJ@rzAk\P.W|酾$mY`d Dq",d;[@@dy;wSl C<\FFQWIMuj ne+D&.C1 $6(ew8q)  <*ޟޜ[ҳk Oa" uj(=EQyuƤ57x'6i +\QN\u8Db/զ @LxlR~O76?s"8qs{@՚Sr /Zֵ֮1WTS7h.vwI%YCfq'oŊ ̼RdYp22r; ьMrTJB0i 'w(x 벜#N]L:]AN "uИ O%v#ogEFX]{:X0,<=DrYL΍AR!Ƃ:-v5R=(Gm~: 9].y,}q)?hHW]u0cr 9Җch@Eog$I& nfU߹gթWvn hեi>gha~t)Y~yr@C9Hִ_/ vXyԀ<@+q8x?֠JH_qU 'T m'M-0[ґƗ [:r*Dg_cdyCGj;ڕ!JD %J| $ɃM^,rI8tިۦ-7k?ޖMGzpuzhk0#ݳޒ $ f=;"ؕ?N v=uHc>)J()m=ىC/lЇWs:ҷ֪NkMA(MB`%VbaMv/=ʬaQӷ0oGfi9NmT)̨xid{.XDQƾ$`2eG4R|b[1#=g̚lɠPty 3lݬxyOiJe"з t+׆!򿮏<: F飻``f{8$h1}~pvrQm"^v⫆goh;1̽$j3z < N!F۟?݈t-TH;~z ̒kW(q bfSə@_gkP.#fU,طjT=znD u zzx:[2>㛎AȪ5$"e;qa#?`M]%sCUh1e=) OjmSTb*Z@66dՀGJ]]{ݙg/ FD5IRꖉL[& #~ژA?&9'L2i^e;?Z?j7j@ 6QLqDD?#!Ԯ@|zOGGx; A6[M.S"\'Ҝg[>I[f^7!΍[3Fr֢+N!;18c͉4n Qڶ8pr8o͌4$iˈѾ~AL%#w5%S2W>J@UΏ*MI ? A+|vhcxɽ\Yzzz_"GK~Md]e=8ɖG?WyÍź柼ETI7*|;<P_LLQ|9TDdNxoJu}U'yQQPZ47Qn]];171 %L*R1ėor>Yj3<ލƢƒ~Pwڻ4WB`y(`XZ?a⮦LFm_߸R&XyHfU9mun ;MUL FY57w4zi>܏0Ze8e8ԒW9´3'ے ͌^c<*-Re,腅tf~GaM:C\]W\D(rVeq /C MwM#Did9(*(̠y)f!z8KUEvGy1.d)Y:٬hW8̳, tF\1fKi:/Ly($%DLb94l#"Ȥ@%oJ{+.ZbaN b8ai ^\9 50螏̽Uzާb]?rg ׾^H*U] ;rBxUo\н Պ[r7k_>ɣ|~Wu佾\5Tu˿C][} <"ڭlK+CdK+QH8R`j.,͏1Sz$ziօf9VVq}TLƘ房0(gbYR3 B> $*(֒F2mSؒ\Ke!y@@XMb16^+:hruH0qFu tاt聘']N I# W[*IcF 1p"wdYMR@/$b,\Hk4A&)QgCY0pMK.DLAʚff TvIL #s(xH<'E-Ǎ=LY1dx_7ߍ5'q"Op~H@BA7At(hµlk$p Z&&qpx0ek{uQoFh` S+w{gc yQRU!_QOPj_^{$ e{OI'먎X&2Zs `x~̃uEfJծ5ccE&~i}n {"3X2X Ą$Vm0cHxLZSMNt{Yw|@ (dzyM?I4|%0;vL>#Չ& I=ׄ샲+Gџܾ'H]7qulcY3;LR܉&g[׷W@&if(T X8@$% [rTӹu{Đ]WٕVf8R>5 7!}.9)Q|M9ܡfާPbXUC&gV:'e1aIM^T˷:߹bF#\S1@'kA/N/ܕ?(fF;mr>.!@b~gHH=>ݿݕ#u-r^O8$i_.GD]1%֭uŮRD܁C|䠜PF<<8G$U:$5Jwkę zyIm^MF?eF7g_Y,=~71I7$l@ Plm;9wg'b+qm3dso=&H4yEVFD7 8H 1|]':Em'EW(4-3Ѯ O7n jWn-%|s~^Xf tۼj WVpe!6(ݐ -.A`Z/Dm!7)}Ot{:$֪T\ W[gj`S.-5VOiwǧbܶ#˫۫s]0<#UjF5BlWԈyIM#]JjF| U􊴢ﴵ"nr|4mx;ќiݜM/p\H۹pdPksK2$mֺw Z{M ah^"['P±ޤ֬>{>%r:0aCjIe/,"PjѱҮX.i"8>q,΍ZZ ف>~V*IaRIb7g'g7jSF|RjTƇ9u)-n t׺yATNK?b@+/g*fXٔQ:$K[048&A'Ci? X>̵FD-$tq}~Qr@ۄLj R he-qjǢS,7 R4smzvD}dV[i(Rŧ'֊{%mrz?7't~r3ᯓD\Lzò*JS[]<6P3 bA籭 jظY6H]F;j~L6,I'U ko}m경v8bnٓrѵM;Xŗ]"n`b.1>~4)Ot.[#Hϖ:QભHMiLvgM,_i.)tWZl F  2I–mo K-P*WXMv ۟"+u.$#hJ̶k16.ֆj_H77[#a^&XX\$]& Th㌛PJ?BgݱǣwX9[ݤ` iw4}9<36W 9|%ӏԨg,PXHﴔ>ZxYlkBVw6{b ;d{UĂ1y&F]9N^MDU%(4drl'R'/9co1H)6 ϣ:EcmdB&mS^ Ђ7y-~&?~oO=@N97xNcxԜhRI@*\(,͞58ti@{;:; ֶK y\J?YhRߒbsM8lp؅4M]"߱QtQDIFAnD]b9+0/s$9B_eՌm4cKi ?oVOt"J+Yv@'6=TȺ}s'cE1߄;؞7ukGD/:}B)y]&ʢ߃[*ߑ0$(xA@ҠKT 2Z Ib%m |Гcz;ɴm[DCg,GVC!7þtYáhІ-,hYraPVeZұe!:ZB`w8o0^$&7?!oJO{C$-{Č4tHw,|PƷws$Y`Eg^VJ}e{%;g٬̹9PπrR^ݎ/a7jo`t1#d<  8~`D, vs6cV_ڡ/6A~ 8M<*QngLu KzGþd)?W2&H89:M>47}s1vM{~(1S›_Cs[s^KGRs ?ҁ}sƅ>#(-2S֢Geg]\I58@)asϋꭓg"Wzg}-$';CSִ88rEuK,Qrs\@^ %  *9=@oŤ/ބVj3gMn_ZjU%BQTI m axe^izfWO[FM6dda ڃfc͚*_jk+D^ig[ZdӵgQ{4h#j2>>~?IYI3 M"Ă'Loh\J[nDʭj#|ĕږ{a gN=Bێz˗=R*+pj'+ v'dΞ{tXyP˄JwH-ls,9@Q\f' FP[󳶓DYIhz}|O;ه3Uiakȑ+\ fUߌ)@"́kvHxi0-[2Ll>S9R|:I xWbt5jCf*=N׎7cBIh~u;a Ɛt<Avg$xdZ-xpeF1iD8)T)MaTSp yvkebaJ`iLߝ(I&( [ --,LUAg9B,9PC)7:ݳZs/=€YJ NuYNYSв'!l8mv1{VodT0: *A#M5B?hb`Th¢0#F6ٹ3 k*YZx?̯dF`6N pr] Gݥ9*g?&}wMy;Y=ڡMVM9}qu: cQJirTuD 펡DN>oK1kN{(4h'壼pF3j~Yk)h;bʛH1z-::嘅L,uO;3v廾QwG?2bߏ7h녇4ʵq{ܱJ,:䟰 ;eԐ} Nߝ\\cp3v~ņ1;/v:/ONΆUȔ-i$ /#DQf*c*S̛0+޴~Uw"T P>U$ HwNjTW+Rt +J+$OP9n'X>o,t.hUt'?V $~=ɲ%N`$ܡhܺzy{:K{46dF¾%yy >'#R=Os2 IXj/}ixXNGO1YƦR $J\ 1d=ٙH}>a93^RD;9g(eI+.{==+mEdx'|ͽ^9IoCq|rtzXRUkk΅+'2 Di}(,U}5N*aMebi}!SʔUV ;sb9Se=.*7> mM*l/x&R"U]7E`a_,[*B%JIB݉ʠdLatqg*EF@ߢ/~y!lW Xc,Bxk x1dx˄_L͇NG]a="޹DȀ6i'@Xbw_E] `yHzjfx=!UV3HEQ4HNU51ngYȌrM{=, ldrƽE5P@}t's;:) b%>e;Eg_NJܥIm?;eI?k|?!kOvI] ߊH(|O; ߉!VBߪ+#~{}JS_] zq?Y1"@/lq08\hUK^R^NMev3N[ᘞyt/u/yYv1[w^#_(6xub/$& {˖b直㨗]OGY'} ?G۟/e3A˘ubFK~,ZCMηe) 2"&%<9蹋%&BX,JB72T(I%YU~AM.D2l8%v\~w FQ<c]+fF4-|ms14Re.$pK8v&dy M4Kx_oy :N wў8x*ٍ >T`JwNIn'S_5 DeҹvHO:=-F>]nXX5,ajKOn!K5sjO:֭߬'C3*$-[ljIxྤ#kmTYqqAXH DP *4;)lT!mG AVwvNUOʵ W' RX ;ڥVE]FeEYi4HP0ofkV$]u&ܫУ{]t8kLx+1?x`̲-TEK}Mm!fLT!F;<ɴ 'VwOq3N$ k\PSHDWKY)zj@(,&V3>T6u%xRSEՄ:ǷFQ3WTfF]01ݜjPg'5drrX Vo`!ݔv**dv$ؘDQ V~n2{pu#ȘbYrWg- fV2.E0{BuKQ][gW1p8샿xyp+- &hhJ1bчr3Ka(ǢKO'i G?x:sa`B _ƖϪll{J?u\'#t:N_p^h~9 {{8A Oլm=X !E[1>[ o?5̈TȔB7LA4DPDgK%U[_0%HSy7SzBHEO$Ug" =  y?a{|_3_4RF\KRgD 47WO*W!zX7PL(۹U!ROq*|#cCb8BIr$ 2] %60㖺@AHwa _[6N)]qcip8¿؊M:TPKB'~--.V)Z+qRKJ/Lbo$qAA0RK7)\*$bȻzg3E7UWy%<ء!hh2ʚBgm]mvvبV\; .^(( 57<- Xp F{/, wZШ_5pz~~1c4ךJ[4+ZFדio>D,qJ7𰵲LHȌ4*S~/B<$kF)>lijgJ?*}< }Sd?wråBL:yҋ!Ltft}T[jĵⶭmsF#0{arGޅ׭u+rhx K"hö!"e@iIs,HD̦ތq${MŞjIb+w ]7$CNp:NI=nG=cʆ/gsC.s4[96ScP.aJ胙X4iVmȀEeVgJ9"Kw3SŽ]9F#_Tndt0v"d\C9Ƌxht|l^E[YECa31M-ll֮Əm^;mM~m0YehLKGl$SytY ͝yk;fikEK<_dSaK`;$|A ۺHY B 쫣_UŅqļ*Q ")_ԌD1<;lŞE{lfv?C3_ԸaJl o!Np1k;bH>0ż*1c1G̜):nk~*^f#BO&&W?;4udO —-uiۅ˴}lt0\Lew$!࡭^L)AXdͷf|.1FI"z*9宲XD!} Un$ew‹+cKc}D$ԕ+Xj|ܚs}SkI-aM@pꇳbx6,W6 wHE̎XPdcIXT\)96Rc<&M!UJ{/e2dNi˸Aߞߘu#U'i(x_H_jvDan.UMj/}39DK %2,ǵ˄EZ; @.SXZN46IdRZ&3珯>!͚Zfb[?@Dߴ4\O›Xi7m6^1C{# `.v襼D BP$`Jj۴Cc8!Ӳ&hҤ4gj }P+eԁf1J I"ʂY+z ؘl;Rr=C$=Y3N]5AU&}&p)S969TDlmv!a٫!a-MfU.1֝0B]J&~{VU3v'C6M&7\BA<7){E0ӵ{6Xid(wN-j&tlD$9'hfHBeOH}WFK/!Ю+l={''1usś7W72VeI & lX/${IQw.@㱉  R;8 $@▹_4"s" D,%ТV9|ղ,HAPyɻ. QiV@A^1}*]=wK5WTyq:N&EAK,U+qyt MpNSY4P@ 'ў (̤`bgӢW=V~9 2KWgڛBX HjkR+3_i}Y&g4wij|yT'TaW4>]:HR~|Vr(OL{ģ:z7K6kËe(sI|KweܟMCOxڰG^8i(To׉ڽ k, ȬI$@ 1{lNޱ CTyؒjnίݱEiQ!鮋^3^Z1&Y+ "OCiɵ}6'1+lp,Q6UU:lZ& 4cB%x6]֮ f掉{T}<(iP9j6r\í|t'}(("JS"]TT=+]#&JeBo&_ʞWWfō;?Na7gMipޜ_^ZS&{NWVx}Un6+.rhhŰ[ 0h$$eI !{R;K 62*u38Uc$DnjRչ)t}q[:^2kc~T{XEJ{|ߔgobGv]G A+YBz ڪ۷ qVΕ+6|rdTfX.kB;̽*09J! Ri^ȱB? I{Gs`j*PVM өJG18YD_*{f\jUM~x+&7lN#gNzpK\92eΫ-!8׼*3U.PvqĎOC[f*74ZtY2vT9rNߍ*ڑZ)އFdY*{bHZfL:ҕrm4}My6h!~ S̨͸TO-N)iG㌉M\骭YL` 1KD{ ==']gu̖>tB > \K2 -ҽ逡W=5Oyy=y/NvpЂ^xɄza秦Х%]CRxu:2Čp6b~Ѩ˳vc:as\Ze 9s,wo~'3E0 qpru \| :_b]W vdi,6|K"@Tf\vGq},ȶi'){KYom58M  /1:F3}8Jwi\%(b@߿۟f7E'T9poUxWnF}bJd}p7v#eɒI[SҌbG %=dM,h ٹ=sv\J͘C`d4c[ 6Am iOS]򄴡 -TESHQ3%SlI HM&'j?L֔KjtI3S!R1Wx e ܆98|qrI9< [ptzK*sR9mfTe.|!tģCҥ:/KK]c Iɓu`ϿdҁFg-I3:RJ|"{L8kf]|3_C jw$8+`t ,`9VmȰC$zQY"' R᭑4γ.F_T30vr I²bjH)t^5 BaULkSj&{>Zo761Y7jgjH"g.8G EՂuʉׇM]aFE5&A[Fq!H@fnq(:CDQ*@ytQUW% tƜGM,#64Ϛ\8"2z+uSn 9K Xcc' +蠣Wv9]6e(vd.{ BˊTcSVesU)WlO/*.i4i 2޵ra9jo2ζcVɠ{Z ,6٭ yc])G::ߥ3l+Ǥ aWҩ.L؝ThBx}`V"H1Ўo65 U[)6p f't$ܓo3=oTài±xٗCJqxtH:Rgs!Nv(KWoGJEGE1I#Mt\q͸x=1hS#{M ÅBcU^EP.kc{fI]e/87 ݶ : wF:6L.:evQm̆TH I/[tnCݴiHE w(-,n[ȼ1jS =ݩLP2cøj^F8:;3SﺱImj@x/pK8v립8RD3x[Xa`i@4]ioHZ4258gіZSb+826ny_IcLrcK햨Z[2[߇s~_Izw獄 x340031Qtqq w rMa~bh¦m5<]:+*9x[Xn㮣R\˨/zG`]B}\=Tҝ}}3j?vv*v u ,hHLySSǦu^h 6tk[$J~ tZ8!_߄[Kr?mKϘpnnjH?b姣xu5|mR&M0W· ,Pr. +{QNU B\[&@`/R8|/܏=̥dFEQX ;P]^Al-KIZk%р2F6b7x՜B9vIPV$MɐT i:)TkMp:^\+rCw:LzG=U)v`;7ǶX qmق YKץ@f2Rm3i x4CoL.뻿 *?G!ˉS2{g3^*V^<=jz)!ۘ*F:jHSbܒ>q`{Aٓh 줅wpE곂,e[g4}Yk\3͔D#NIZk/ҷ X.gdp}oT82;}m? :4 Qqwof~VLid:ӳd4=Ka¬ kC+ͼ*Z))j.9hR3śh)hcG) ZH& vUc4ExIh qM7JMm},(#.$S}ZΩvDkUoi@Ϻ8H.LfӀL*,ci?YCRjLj[Ш$bUG[)[h&d0\x.j1!QP>l92ݟSXapDf[ScFiVME1ӏH(M;3!Ml&{jtǣ+x:S2ihQќrko"*G";zx7B1 +n\6;UVVq J;` %':c_)OFXwDʭ[""M+F$o"@[z=W2ܰvClu?/>lՄtuxWn6S&M]Ybߒ0 -1YTIʮt՞O'wHI$؂:w ]Zitx[rnִsݐ,du2JϨ͌JfF)Km'2qɻj*H:tt5{c#O+#N;OΐNٍ!kL ɭe]R:UڵCwnww_ l5PQt)Um- ZVjm5`[VJ:U*Ľ{tf͚C"hESXQS.KMd UT^;kXaeEh{V}26}M2Yt[b2UINL ^&iM}`1_K+ ~ Rl[VfT$o.?@ӧb@ꔔS4*ls"CǏۭB<855m-ݱ ]_|^XϢi~ ͮ_qU na(S. LBd̘Qոn7(/?X {\# >ڜ'>Źz)Ad1:WٰqZ$MYK:b ęCJx0 wS gY d\懐XU네Z2ߍdHo]|< ot?aA֟msB'u="*X``n^"o޼N`qФxQ뚝b2}I 1e׏hkNl*ǙH?< ,E+PpsF;*qcE^#@F{4f&n<`!m|G9۪QxRߌx= f|<EXb$~ڧts'm\ >?j>q@gVȡFK+]6JaI3e7Us`蹂'%e^Å 6/$8t.!W^>`8R1 ` a<Hϣ r7~KS<,\Vj =k$ Ikz#kf z ܛEYʚcLƳ4Sqs/y9ޢn<1_e>7W#n?V|2LVk 4ˊ___l .bHEݯPˮ,9}LגFNA+<fwn&T/;zA@{%gx?YSݸ:19xWnF}W5rq_֑,0lMw7g4GT7|A ӗ:UC?zВZaj-gE]:;iZ%yMO“CV *EI|QdYYn^\bu[}!Bώf;q!W4'fNWhtp "vrZ{@mc߉htbATdeNZ :%B"L3±QI:`ecQT|cD'+VSeM l5%u¨uZ]4.eT"A;ỒJ9z Q"ٛ)om?)FvX[3VU_hk|/Bke~+M~<ґT',s~,!o=(]{cF_m{t'(X9Y;a$ p` H@ fRzv(R옗{ڴ@8px ƹxroYjQuqr9o#mm=]-ZӀGpкfTb^nژ]wBiu}< 5>$Fc08? h݋ܸ{,z-'nD'=/gNm$Bd8;H5bR< 3&ć&MāKx s"-N&,{TNOBq%Dnݳ NwOct*Yt-!3`hWi莇a.}6ujb&_&*g1Ə5}iվѾ%(4+uCڏyYD,m?y(S<#CI3 _Ea"N1p'PA X?̮~˄?q,b657;DZ6/0ohx!YvL. "X8=xVn7}W SIߒH 6fݑ1E.Hd~G %=Cnq"g眙Mw_SlT2LotNu)8f6lU%9mU@KU Ƕ1T+:rHϪY[pC:[h!\F]E.;]Q|K3&P'WWuQ &{|TZQ5QacAMi,+{oϻ*i{ [8Wj# *O n޹D]wPuj_ER\! ut~ t(W=^\NJn8W59{qCj${z*m GJe8<"b*'t݀|LVPޯҒwԢJ$̽|!m_= )^"릞CKis:%^O@kz(\:!$/ g cIQLdZg R_$AԮ[F (Ё,ȋ0;,X+H8;;a=-w I} 4JKϺw=kQ:!<@R9Jzq˾čj.۶0o!G9ˀq&VP;pӻmD04CإZ":Nx] pAN/DH5>4Wg0L?@30CF!!, 4pd>V33 K:1Axklj`W%ȩ(ڒU:!X,X9I|xMzʹkCt?)a[Kb8xV>-eo06=}𝡂cZk:ZkCA;Z@|B`^Hٛ_..ON]DpZ0(JB}nU{&MFO=d ZRu!@̔1Hjǭ2B;T:5 hAKD:k5'Ј"i}i!<ϻ!6$ JTF䬍ڀb\Eoڬ͎{3JΆc hS#V@"QV{-\eRORS{GO8MP٠s5_=@<%UJ>uQ.iXoN?ҹg 9AOomq(-."hC]kPeTSLXy)P[LAiixwMIp'~sJ1do-YWh| [O,j`3Bu+z$/hGC4E"CscK1v'B;2g 5<20tqrkxr-_%`xXkOHw؍03ҮMQfW ]nܶ*UfFjSu}SѵK#-{tR&Dd|*LU{m:("LR%J*kEcJhS\DcBEN%RDhJTaOߗrV'v#M=,rd-8?4Hd8K=Y ]T*wO}\Ôs4])ON󝨮6ScŻDQQrxM4+SI*BIwTULX%T$"(:,:H1ڢӃߠ6z8Ǣ80p Mbs*FQI`0iGboKLx [@r~T[,ޔ ^=A/7g)13pƴ9o0DTwm\Z}`7_1g:q4n yQw9NFenK0,zAl+B?Q{ˀ^r˿0NM>'aAX+"`k> &#FY aux;soqsT4p#4< Gg8|+4` v|%ӣ[ -^Ixg$Ѻn(/wm*-pM=$^lly훓d*7|;qI1rn0m#e?+,&Kv]~2E`7&a.oW%?#[l2Dԙc?gQ?*SmW@rm'2'j],.$^>ߒ<zxB2M0L} Uujb5ޫh^3A>ա>,i^2Qexja` L=H dL=bMQ|7l(xS={N۶4ǞíI?SAkl" ͼEUimg(<-4:7̧eh A\G{jG כ1s ߊvfvD$ x,3 \0MrHjx\6k1ޢgՆր aԝrCwCmLU [1XV.2,{#@cNpxlФ/ NWCbCA+]Mٶ"TcFe5%$4sHٿ x\rF[|16طTTrJmrv$UC'!Yjbp~=3 % J&`$RCAyԬtV^jꏺTa",+|e_gobjf]LNnˤusyj7Z6Y\XI DaSiuXgѝZRۼIc'I.ȸI" š]WDչ*f]jv>S^V0]RUA5تErUQqIUS3$QEK eb pVh~<,TQ4èn4% &dym;b$y/< JB$eNbVfU5**"fQa} ( ۼ $!A M:o3'%za9heJQ*rb:"†PƊa[ YTX]xi@d_ij.˼T`H2It ˼(0w0HVtMGbU6<1_i ^ r8+FeeN"$|ntl3<hY\-+5sRw$882S[,?!ODBp: KyDw3Y05p!BE`h=NOW_2W1cg& %el ȍ%S G A}WhBRRg7?#Ta^q& s!t8?ps .t McF `rҰ=L܏RPl#.EKH`DiE*>J0ofdBԆFTp.nۊGTR4vS_DZ De^Q'0V ]b\+Rwq1 9p*6@>n HC)e--D08ee&3EEjT)-gPT<9UA@ϰuSfh=h"GɌG2Yt#ϸj$`".~lF.cNO u}=MXb 6Ic^Q@gNݲw}^=[|+ꚗŠxX@ bqóT"<_,씖1S *>`íe/jz8wz!ɥ3bɥlR6?6[ m/k4~~YH&n 5.zNpXq"SATzL$ ;epW@MBwͅ,~g4!]%-Nq)N)7i:BT\96K #qUҬ-'03q gG ?K_" 3y9nA@nj/cOb§-Mb;θNQSV}l6Ü+ᐈWN B4[=_x3f~ʋU䐧-kR18k͞fpDnZIG^i~|ROLM9S,>m֭Ӕ:S=2ÛjV9GE$+S fiə%G'Irg7g"eH6\1C̔W1Ń Nh6ґT#,e1C&+cPyN7Jmi,MTM5xxEVD0+1ךюVHڊ)G;',tdmO , "=x xffO3^,z5KpC7|%-zp}G޳ݕyo\_L9T S`w5v`>L[JeO FNfDu5cmu՞l™npS^x,zb)/SA߂-}GVrWĕx5". 2Y  cG [K̀3BM'=ݞNQ餥RM"Z%ci*:)mʘ@dgs<#/`Vlψylp9j)2HQDxqŝDj^2TQ(uxE5Օ=; 7Te@S~ O㰶),;|ƎimK-7c8.,@nhT/cܼg &2. 6P[tڇ84\${ߡJEb{Y}3 Gm'bccݔ̵q^-W*ܜ ԭS mnoہv|aѻg"O{x=N(^2oh=aHf1tjREqFouJa{SY~LԍI74x۠MH ۥR!i;Dnp%˞q*Yۊ#s'-Qp-|D&Ϳpd/i|ѵRzж>KaQIueZtbRP=;chxrfcBR- mܔzǶSwO;r}Q3ɒ=1wAݮ.6,kw*JJOmmX,٦Ej< wu{~8=CX&'`O&{7;,e %]Kc7T~ӶT j/.J*2Yj/_/vklGji4J*7ݹw)Xļ%&-<<,$,xEE\pةQ[f~S^= ?fs1.HzC6Uo .lr ]fDJh;+y{,@;ǁРRbGCv*#D{>Siek)Wdeݼm]tl3?6 # Hp&aD'0Y, c@^?|[edqnn'LϚ|)e5R{zR˛7+<^G\{#u峐twR?e;,u~x)E;QVMo-;9_&fj;fsQm;_Tբ_{J~6zb XW|6|;Q]@pM/WiK߮QǍ}*/QW$mzs<2ýnh#F<>Wr 157b$+ꤤ'HG)@mY+ZUiAJCaldCM 6\ekO,MU3{ez(lg[ݝ=K2n .} чhKhiAG'peXҷuPr97yxXn}bC4PI!u\m8P@xCrywVt ~agf)E["gfg̜u%^?)ìqb4D."|TeӬfuI3j#s4mUb^WF;=h8SQIlDf+UJ؍4*+|jat JS<7mn#KaTSi,.̐o=8MCChّ}FRD~U>Z!TSʜ,,R;H A/!cupp^UOVZ~ .2p!Ȝx$Җ^e̽%{'E/z(;!KY3+E9'Fx8`%G?vXezGXeM*4Wft'B)g'!ȱ4lfL.TҼ{$2 [͋SQf9^xx*N FڔB9&g5aqxZ,a>%)R -zVg/VXsyoEA&ح"ZsL)z,S>c\ڬe5I uW21}x;iD:)*!CM#&vYY4Q:RmG?ff0ܸ؟qǬ3"tk!n,1[9"ŒH#rU+Wc1$/.DY[ 8/"6;Q uWgƊBVs?:?ŀG gFnN4o&ި>5'M3UF|:qP{!@&{{}K [{P PNݓY7bC'D5|~]dA|#ziFݮe`,l]:k3iO 8賒= OKkс?_zhz/,4!%_{?GIRc! 7,싸Eo! YQ9C%l`0 d+GcY2pHw#y\R읉R1`3VIϝ@LR߽ysq?})ݨؐqHVǍq79̈́:YYRYo7>~d\Ȭi{x(40000 express-in-zip!fqE% [b:C[40000 hello*]sU!40000 local-service{ej))kĖO40000 migrate-from-beegor#x#TŊ3-R40000 migrate-from-chiI:'CѫSC)40000 migrate-from-ginNQtecè )~P40000 module-routesl` 4A^6Q40000 pluginGҝC:@=Ʒp40000 sse-streamingcATe;:Y E l40000 subsystem-mountCפq q*3A 40000 websocket1<X.Ee-640000 zap-typed92i^# ֮(=E*xm100644 app.ts>Äxچݛ9100644 main.go{

nJe<.4xXnۺ;~ Nrgio .: k]4AqmwVZmpbϰORh$:SqA?ճzimiFDJasm݆؉Jh̬x)D~> {l&rNB(wt( mU-a%YJ!ѵ쥿ы=b ;p >dA󗱩˭8S$Z SiVy R+e!~/rY af~vklJ,2?!gbkβllNzw譺9_9)z?.)(xFv )0\)yD(A?etMkiM' ̇}7$}bۮ~E_h-kj%ں jh%YACcX&1.5q-8vJs$ݬQuMf,aOwzN2L X mº$+0NȮ`,wr=t-(N M.F m"c5tۍ(WK\B~#M!g{DJ1+k>fu7Y .!H ? 버>=-W {(оiT`)9ݞֹB:u@»Fhmd //A}GNyݘӎ,5 hIZms uϒ 4+Uz@A[Ny+q uγlN`) NRK {n+H2N_C1=,I=xne_`˅ ȧGt}y ci}a]=Z/5jK֪@{+e*/1XC!7]~2vf%{-⹯P Κ{ಶ#!:;iI?Sz۪PU`ާN q[&'3P8V;aIכ#BS³^Y7M5<7U6U!iX# x=P$R\7Lf'.foJu{Xf_" F j0 Aא eH hp) <)kKFm$=>% g:~}gB _=A9:F!`fo#J ߗ[\'GHS 8t&8  59 1zrI0 :|g mܙsFˋ#SVߒi3f{1U E!G([6UG73H&N{_lD;LD䯏w B?_t(4s^@aYG-PapOCG!"!Wpߊ*w~ɶ5ɢ!my)ރԻ1%gS)h}_ީsa[_c)Ҥ gvO:s|aTMIsƏ.~~ow+vc!pWX8l\( Uc= xDlJ4YDưC@SI[(uth#+H3Bt#G<41͍xB$I^0{$1D3ܣoVvreISiVkPĢ%S9iJ˻wxVnF}bB (c(-*#61,Aȑjދ0ЏK:K%M(B3g.{f a!v1Cdds< R޳n0_dҁ#4֘)4Fj?3Q]xsk4w=VhH5L.Pn{INX&̩Int2K9!lzVұΒ"YqMi5ewtu'Wm帀n%DkaE#Q9hX˗ ί]g^Пӡ=qbVyQr^7:2&&ҧDy;{Fo$Jfp8&|;m{ t<&W-X+7]tN*T+`Cv;&ѽ^ #nvR B_ pvTϸ K\"qpNG)㉢iXf%{_n:'n6vcNq VkmPH?-8뽋.{_ ѼKe}*E=0gl-]7%*{H9fq%,n}/!3]bBsJJǴI]^ӧw)޳a5C)SH[97wJJr.UO`Sl *3ʻOpAquN={O@K[Z`tC VF (B܄rLt>a7;hSd=q=x!k x340031QM.*cSx@^m34g_1(JOaX}kR '/U}49Λ<~ v)CU&f3>^fTNYx+II|Ijq H]> o&1 ^jPv* %?9>=lz$3URYxn{ "mcpServers": { "notes": { "type": "http", "url": "http://127.0.0.1:8080/mcp" } } } 4t)nxc examples/local-service+sqlite v0.5.10 @36.47 )ep/dustin/go-humanize v1.0#hanzoai/csqlite v0.1hanzoai/sqlcipher v0.1E!Zncruces/go-strftimep (-8remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daecUw0.0#88.3#PHo W6z1J B modernc.org/libc v1.72.3 // indirect modernc.org/mathutil v1.7.1 // indirect modernc.org/memory v1.11.0 // indirect modernc.org/sqlite v1.51.0 example runs against this checkout, so a change to zip and the example // that uses it are tested together. A copy outside the repository drops this line! ) .. tool zip/cmd/zipdoc dS%x&`kI}dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY= github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs%6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto'JWpprof v0.0.0-20260402051712-545e8a4df936 h1:EwtI+Al+DeppwYX2oXJCETMO23COyaKGP6fHVpkpWpg^pprof v0.0.0-20260402051712-545e8a4df936/go.mod h1:MxpfABSjhmINe3F1It9d+8exIHFvUqtLIRCdOGNXqiI2csqlite v0.1.2 h1:4DzdgUfKADhzEP66Y30/HwepuBLrwt7NsemJMfrPGl4= github.com/hanzoai/csqlite v0.1.2/go.mod h1:H31a/O6VXuklR9UBkgY++bmAK5uzVfXPqU0F6P9Wsos= github.com/hanzoai/sqlcipher v0.1.1 h1:GARjSiUEa1lwhd1/f87XRaujZBG5s1ZwxrZW2Es/ADI= github.com/hanzoai/sqlcipher v0.1.1/go.mod h1:F0soUYM1i4sawOZUpRvVnWoUayPbeGVlGq01VXy9Aqg= github.com/hanzoai/sqlite v0.5.10 h1:TY1YjsS+2ybZ6CKZKpHY01kT0aGdYQBUad2vJV88Jl8= github.com/hanzoai/sqlite v0.5.10/go.mod h1:6MOvr13PLL+ajbg6SGf1nSvqDsCNzKIvwrLo429LFUY= github.com/hashicorp/golang-lru/v2 v2.0.7 h1:a+bsQ5rvGLjzHuww6tVxozPZFVghXaHOwFs4luLUK2k= github.com/hashicorp/golang-lru/v2 v2.0.7/go.mo0d h1:QeFd9opnmA6QUJc5vARoKUSoFhyfM2/ZepoAG6RGpeM 24.3 h1:xkUKRWvQ4ZwvlUC2e0/RTtHYZOYSMvSQ9W9lbjwBmiI  94.3/go.mod h1:myIkufyiQomSQH34K981kbz6cG4WUoerRUh7F4XhlQI ?N20.3 h1:pFlQm1+5FuKTDUh2y/23bXWkN4I2Rc5iuxJypwDFFMs ?pq v1.0.3/go.mod h1:8bppZcRElfrVt0n3nYCZW3iX1TvhvzNbdjNdK1irgIE04 h1:9A9LHSqF/7dyVVX6g0U9cwm9pG3kP9gSzcuIPHPsaIE&4-ncruces/go-strftime v1.0.0 h1:HMFp8mLCTPp341M/ZnA4qaf7ZlsbTc+miZjCLOFAw7w= github.com/ncruces/go-strftime v1.0.0/go.mod h1:Fwc5&htZGVVkseilnfgOVb9mKy6w1naJmn9CehxcKclremyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec h1:W09IVJc94icq4NjY3clb7Lk8O1qJ8BdBEF8z0ibU0rE= github.com/remyoudomphceng/bigfft v0.0.0-20230129092748-24d4a6f8daec/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo10.0 h1:LAhMGcWk13QZWm85+eg8ZBNbrq5mnkWFGbHMUJHIdX 90.0/go.mod h1:oDZEHHkJ/Buyklg6uURmYs19442zFSnCIfX3j1FY3pE7$#+26.0 h1:Rw8j/hFzGvJUZwNBXnAtf5sVDVt+65SK2C7IxCxZt5o&:56.0/go.mod h1:D3Ku6r+V6JROoZK144D2XfMHFcMq/0zSfLelVTCFKecQ)(R01 h1:fV6ZwhNocDyBLK0dj+fg8ektcVegBBuEolpbTQyBNVE-$1.modernc.org/cc/v4 v4.28.2 h1:3tQ0lf2ADtoby2EtSP+J7IE2SHwEJdP8ioR59wx7XpY= modernc.org/cc/v4 v4.28.2/go.mod h1:OnovgIhbbMXMu1aISnJ0wvVD1KnW+cAUJkIrAWh+kVI= modernc.org/ccgo/v4 v4.34.0 h1:yRLPFZieg532OT4rp4JFNIVcquwalMX26G95WQDqwCQ= modernc.org/ccgo/v4 v4.34.0/go.mod h1:AS5WYMyBakQ+fhsHhtP8mWB82KTGPkNNJDGfGQCe0/A= modernc.org/fileutil v1.4.0 h1:j6ZzNTftVS054gi281TyLjHPp6CPHr2KCxEXjEbD6SM= modernc.org/fileutil v1.4.0/go.mod h1:EqdKFDxiByqxLk8ozOxObDSfcVOv/54xDs/DUHdvCUU= modernc.org/gc/v2 v2.6.5 h1:nyqdV8q46KvTpZlsw66kWqwXRHdjIlJOhG6kxiV/9xI= modernc.org/gc/v2 v2.6.5/go.mod h1:YgIahr1ypgfe7chRuJi2gD7DBQiKSLMPgBQe9oIiito= modernc.org/gc/v3 v3.1.2 h1:ZtDCnhonXSZexk/AYsegNRV1lJGgaNZJuKjJSWKyEqo= modernc.org/gc/v3 v3.1.2/go.mod h1:HFK/6AGESC7Ex+EZJhJ2Gni6cTaYpSMmU/cT9RmlfYY= modernc.org/goabi0 v0.2.0 h1:HvEowk7LxcPd0eq6mVOAEMai46V+i7Jrj13t4AzuNks= modernc.org/goabi0 v0.2.0/go.mod h1:CEFRnnJhKvWT1c1JTI3Avm+tgOWbkOu5oPA8eH8LnMI= modernc.org/libc v1.72.3 h1:ZnDF4tXn4NBXFutMMQC4vtbTFSXhhKzR73fv0beZEAU= modernc.org/libc v1.72.3/go.mod h1:dn0dZNnnn1clLyvRxLxYExxiKRZIRENOfqQ8XEeg4Qs= modernc.org/mathutil v1.7.1 h1:GCZVGXdaN8gTqB1Mf/usp1Y/hSqgI2vAGGP4jZMCxOU= modernc.org/mathutil v1.7.1/go.mod h1:4p5IwJITfppl0G4sUEDtCr4DthTaT47/N3aT6MhfgJg= modernc.org/memory v1.11.0 h1:o4QC8aMQzmcwCK3t3Ux/ZHmwFPzE6hf2Y5LbkRs+hbI= modernc.org/memory v1.11.0/go.mod h1:/JP4VbVC+K5sU2wZi9bHoq2MAkCnrt2r98UGeSK7Mjw= modernc.org/opt v0.2.0 h1:tGyef5ApycA7FSEOMraay9SaTk5zmbx7Tu+cJs4QKZg= modernc.org/opt v0.2.0/go.mod h1:03fq9lsNfvkYSfxrfUhZCWPk1lm4cq4N+Bh//bEtgns= modernc.org/sortutil v1.2.1 h1:+xyoGf15mM3NMlPDnFqrteY07klSFxLElE2PVuWIJ7w= modernc.org/sortutil v1.2.1/go.mod h1:7ZI3a3REbai7gzCLcotuw9AC4VZVpYMjDzETGsSMqJE= modernc.org/sqlite v1.51.0 h1:aH/MMSoayAIhozZ7uJbVTT9QO/VhzBf0J9tymmmuC/U= modernc.org/sqlite v1.51.0/go.mod h1:tcNzv5p84E0skkmJn038y+hWJbLQXQqEnQfeh5r2JLM= modernc.org/strutil v1.2.1 h1:UneZBkQA+DX2Rp35KcM69cSsNES9ly8mQWD71HKlOA0= modernc.org/strutil v1.2.1/go.mod h1:EHkiggD70koQxjVdSBM3JKM7k6L0FbGE5eymy9i3B9A= modernc.org/token v1.1.0 h1:Xl7Ap9dKaEs5kLoOQeQmPWevfnk/DM5qcLcYlA8ys6Y= modernc.org/token v1.1.0/go.mod h1:UGzOrNV1mAFSEB63lOFHIpNRUVMvYTc6yu1SMY/XTDM= {YxVko6l; Ȥ@a m$ u2Z LIF&UʣA$ibIE}s\mLPU'Qp|5n@IYd9+y =co8?XlTɋiU S~7\zO+uhqKj vlgMZgH]-"We*Ð`O %/_|ĨT(4gɉw}4j1Wö 3®ha}b E$E?>qh\nK D;.6U.˜'kJ_ Rh^}[s2!=VɚK jyyb[+m!~$e%,gNJW[wc100I1ArXO>j|/}.+J)}[cuSXx(]4elʮ#֒7 iw_:i"-":M{t2m8ed܅^?\_75O|?6`>'WpymE .*.Vt 1_u\MXlMv(aQ("V 9/ U#  ;3~]\k "zI,hIQM7NZm%zG'N/,/RX&)d`zm6_;lHOgp5^g]ۅәLeAJ#rGx j+-]!`݌%dEُm'Dr0}I`MqX "/Ϲ`Ayto15\ԲRCS%s,<-n M:pI^b*ўrc' 6+m;;*2|x0]>^W/4~]Lr'Bc :k>~t[.a5CJ~Bn %NB~av JsHVa;k¯0#SOMzX['oq2(*r>ɨ$l,P] G~`j$JއkJx3package main import ( "bytes" "context" "encoding/json" "io" "net/http/httptest" "path/filepath" "strings" "testing" "github.com/zap-proto/zip" ) // newService is the service over a fresh SQLite file. func newService(t *testing.T) (*zip.App, *Store) { t.Helper() s := &Store{} if err := s.Open(filepath.Join(t.TempDir(), "notes.db")); err != nil { t.Fatal(err) } t.Cleanup(func() { s.db.Close() }) return New(s), s } // call sends one HTTP request to the app without opening a socket. func call(t *testing.T, app *zip.App, method, path, body string) (int, string, string) { t.Helper() req := httptest.NewRequest(method, path, strings.NewReader(body)) req.Header.Set("Content-Type", "application/json") resp, err := app.Test(req) if err != nil { t.Fatal(err) } defer resp.Body.Close() b, err := io.ReadAll(resp.Body) if err != nil { t.Fatal(err) } return resp.StatusCode, resp.Header.Get("Content-Type"), string(b) } // TestEveryOperationIsInEveryProjection reads the router and checks that each // typed operation is also an OpenAPI operation, an MCP tool and a CLI command, // under one id. An operation added to New is covered with no change here. func TestEveryOperationIsInEveryProjection(t *testing.T) { app, _ := newService(t) _, _, body := call(t, app, "GET", zip.SpecPath, "") var spec struct { Paths map[string]map[string]struct { OperationID string `json:"operationId"` Description string `json:"description"` } `json:"paths"` } if err := json.Unmarshal([]byte(body), &spec); err != nil { t.Fatalf("OpenAPI document: %v", err) } _, _, body = call(t, app, "POST", "/mcp", `{"jsonrpc":"2.0","id":1,"method":"tools/list"}`) var list struct { Result struct { Tools []struct { Name string `json:"name"` } `json:"tools"` } `json:"result"` } if err := json.Unmarshal([]byte(body), &list); err != nil { t.Fatalf("tools/list: %v", err) } tools := map[string]bool{} for _, tool := range list.Result.Tools { tools[tool.Name] = true } commands := map[string]bool{} for _, c := range app.Commands() { commands[c.OperationID] = true } ops := 0 for _, r := range app.Routes() { if r.Op == "" { continue // an untyped route has no projections } ops++ op := spec.Paths[zip.Template(r.Pattern)][strings.ToLower(r.Method)] if op.OperationID != r.Op { t.Errorf("%s %s: OpenAPI operationId %q, want %q", r.Method, r.Pattern, op.OperationID, r.Op) } if op.Description == "" { t.Errorf("%s %s: no description; run go generate", r.Method, r.Pattern) } if !tools[r.Op] { t.Errorf("%s %s: no MCP tool %q", r.Method, r.Pattern, r.Op) } if !commands[r.Op] { t.Errorf("%s %s: no CLI command %q", r.Method, r.Pattern, r.Op) } } if ops == 0 { t.Fatal("no typed operations registered") } } // TestOneHandlerBehindEveryDoor calls the operation over REST, MCP and the CLI, // then counts the rows: three doors, one handler, one table. func TestOneHandlerBehindEveryDoor(t *testing.T) { app, s := newService(t) code, _, body := call(t, app, "POST", "/v1/notes", `{"text":"over REST"}`) if code != 200 || body != `{"id":1,"text":"over REST"}` { t.Errorf("REST: %d %s", code, body) } _, _, body = call(t, app, "POST", "/mcp", `{"jsonrpc":"2.0","id":2,"method":"tools/call","params":{"name":"post_notes","arguments":{"text":"over MCP"}}}`) if !strings.Contains(body, `{\"id\":2,\"text\":\"over MCP\"}`) { t.Errorf("MCP: %s", body) } var out bytes.Buffer cli := app.CLI() cli.Out = &out if err := cli.Run(context.Background(), []string{"notes", "create", "--text", "over the CLI"}); err != nil { t.Fatalf("CLI: %v", err) } if !strings.Contains(out.String(), `"id": 3`) { t.Errorf("CLI: %s", out.String()) } var n int if err := s.db.QueryRow(`SELECT count(*) FROM notes`).Scan(&n); err != nil { t.Fatal(err) } if n != 3 { t.Errorf("notes table has %d rows, want 3", n) } } // TestARefusalIsAProblemDocument checks the error body: RFC 9457, not a shape of // zip's own. func TestARefusalIsAProblemDocument(t *testing.T) { app, _ := newService(t) code, typ, body := call(t, app, "POST", "/v1/notes", `{}`) if code != 400 || typ != "application/problem+json" { t.Fatalf("empty note: %d %s %s", code, typ, body) } var problem struct { Type string `json:"type"` Title string `json:"title"` Status int `json:"status"` Detail string `json:"detail"` } if err := json.Unmarshal([]byte(body), &problem); err != nil { t.Fatal(err) } if problem.Type != "about:blank" || problem.Title != "Bad Request" || problem.Status != 400 || problem.Detail == "" { t.Errorf("problem document: %s", body) } } U#x?// Code generated by zipdoc; DO NOT EDIT. package main import ( "encoding/json" "github.com/zap-proto/zip" ) func init() { zip.Describe("github.com/zap-proto/zip/examples/local-service POST /v1/notes", zip.Doc{ Description: "Stores a note and returns it with its id.", Fields: map[string]string{ "AddIn.text": "Text is the note body.", "Note.id": "ID is the row id SQLite assigned.", "Note.text": "Text is the note as written.", }, Example: json.RawMessage(`{"text":"buy milk"}`), Response: json.RawMessage(`{"id":1,"text":"buy milk"}`), }) } c<x#100644 main.gowz'd>,r ) wxUn6}bB liۧ>n d(6kdIZ0Ч~bp3l]aQ9sf\++KXYٌ3ru;Rf?(Xݙ,-[\z_z^Lۖ.Q\,r<wX;{ pv!UKINѝgӵsplS)P@Hh3Ά|QytM-l=F"bJ6:bzJ5q` ig0 !5ۢ0{;g;~\ZV(,Xi wXvODj Pm'MCTLgKYKE#qRj@+$p3ވVH$g_5{Ұ+~(%3MΓ <}WlW1I!;0 Wޡ3Z9J sp9ա9BpmsY:cʏt-97heZJ⁡G!2=N鄘MdIbkN|]eH+AE uds/|x$& }l} t~tY3'r5b-Cwlk1\9dlhAk&b`N&=@693pwJ.Xg靖HfЋ7r-e9DFFM,sNi^T4 ĩu˾(߉-j仯1gfTM/‹6cnE*K䓲~U/`x#100644 main.goV`lU~xKJcU߶ pxVnF}6b@id îcc*(9vK1O_/̒,  33gΞUJVVxIk)s0m9'";kWMB[ouCRVQ"tTCgtH( nԢ>\ ;h_B5ZXb '5_-y ݀q)4]Jg/CQ\tp~ J4G#i{xlKMv%3QRx\aIO]3T{]\ +W4(4@Ho%5V}uRTg7(uѬPQ}w~C5Ԅ _k)(c.ȅqc%D|Q|J2t\zؠbƲ/jcPB4X0 guh\AYK5i8$FꢬZ7 r! 7@^RAg%hEiJx ujШNAQ!TQ$WF[ItZ }ڈ#g^埄91V{o+YZa1҈F)Kk - u%27OphDwe|m EѢQ$)ܡ]cp;%V&iap܏Ѡ)l6BQM}3ʟL)|Fj{N.ƴ#\Fd Mf'a9uƯ~MIڞsMCwiؘQdoR@tzrj.`w ܨ` [Y@; mZYe]oXvz2r썆v(qi: oAa&84k>u\o8`{:ZKNZE+].5q>": q#WS>y=I+&rq窭c><A0*Ѽe^!>s68{>M+//㑘{{WʫUO1.9FjdUѫTƭG׺zE{GV:CN,ޥo-RvK+jtEkU+Y|čuFTkc]x'ƇH 妱u}^0L6%"qŠVzDbc޵QʭrVL,h**ӛEAZ^ :6 gɇ3E[J2af]62s*W+m㈷ۋ#!kyhx:RS,QLK!ᙪk)fixKj>& Z?W4]k],k Fm;/ Uq2<6cb\Tp-586<|)&% n CKZϥ, c;p:2VGluB-nkcQpɶc9A8KW f!6i&G ֳDDiyƽ􆯰ʘؔ|#=:7wҭ* vcyZŮ%+dybdHz=vFPf%FAV&vl pw 2E7FWY6`S68*1 sf[S(4@ b 1.2BHdfs0t3tG+ef k4Oש: 3ע5f[']"^5}@x|Ξlb 7&VS"<9b1}/&qvn/P|fC|@4{>qzQx=ʼnbztg7C_aI]`fFl=iʘ:)I2z6ykPC;@x-J?1@M-}}a\!sIҲAP3BF`IՃTM8 0 ,ie#Gvu1 Zw EE*h 1^8"2ZQ\5B#"ٴ8HspL ͔߬V82%߈vN~ ZȲq+ >m@2҈fAxny-.,*M ֺEXґ'ph6,"a"Aۻ}:U@2UMR62aȠ댺Y 땟`]6c1.Ip1i٫ʗc4~|:?4F G3P~%% q50oG{DRG|R1ਘ]L5Nbcn^rB7ٙZDj]IBpc΅F8b- ONfB$Ӂyst@[[-uٳ8 JZᪧwҕ؞0);ڧ:GQmaq]]a7htw١ugzskEg-c5mǣZAQ|͏z/T X8~|%NA?J(:V0ND$t"o筮eݶRqg+m|ire5s02SAgpT+L[FTWε<_8yqec0ID5iZٸ  CYGq0Ĥ 0}wj*pjق-B+#6h:w4Kg|ؿǓ0l_&;vfxf100644 README.mdP\DqU@䈯40000 billing~\m-z}X40000 host L%9/[aw-qxWˎ+.[8xů3y HȲH]U6 xu||IνUlMX<ܫ[1Ckw2Ъ@dړd'{4r3*!XRZ74P0dYQmh֖oKufhhnQ8r_l'9[ST[iL?Z?!jH}UR:~OV]h{tp~kE<'eJ!*+j9Y\sRA4muԁkvWk[\y-6Z;iSp[=iG?mƓk=T5::М[zT:):xϭv{P-:n6aٓ~tptuSWLνUO3\]]j.WI#9.EWFà fw-jn澣w?t sZ3B:ӫF .$<ˈ4Rq3R̰F^?;Pۭg唾GXTS!+LAޯ+ۏW[|/?'p~R맿yBP(;j^((i;iuUֆ0vۘN%^l;=x|>G/|גZRJo;ѻUmUX}q." i~c̸y wσ {i+iM&~rGt󞔖>-eN7O7~_7S{xZ79]>-ZdxSD|fٞvaU`چ~LXGA?r\%.~@JGHfUl'@|&D * $uG)yf;wLmQԿ( ڥz: 5[뷺A']rH^˦Kyjaf]7K RjPˡW>zS%AHc#HI%)# +tolq4X2D:o%iIG=/gnZ3P#֎A!KD 6jEe ? f:vԦX*gR:LfDYb NdwZu{8PƅGh ̴7vr Ľ)fgG#_KDn;AqV1Y!Nsw[ΐRK_@^i=#j K[3&ƾ"\r5qA|VR0xWv8fB/94φl4ՑT:EҖ}mgY #` ;dʲ/-0%V3o!wd؇b)Ntͩl @: =#Թ3p}R%6?6\$ i4jx*$XVe7RjR5ohUjMA@FUI0CxjTS1 i\.K?"Lrcw_(OFq\pLEM~KV85Box j}ig119ІkT5]̲€iLԲ m쀦 ;u5cA@wͼj,w2yW/ȟqL2|"7bΎ#q e#IFIΰrSaA\.!V@?_/rWD/p93łE]tbȺRHtϿd,=}_/ 6wJJl Y.кQNjɜ)IPc} ) VylH{,Dc M`K H#ZhQieR+ ֶ~Pc(87D!Әѻ#1p q UNXۛ,(EG]rvbN޲_Z tUrWiuF%/ Pvi\HЀ>B?m^ Jȸgṍ[{ӽhu)ZN}5P(v}X bY}/ܓ`oJw5"z#cNg'YqSZSzsu%巺m+D |qn"Gj%+߾}"i~ ?Aлay+T'wC>:^95qhFW ZMqR`zp=>0>KDgƶ Oa"aޱ,Z.8w#&o"vl\Q?U>h\~݊?V }}J ӈ5y 0+u"0QFlPZ/紻{R^n b-G>Rt0"݌%[~KqEިC+ۛTbkw+5K7Ԝ$,w Bٱͅx#100644 main.gobWIus//.ס xVn6fԵ[jۤ]$-fðR'$$e ! {>GJjI$s$$ںX;ՖR͊Kfr)𽭺>n[ V$d(I*,gp' ţV+ QKՌFa\7n\J/~e1K5jd'Y!ef)]ft ܶau˝];:ToI#?FoGwvK^qݒNNؓ\Ni;׻N?raUF_sحM0?6D/PZv𸼟©2I(C=u۾Wf>dKP-}P +Lφ%*KHQQo ̊Yi˲Nz==8ztMm|a89`xfxC \c;B%r|~- r&Ucϱ3eg׭!_ Q V-ߵ($ 'VxA5Ewd-(C$|o@'軎`PWn|_!oW l1eY*LZW!5EM"&=͗#fy( Kh<{%WFan@Fe熸^v{D 8J?{e0=M&;T'-nx#100644 main.goP MwDg fxmTQo6~~M9$wO<AeHΰ-,"IЧw"[â#z :~t{tu={KUA;&d@W$e 7NW0C0=qގ1A΀5ė/rH;,j77rG@`?g4i48UB2 L閿dW/aGi[m ]+tp>X0G'SHP=rywp2`l.*@kT=BVFkEͅa`<.: ZYG%Vl.jo8!&<$q Fjć[|9Ah9GFRİWuܧ=@FƅFIZ,.]AmI]Чp?Hc-+CFղ胤fqN wwVlH;@hml>$<[ܢRVN3X? -9t=5%: )y{@3ܮak5}"$NH$1d,4)-.C?0Mh#mQ|6'$\̓u!9|JfZXFY8dQ^tf횴\AtOi{1dwG޸DVI s@;6)R*h;ҘA>ʥ?s3s+Aq=D9B328*fj6c$˵|K5?_?>.#R\Z'uh*":_ӑ!RoOp'qbN nHNcɬY4f$&*c뮥't㭜S x#100644 main.golv,z@;m~rzr4m xVnF}bʇ4dy)yp_'}WJܘewe@?_/]R4( 3gΜtJ[9nL=Ѵ.7'NKJENH4x:]kIOۖ4q5 ]"8Jxyg8g0z+jwlŽXI\L,-;]QO$VZklO^+*%UB?H[iQt>7ݢVxx/>`[ʢV:s2кR8SiO솼15yd0_X45HHy_+W/,\Ufת{kT%i NNqlŧgmP ̱\B1!Y;W4BXAH)-|Y%c|M!Qǭ5La+{Fe-א.gcvjr6\&u)uXxqkFNե#PfWV"Y`4r{)j͆K,]> 䌞%L\00 /!ntf>Vl ߹`W}Ҋ0na {nÍ)pv۽p]7jHvaR//6 .*7HZZT5bbx1@ M<0Qt]"{֪ Mˠè0m+x@x@pBQHfoTlJ0QFMYsmM *ZZLxhq3mvU Qz1u3wwNZ ~b&j-y} E'x#100644 main.goOmęd}wC`v]Ux}T]H|E9%6(;VhWiu=F q鳧Ld ;3y4rdXa|_34W-SLRIc&jEKXlzrFa+w<d&m;Sg=):qOy 6 \1uveS"%,ȁk CE3 Yrc[!-$}`IGt ]4M/pS?#j1KࢺTO拁HRYOe2襅(g>y;Fζb{fwD?eˋa<+ǜgծz~a,4T󰁪}xzYUdI`ܩZ!ΣBr>:#yV Px=+L_}&R onaܤ<b)UwirE_L9GɈw<k:}sLRq~׊Uy RnͫrTAMe_Ś ("lOك" ,.6+ ޽#=Gy׶^8;UgiDW-r5]:|Y1;.N<YRu{_~.'"^R,WcLY1:٥ąx#100644 main.go3Ƣ>tWhY|(YxuTN0}NkҤ!HӦ!F0iĤ6ӖJ}dIڰ2vcs=1G2`KZ_y3"+3 ųbȏcx] [vwV7\NafJ⸐)-fhx4xN a0#NLJPK>Nb=FMAjЎ^tҬ!v ߇`o!0ƀ\7][&Uչ&imc< .zN/AxYmo,vI=;@: uEw{V)%1__gfGJN5 g֍,?f_/e!rKwgw#UkEN[~_+7l[B:%B!=JQkƓ`K%dBCr Rڢ]*C슏xDHS9- t6e1?7>n&> 7XR/mAJ3 JM&B{e5AjC* P5wT|*I)h1ʥ,4,u,hM&8x]*v51襋&}oɳ"OBvOVWEmےw@mTkXӕG .Z[TP:*P=ntů k7eRC|#3("\obzA  CJ/f\FD'M_DV}[i_Uf"DžۣZM#~ C&"k! 'DxZ }qD{t^e&K"G/y7ѐR(`ʰdL>yVֺd쎑~%xtUg؋;|,I#Z2g(@!뛜^ά4Y2Д8;m{uC"–2T[ӗBt=chy #Y 904j' wY5\2n>NGR8'Tfeʓ,d,t b 45;h8AǝcA3ş딣S"cpMo[ȏ7|o:%J=AfԬasP%(>7JM!n"tK zL ^jFfkTL4BPPQzu'ZZc=(GNn5!s)m~nb#PPhY(Jx; R Jt@2qR0fpD%DYRp#}Al !):   ER!(7W,띵 ePtr9tN=3Ynxd7L :RjlƱ1UKO%(z$w )_vDټWKrl7<`ZwIXm IoH;Nm% [&m):l1Ѷ@hCo.RHE.4 ,Er'?eC K@؇+vma[l\dՂGLdܲf|;A震x;PFwIOޡ}lMǒ֔#HR( A|L()l}fWE5jݘdD"oj!WڶNq;仄p#&&"+ tDZyo0wC*ReaAI_3dY!+Uƻ>>yctĿ T]%:2n'o ҉ROt5(zH<<[(FrLcBIcf }MjCPc}D%yaX"Ktg]4yU-տSfVZI{q@wa4)ex@dmM .޼xADB²Xm-fZH|7+KƲʙzMA~̏V|L)Bƀ+ G+n~m;^*o(BDupD7ӽ +/:6f@eB)+rUI w`K{>yOn[ıJ?ɆzCMI<V8RϢF;7BH]6K&LSpE{N6~n]ð)BcOC_\ 2WJ8{,BmHm2=b6%.R14c56)D SݞxUn6=[_1K tvs6"q\q$8~D_3dh K͛7#+gQKxU6I MF0:ȗdT'*,'^U؟3cl:cxt1H%Y0_H uABvKU;luC Wʒ:5ԎR LW,Xz:g9qV(yZEx:H?x"--rKiS踪j(+DSu<&pb$nޢI{-D,'}_$$HhZ3 kl=JtMFC]U{UXe_"۝Eƫ.0^=O+ց`)+F&3Yi\@K}OjʽМ;H fWņڎ2FK_sPC #ߺ o엽d=t}m;Xȇ~ BBiƼUOMhGN Fz!({]Yw. mI.;\clsLhg~-eOfv7 O+ id=OhPgU>۴B$ f W*-oMkLZj'껃⮇#]8#x_2&8  ⅗`b?XQ]Nl/6t zg}s.msE g8ÿxPe6"U{n^ZvCS{]pT%Xw߻!5R WxE?CXu&*|*xMRn0>O1mz@EBԞlFؖ$Pzo^N>an>-䌃SyLפڅZ!>-h)C/ P}<7 h\{ˢcHQQhccȭ^r&@ ,=3E ;vA_qZd[J{;x;6%m i1G|dRL]FT7 y!^l?rh<WfNUNKDl[39\o:GuGѭ4mlD[b /k' 7_KKbWKʁz2Hp?n@}76ETջ_Txvf21(xmQN0p$bF;; bv{,`A: =%ޠEZrPJa奦HŕB w #.d#ᝄB<(DNݘ QMܞr[swiB@`0N".V'DͅEzdAXmL$1X ܢVo]ꖪ_PL\Oq"s튈fCC|[}vXm#7ȝAgD9T?{`2*6d潶xXn-=R 3A?x^ qv-`ƈJS3В ЇIz'@ D^޹{WVd6V(h362+%>f:uc]H9g?·aXw>Uu4O^_ڬm_Zkk%Q$)NZ6Ny;MIemNcV>V$I#aÎ`r{6x֧!*]r12=Fܼ;b?PvE;10 Κʩ($T%w^3LB(cWTc̪tgWٔOB㒐kKN$,""ЕNmC%UEePT&8[#(Jȅ)ψ=pȗm D$AАbu'(F,z"cepd,\ zIbx })>M*JD-`ⶾwDGоlM>T~!;ZpwwOi,R_Z<Ӊ.-T+B̗1.KV֬H.1|i.2gt ք-Ӂ)rD]1j8h1|!89y6{INS qpPG507DCJ#IN_QRyWfA~]!' t:A6<+b6Lo,2!k0:w -[ F6`2θ-,pI=a"5+mmǰ+PjH1@ DL4_چl:)1˵J5:p-; E2̲,͂Ol6Z^f0tρ08ECEk#g'i֌E"4âx6j_ExAa,k ۡg?E2RkFYiţgB߭5.K$7>nih$I@Fw#ႁSi]\)u#^7FdQt9w vSʘ KIL"I(,x)6 ˖l=EU+1J51kƶUq۽5#$> eaȐOgo/ ǫzxaJ32]xԷghn, I߃K鼺74E~ qw '3l!>|eI<UevNOy=RPZZSgoٕhbzE.>PG{F Ht &y `}8gHE)FU)RMG?yKJZVM+I-KIde.BSe#K[u^ye/J1uMQ'fs1!Ym #*Kie:,[1b p/+95Nj#>2P'l쑮o|+鱼l^Bh>(pJBmXU^5:9^ƑiϫL͓x4xt@ZՌl‹:5| ec#u3B"CT/jd1@O. 5#;9} W{ys/2&&s߬-ťqg:I'],C:U"CIgaRC(iVrޢ1̝L-S |Kh&^_QPnУstNG Ji|s2>]P&=8븗| ԷbؒERK=7Z^YSK #?3kt!~B9¨Kr|ipTTcf^!4W*X;:sdشa:Vn3$X.̽2("34jZ8mg,7"'\.>NgSVDߙFԷuKo ͂xc B֜ wz9!gB<1-+D"6 GhH/}7ĢLS d_ mDw$2lѡd.ٜgܡGlC/xVq_v; ΟE,4? t}sg)LIAF?g 7 T(0+=v?e^ >[S{H蕵 K}htNZwXԻF\xerhBrBdߠ{4"L1Gs9 ڑ|ֵxѵlՊs隱=g=e_Kͅ6+8UާoeHkLּ$ͱ(PP~hY51%^ыZ 6U/DU3^ 2p{Aݼڊ]؟RxXh "s@WxmTnH` ԋ.)REђnE'q)O;l(gݥWq\o;y= tO~DʯmA;\:!=`cϒxU] 0Ԃ^$i!"*)/ m۝%"Ŝxi%e84jc)1TzbX&Udpz,(R=-PJqxěg0mmqeMֲ]AJ?E]*i.L@Ax}Sn0 =[_ {OC` h9ؒ! 6>Jvҥh @D>=Xѽ 0tT䟁|Ц"nr@{@qB<Hl|e eǃǸ:4S p&y #~);MOshxQo oRRXDB82V4 AIEGe>f"R# 3{&`Yq!>1O }/iQ[~xxUQnFO1% dZMpd7N[%XCqajQ 9DOؓtfI*J]- H,ߨ-GD5$$6HQ_dQ~QEp[ET)\c GI (j9^vj ҡoe ~4U%x'jfYШa<犷4QwJBL=CUg% AЉk^\Ivq^޼PZw?NUFHbW,f8<[#+$?9/A)/gq*1CُwoČQG,`oߕǁF|ldΓQf)ՇtR]HSdʧo9Â5J.RS~HWs05E.8DI]+}3xv|@8GdϓbݪrK23ܒ1 9@9-ʥVp(o0(mrzF\|S8r8b[+c_ L\IGG@uȷ T! bȃ1BB{$"z9&ٓ&Eqizu]sÝC7o-~xnHr6=^_!he-Ė IE`{ 5CΑg} !yn%XKNuuWU_U>r[.MۇnSOva^wl,=&gyn˛ ~͗˶gٳ},|.M>,z˫Wo wEhWu_.lEQۻmWGaYe݅g-AhU_ZBSK֬X tnŢ Y.Y3bAȴժ+Zwy L{Y:{M["weU]>]E]y|W@E oPA(vikbڣm`6*L=ߤn"}(aٔu.tն'o$sqUV3}\n/BW$Kcb62k]M{YvYݠjכ%1phX3mӢí+w V]սm"12m#U.\O63_8z$+2LIҴ2QqUnr-nd4ΦjqBT3(PDXYx+nqrӷySmB ︞X^+nf]' Vt႗0Թ0vm*R $*Cy;~PݡBF|:%Zt@npYu!hc h^u&tr(-+(ͫv&1[hr"8t3}VVO˒b3vW|*,G=Wj\]zT(EGX?Q$fIBH]V4Bn޶Q[+CFLsRܐכ˻+~$Bbd۲ȍa;ܖ-3goGv;%X W|\H]NG`ECTWtGa$D߹<b Qa@&Uz5^%G-)k¦,*Y9Ζ?sҳ ChXR7HތtUSj`I)6 6lil]r y>>$Pvel,ޔ\×`8NoS>G|^7Lc.RAݭ,ݩÊfbAU%3}kY]<}YR*ߛ%$ZclWz -g趚7cݓW,V/ +)M)RbD {c&';bzCUE??}s ]=OxnbfKf &l.(z#1Ak.*InP[q0q*e3IT[&;yx2eWvݪͫ yX .>c-xD$'Ňk!9,,7`H6=}D֤"S#ٷdF>E6Y )/RowQnʩ8j"5){wt֕o %$ tcy/?}|e sXOW~GҞeu}xn m> B42 ,%\/y2W*KhU^M.s Q"V2R ؜) )KXݖWe qm>r4R,+Z͡)&yg"҉ ݮJձȟ^PS0RB͚lAQ} J̴ړՑm[$lSѬ[v<UNޜ})UhS[!.4D&ݽ)߰A6̡WvUIO^H(:h3ϗ@9bd L~*B5{/߷~X6gӈ<2"P@)s3}IߙgjU(stN}E8O|S&sމg$'Zۗ]\w'I`V5JqHW4S) 7Qbq.4; 3Y9&Q<[`[D#V<0'MEQ#[BT64n#oAm4 G2.ߢGLa7s-e~Sx쬑e Ϫ2edqzvE7 %:xJ}$#.r^14O3+ƏHGU "](h* 7uzYWu+>gZzɊf[:LY>H>t'.'2u5ɸa$ v#%" ZOTSnQ@Ie!,RR|dݖ(Sebכ1n0$::NK5hH7- KL+R_,j =LUJA\ZH -o8BCņ`6@:a@ZՙܔƢ)yxlGj٩d/7+!LG!OsP)H-y=4/~ǸL,hu7F4HMf ߄/[naӋ ^b}dIp(|VH^J>Yjp/__^:qT]ו6Wjc,ɰdd hY#Pd˛r"Oa)8ꡧO-twdv=Ѫfads)Z\R4+n4;cYWNB(QosV!D4eNJ:հͪjE1 gUF8 4s~X*ٖ^_^|x"Ϧ*!u1 aLjq>{lP~^D˪щhRO;g%K|/8$3|2Ss,*Y(xD5=[&Tx_ݡb.]Y\͖%5^hMԦ𫞄 .ʡمO0=FOzB2KGCE4I/&$%rNooV)sn3Re phKRϩ:i8SơfF^ _ESOEnZ,Ib&,杦Vs3ј+1YK0fA U=:9뙱Fv}ˡ,1_t&*OA$L `RD,c&AnaDp wQ01#ί)Lj0mU d_Rq)l4)!B8zG%)gHRcd3*yTUON|Nc*3h/Sہ3BȦ%G .*&d_\''WW'jlѶ+W0*ָ)NGRaٳ!P[Sɏ`eV}:ڤ9m+yt؎bͭY;$8K8Y`T%wwbUy 7Rjqf:[ $aӡ"Sh:cuN&*/LK9ze!_0Fα]V0491zBBFG޳vD AVc{V>Aoj&'V9dDz0bʳXM5(W ?@7ݝc0b5KT*g(wbN:tnkR5zy|~vĖ7 ksD&֍9s$jͣ=c^ǯF+k9[rC \@ULJUe@Xk/N怂2[Up^h5ifYӋp^5Ǚ%DŚ~Sk!0@̭tcp쥡ʎM8ɴ8Ō'm4BEyX#gO oe]B>H<(nN}_д(ul)Ł]g}UUU,W8{pjMbD?E芷s&D4V_Ҝ}f9ڂI'ww"͛^#AL1c# Ba>2rLxM2fBX*+34%3*ļp"a^Emx3wN_q VLmIiNIzXYɑy {J?Zf=fCmf/~S^-PH%Y9P.=Y#}y;*QoG*"`ſ>z 6csq[:BmKus;fw ,%Gjp@KJUI?27.ݽZPT A9c!c|ۦ}K$rWoǰɻI!5J9jYTbu.̩=$RH5W\Քf5ȶ35iBJ('i;hРѥ1\NĞG&]ob9 {6 iDqkѧ𷿑V:]HM:WNb" RgW6w(n~;=6ʖ:d%ykl1~x>Lf`QI}r9g,a' QD~}(9d g|+go< 0..Y[<|IþDԴ{/o1,2-Sy Tm1uO4:~u;/)?VL.9#^ .=ӡP0uԡ# B{d$|1Jƈ&Wئlj:֪jM8~x  Y쿩߼"g 1AY2<^OMug^l}lyw@Qu"ˑG1Ӛ)7+ܣ08b~;! vq*T7v%^,7Jx\ ㋗,8j΋5cP>BZbѡpyݏ6Q!Ωеc 7}`m3uU: bdZ9>t#p ;5#&Ϙ?s/{n g>50Y%+;Ted6ܠu4TC>;:^@ A-՛+E.k Ad ~OAZ[7i/.1xuVϋE&MPDAʒ=q=acܘf7 $!vlOU[UhbQ(x7Owy{U;@ԏ{7|/>Ә, _rۄ4YXtbVck}1lnm| ,uF-/ Gv_P^컰?Hno yezmQ*(˩KxR"(’Okr>]^3MqZԏdw5qNJ<65SҞS@.(B.23w"FЛIB,y@NP B-J ITUzC풽/PX)G1׬l&zDUh涪TXdڠ\zd֢ xMF`e/'@KЍVҵp^?}A֊B"{Kj|幋oq㼭3_[Y&p曈YS|sk> ᠌a$^qމ/r&/>k>UYOP$V" PډYf43&vAeF"P eA&ʃ{~y 3ӨXQ&58AKE3W|eMF΁(TZkP efk[0% P i!/A2448dEtX'$~TȦܪӏM݅sT)R"n{H8biXwt٢=e.[a _m!(Xz_9抠ιrؽy;[U;։.4"|Ur" ~ YH=)㥵 e6s<.QQ !T61%掣$3h-%izm. ns}8ek8?;{0c!gq0"͏sVFݘ^DBʔ*{̺OAn#v9UNU0~q$q Fd-ŦɩIXĂu 9zRK"7nIc/ W'3FʏH)*:Wdaq ^FJLV䮄!aE0vk8i8E[njiMy #)O*h}<b`~~덁 ،ţ٠#j\L$R\Eg%p_ 7J 'aЪlē'{rK3:x .-eDS] '//F OSnWCw|H4cz rh?c!?7+oGh)L,zcf2?r="Ȼ%nm\n b.Wh_wIxL" ;t -Ձ9A?7Iacs2{G'y2JAYNXwIsœ:5 dɿ/~4ԡU"/^w[^V \) O&W<ٗpw=/8$x-N1 V# #H]+&iߝEH ispNSܐNh38LӂQz.8zUmAKfI T.Hq1,3(j4s-lŮ7:<) =*G:2 t:أ:~^ xZrF}b*eD,W)^UmI)[yJ!0$g @j?bpdOw.H*/ zzO>Qr4WJF{PW?kj&ёzƙJ;eZ-t *_;<+ SzZk5N Fa V4Um!Qh渿V:]kҸ<(R*z̚` Mni ȯygTV _`Ko]B0ngkScnao oq"U{U$$-+*ߐ SaBg/bHC4knCo`\-t1[i6YB,|@iZafMn/V()Yq[䇸J zlt3' Sy+Cħ0$]Bp g8Ɣ{Cmdg4k\gܙz>T}l1]'r;}W@nၢ͓L}C};Q`O2uS98$/^->#&NtI;`Zk;#-|SlAZ鏺áqo'j b-}fY@,ySoRg [ÝZiWc5]co9FFMp mQtW&A| <Wd$yo0qF41j :iO+N=,- &t63ȫ\ح˯š(`& S&~}f%Wxu!9>ȆnҘ›Ň.4&0 -cZٛo;zg[vae-h H-JkUIXF 7HBd4A?9Tz ;le`CasZK(.:uGNuS0{Sаk5M}=0H9R ~J/dc?D5`؈h޲Yi܁dOZp \$1,֔"iMNP\ )YA$s_~{,3}k[Z*sc})LPsȮS&S'1#z|0+4e^m&=47Tų%=$Q"+?1wS,-[wD̈_`f^|Z[o+A$ڗ%EG9Ñ_&cSSK)lk3WVk b_O iLt¸D*Lv%V/T2yQ6^P7R3SR B=3eZoEb*IbPiEt<C|;!䒮aJn-VZ>CN >']eYSU z6:2 횑g?^\^\_\]#X'8͉'P-޲=MCW9YGM.ںS"nS9@KL҄Yq<Ec\O<6\cnK@6zu؇[cB֦i$6ÿ<`A?9oh"="uqK JS!BzJS9M0k;/@tq P&'C{ua R KzˆnϽ1̺~(JJp)a T뺫٥DEx}Al%# HVV(Xߍ;/Spf;m-V-G\}ddz#M%ꀸ'N24Dg,@ ?k=#ʩ ɡ3VñO3q*K8qoVUH¡Ge ٶOOX,edtOb>BgM~M'硛CǢDbϐiA,[CN8O9-_4=Gs 1tUY;5H$@ ҫ"#ÂkM>.l%ŎΆ)wyAb7H&[bjnwؽ1߷ }NH lX5Yhit0;d] VۿB:Ϝ]m YXNԸypN=t[l:0K}u(kœ1IK$GCPGf ZĬE%s8VySqPto w|?4F˩3'Q% 67wnR}g܌OZV]s رX ѵRj@r~HH' ȷ} @GxUKr6]G@*S~gU*Tr&f2gC9IlSׯV%W؉ld)ώۧo md,9m+PO+Ҟ(*:gQKzqң:Ϟ j- 6Ѻ;Ǝ*SJ-af8J3I#2ku N9sJWP4[)^%l_%<~Hhm8F<Oz$~ͳ@IOS) mp'JeҗEQeW_x('iT'&Exd%UgCU@(픉<_WF$4gb.V=zNW"iX .%Y7.!h/ Ro1 zl}Cy%d"->gtt1uڐ]>nHJ5ݭs == bg-׮UeR`t֋\M}(F F(4dⱞɓkZ&Ԉ9VэZn/GxTܮIg[ u~e!bRtxX=鼼/#88:\ov8? [_l|k'vnf7_+L_ر?5\[aenLKZ(|߿Y7SxnJ)=w EES,z{W/Kꙥݧ;j |gD&tHF_퇰+*>,' JU?t.zćCy=B &9Fr r1`\(,`@C`Iߣ9Ѣ<Ma =]ǽ VER%uPMj@?­C'ȣϭS%BxA 9ܭ9X{|\Q Y〆m47I)T\*w!=(kB^d m!z6hz M9*g8z!:L8@#1Ls=cgn4LpADͭLՋ[/M |_cn~+@)DXzr\54c50:JɌˏ w"]!$ u\I`\PcIN'o޶ @0Q(0Ro4F(/{&*:(5wՠ+jS?Y;Z!2ҡF4ҪrB\}~Tdz>~A?0(-z9؅qlpB~n ZFfv"RꀔdIrHԠAw٩J+rX"#'z-̮2 !B@DDQ!. C7f\U@L@\MF.aK vK}@ݍ?p9ARHd0j"xD}z`t8 'N) XuŞ-5Hg32ꣵ@K VۯGɑ5eq,uRsD>'Ѐs+]0򢆘)m#ÓՂp chtѸ|U0ߤ\"]$Rg-6o%K|pl1,g-7qN߫I:4*d TIEc9tW[̝p.dl&O۲}Z23a6?z}NT:㣌"ј\dN[KeB4YmX,PF P0˒Xerqw ։*2~%v`=wn:< M#PSzYAցd/%wҢ~=#<vs0A"jc @Bw;g9D _DqzJ4}sv ٣0)þ=yi#9Rc&8cp'cHr\[]TgD; |; ;'CX(Ȇ渆Ai˥ҢpwMr0č57Mw, 12XRVW>rsKCOFI" ZQBV0W^wp گ腆>b9^7b;G`0a|3$Pyșo1wXrP}9f_ |R"_A`] w웺wa߿k%x?F-ip gDSs67;Y);HaԌ!й) ;3ϧ_1>t}?,>p/ 3MQUzL v~gS쏼s])ZBJ{j׬4`qG^{[}Z5{R< !P39uUڦ /e-k^[TK]HSpa&f&$ݓB %GHu~`W@C4(fOҪ.jKv.Cu\{=^i0OJ5m>bC+O.&v̯':GA/pX:w9p0?S\b C,p*qRJm2g{._űi?T}PKQ4f, zw;1|<g9GyM5:k*rNM1%*{A&"v1We:OV5r?+4Z4X{9*SP?c39vv$ )Il%P&=O꽏s_-G}޲ ,u'bҦ:W䕋һ_{eB*UR%q 0ka2@?{Z>xI>*:ژbV2GQtJ`5󨯎A}ܣ;m}7 Sfi*^;ضnVaU~3Q6ϠkpWnS{s{r'|));`:5'ҙ5E t  ͆̈t{A% .> ; 9}ڼdZΌQ$iIGsh9t f&NOXϵQ?sSk˓Vy'Z7Rjjw}]2,s#0VMm ӧgjqs8cfw~F#+[$fwy,Y "e^f=fS۽.Wނ4%  RXb[N1=rQ579<<݃c&'nx!ɼfipkU.mdqd-뵳?S-+=rti-y521Y[ЕoBOp{5Ew. &t?r~`rT^j/~SN}5*5@BțF(P4I#,-@ !aRų10p׌_@L} Ytk'@z ALR(Xq'>&ZӤ@dHlDU[;(K il -o-YR2/r2'b!y& yp{HZ《+Ugً(X$ՇܱMn-C&M]kq!УYC[< (Vwf}롛Cy ΆM`6Oqin#S+t_q~g\9aT}%aL=׵xY6y)\`|eܭr8.yNӛ^^f0a;īdhyLcM ]{XPSz6рKxn$l9-!\Bk=ΚzYogMx.MW5r+?v aZ ʏA:7.5Jwøs(ߥtI$qYp)S=439[P7+9b̋ @ʊjf^|93Rr8%!x;s ]>25CjlHGf$a01pvQ M28qPmUUs2^<#W+rmSxn`Q۬{qӿhu^\6$?df>q:H0t7+PiXXNa9*G>35vΔ.J٥+|I!QN1mdUz t~w}xf! @Qy;U`;UOpYd٩GOuV񏺋??q4n;0#ڦg:׶xQ$Z&ݢ;&W]E77x__r >[sC0k2`vGDol!?R#Fq@%2ŏS\;g~}-=iϳ@X<4Hd8U ʲ,Ģ( 0coOSA7< xܣ 4U4 ; ˇz38o&@27i%!l>9;Vk- s!՜ 5e eo_ϧ6K !/'W5 =&Qhgt_=iYg;I_GN(Ցɝn(*C6}- &n]4$1Ő}e7pNI6p&Ku؍?| 5-VFC]ߴD=;~tǍ!0ţMvֽ+2[Ue|>S<+kpb#~U"~̰g7(z<M- >}4xtG;S[I@nJT:^O?vVm [;GQ -Oxh&Di Vn8OâN'\Gn8NqɕdJiGNDdR&f{5x}ZnFm?Tb)),kGhQ׈GHbB >be9Hh`ܹs~Mڙ3zwgiΜv7S7yU&w]8.kTi,m4C mKXu"ST]Xn]yӱɪ[ջdڪ*LzccˌYU(L][j]çsc3m,Sկ*QC Q-g\ZCs\KEP|"Êf&zB]z%o= ỢM(%tEP,Plh\ógʈ)Kjy932:4|54/ܘbU\,l=9%WitxHa*/[϶&/UŪӼmbd{x6pN4޿oVdԵ7WsWc UᠷPe_B&[4/7Բ4WM pAElegqBrN怖`6@ajy\)rd*gջ5˱qT5]+uxgTRL'#<3^Y`˪,᬴8bf%dNIaƙ[UMqtIu7Ae*(/ 4 (`gtlGy D DI0M޼-+/+|;֦SU/&X7A#Q:@dEq:bP1Ƨx$0 p_VYS4xL⇖0N? #ܑC 2kU_M%o܂`T ӆ7aIDQ)L]Vh9Y#b}>/.拺jZ34nZ\zܓ-~9y (j=B`+Һ2 &P?/H_Ve.=刋Ju%#w1iKJJ023WF,ː:Z!/Jf1,hdj qcP(noE:oicx4HCu$WN2E6z Gp z3!#[B07x;2&T5d '|G{f'zgnrYyL9??]^d0cӧݝKۘ@'YX33^wjH[u'rC``l? $Ԙgfn%iRT`Q dPBW $$5XyAu9B~!vD詟H%_ࢅ6z%X:!$6gF@A%$,+ 6/;kvgJplUfh1`4G9̆+Srx‚O@=; Dm:I~e?_v8z"ỌJbAQ59{5I¹E%STUߧe-|.d&l[HCQo&c3z0VB1Sh =*qIFpݱ\Dg{zx"V!+sO}bCy!vzTdxa\.$I]!>q T*?ڇU>@:A ܈t]R r%р4#0-Ev %0ZVZ`]_͈vFx'h+W[)f_e'pĠRW>(呺kl+dM-<3R0C JE$d19)$]C(LR&.DR/rd;*Ļbz {rP,3.֕¢ 5+0G.נcڒ@<ECc`{51׳|rUS@3 ʊjnk z^"3+O [,,U ɋ`p8 W o g>gDR CS+3KxwSdt_ݤ`HPjrDҽCA2+7 AT&BS VeY  Bŝ侭>=ɳ/?-r]CwYǺ:TL5!Ԓ)'B^ M6C+.]${$S&,(NZ)#VJ@KDiX<n]HL;dzt扐! K&ZQR`WG8~$i &%9#_&:wyYZ4(JFŚ] tEL4Wb؅ɂ*HZWt`L$5<)K:s]ڱՅtiNS@zP" }[UX;%Vʹ#g1_8/OY㓇0-;Kv8#*nQSu2&NEeUbDb}1 DuGLBU\CCШҪ6 bW6ޣ)6!?6(8}Pwv-p)s<84,>2*[W j dA+Ӻ7? s8[ \%fjH T֬QuNNHكi_=yhݻ]%F UũL8{$I&VM;9 t|SQbRB6m*/#!w"lIS~9Bw6Sp`cϞ?(rU| A4HkmqFJ!qT(cA<,l))8PQ4*T'T=#sRo)U+{&Y{c^N\ۿlۍ7c@X?毞, 4%'?>)*Jnl.[ }+ll 3.<.b8FGQ%bg  ua(\ 09&c8rî˕3J(j4bUCJzȤ ; lqCQ+naraT G0'K<),RD,PfGN2HRLZ8Ⱥ3:"[&jH Vb,*EEUbnK 'ky$Z{eS2iDȁÔw9 %o8{炶,b/]~hvBXbQeleCzf%)@4µ6ƜUдlv72lvZcNM?_?)t:+Z"oA*rB"1=Wò@aFtCd?{2%mjR%s>-[ֈӂeBlbjm"&[,nZ/@*,8 UbP%J?)\_[@')jU.U'=n'&2%=YobX]ku3[̇[}\Q/#8wDTh(W%(9e}&7\(US!A~qD&8+ZWoyt#qyHa_Q9R%!%[%`;}  XH HJxzDwwS-@JaQrnT$mk 9tՅA1~o>7YxoW =>g绽t?orz'Nqټ 7NQRvI_=@LOA*{Ͼ:<_!## _/rX_`_z>:|8?{}p}"CT{9D"ZNۄrmp$6л.`zUR۾J7lunj~~ r!6Xt u$֞!!񰞺xXn-=i%Cڦ7v\-;k9If( 9&9U>DOsy$غHyP)kUv(vh/|[?z<>'~{xHKIi.TAΤ%>S+ȥKYRO.?9{tfi)d<+̕3?Ej7GN9O3I2 hT䒬h \ԓ3BS!MN ]jU|Skrbav~]JZd ($w;c¿$^A(QY2vN#9t"oׇHUJ?ۺ([Lx9JٶZnIyޮ:ȒuQY3tzʲOx o2/Gt&WwFD!G41B> tNa|K/9}sXw8BvRG5vJM0;s8 i}c?gʻE9q/aI?LvKε$>ٚ`NqmS 3c)H`-Qsg~T?g޲ /y/ 7F6 @C z눜e@A?WҮIPLuApLBax`t&ZBr]ʃ20Y tT5$1Q %n%,T()%P$l;j| _wd%{;/?j W!\DH5 8!cwyjS-#رs-WaLGG *$2Cz T'@VHnY?6Tik4%3  ulOMoLEG: aq' >[rWy^ wF tS>^{jKwj_46s C9qAy4djD0̕:40(aڭx@C/avV&3*B8 ^B$3jatUP:vє;|}^\APl\izX2~Et7;=皠+D 3he4Fr3ⱥۙMˍ|޷ȓg}l 96#Z*s7\zƗ9Z0އc?# s73i2ZȹlEtlͦ厯< :cQi^屒\ .xf>CThm,׏xp8¿IOËNdwK4TV;4h~po;ar)w9 A w+u<(n0Lr:6[O&L= PTɕ4͍JZY2gԚ8'ֱE9Ѹ|-*!\o8Q"g_J[( `왣dkk𒰻/(3 t؜: \;:uzᩞ1oѝMAkZ'dggǭynVH<$8]y+ͱn=<_m3vOz䶊ƒ"O6ͪa-v}l|aY@-D@י۬3˄4f!TC(K7 _xG*=F?;Ō~~b:ajYWʗo< +!%/PP޽Xܥ O=NyG(_1 *wU@Z3Jp>k6 DPU2^1߲ik Tcc/oIRr2_[yT_B."W׷۲[~PxG package zip_test import ( "bytes" "context" "encoding/json" "net/http" "net/http/httptest" "testing" "github.com/zap-proto/zip" ) type probeIn struct{} type probeOut struct { OK bool `json:"ok"` } type crm struct{} // Probe answers whether the surface is up. func (crm) Probe(context.Context, *probeIn) (*probeOut, error) { return &probeOut{OK: true}, nil } // EVERY SEAM STATES THE ADDRESS, not just the REST route. // // An op reached by NAME — through the graph, a tools/call, the call plane or an // in-process invoke — is the same operation as the one reached by path, so the // rule has to see the same identity either way. The graph resolved ops out of // the composed registry and then invoked them without saying so, which left the // contract falling back to the declaration: for anything declared on a group, // the bare leaf. A rule reading op.Path governed the REST call and not the graph // call to the same operation. func TestGraph_ARuleSeesTheServedAddress(t *testing.T) { app := zip.New(zip.Config{AppName: "crm", DisableStartupMessage: true}) app.Group("").Group("/v1/crm").Post("/probe", crm{}.Probe, zip.WithOperationID("crm_probe")) app.MountGraph("/v1/graphql") var seen []string app.Authorize(func(_ context.Context, op zip.Op, _ any) (zip.Decision, error) { seen = append(seen, op.Method+" "+op.Path+" "+op.OperationID) return zip.Decision{Effect: zip.Allow}, nil }) if err := app.Build(); err != nil { t.Fatal(err) } // Through the graph, by name. body, _ := json.Marshal(zip.GraphRequest{Query: `mutation { crm_probe { ok } }`}) req := httptest.NewRequest(http.MethodPost, "/v1/graphql", bytes.NewReader(body)) req.Header.Set("Content-Type", "application/json") resp, err := app.Test(req) if err != nil { t.Fatal(err) } _ = resp.Body.Close() // And over REST, by path. rr := httptest.NewRequest(http.MethodPost, "/v1/crm/probe", bytes.NewReader([]byte(`{}`))) rr.Header.Set("Content-Type", "application/json") resp2, err := app.Test(rr) if err != nil { t.Fatal(err) } _ = resp2.Body.Close() if len(seen) != 2 { t.Fatalf("authorizer ran %d times, want 2 (graph and REST): %v", len(seen), seen) } const want = "POST /v1/crm/probe crm_probe" for i, got := range seen { if got != want { t.Errorf("call %d saw %q, want %q — both seams answer for one operation", i, got, want) } } } ȰxnXr?[Oq# ,v3XImCXSndd 3$Gɓw%[$k5yY[NM6-bspP7uӅź;<8x$סhC6Y &_CVC~7wݪaʬa[&3V볫KZ]塻۰]>U硪UfY܅nݪ.s_҄N6CM6yuE]]'\Y]͚6{yz]np~Dp69߅,]T ڮ(ˀIm5ST],Yގee&.`n-FfZ4tZ!bx?wM!%P&vWEVY>=M>f36~ĮKƯ1+&Ϻ\bΒaRthGb;06ZdM]|ũӋpqU|c?}u~Lx-M>ʻ{WD؃q(fen1h݄mQv]ܙ|X{[bPzhyKmjqh[ G<0+mlg]RR`V'[M,#@7#6>6ikɰY!g.kü*b@t( 4R hkiho)G|S?7d3H\&IJht~&!ٕ/RќAH,,2{(+J. oXrm;S]= ،% Gk:/1W@O^ErbM8kO/ ܏(B$3}f/ LE)e1Э(, F*(ccXa``%I ˦aWo9(LZ>gsܣ 0hY,QNKhӽPzJɔ2 BtfB^omʜڢF 4nqplzS& GȦ#(ܶ[r( 35@=I_L*(. =Vl<f=lգMVTxfxt!$5R<3^2M,^86PqCVVZyR46 ŵB4ư\ ~Ybzj'=-#]e>,U~Wi9/LL/.Y5|I Q7wY"{׊,l. <+ohL5;M0m0e*FȠ&agFwu]V'ߜszc,lZ8FFCO)´,ɇqP#/MVzSq{ZveYYeC#g*ճ? }ؾccTaLnyܫ{-Jj!\}tj>7}c$9pC"ۖ[dhH&A4H EA1H隘:<KH (ރINH jAwI*3&%7JL|6 Hh5EԹ@H 2܉0 2@OnNϮ~|uC2Sӭ>Bͨ;VBG!fŢt ~_%ZjlU3bp٪<4v*Pǚ;t 8\Yԗ.Ko7Aj0.aNh ޅ@<yu|vq)(rZˬPEŎƶ/T8U˵a޾V4xq6(vus Y_02`;$BUxɮnSfuS2EZXGKJCg]/$).?LdZ;;s#vJg{ ` D@QXAٿ+-)1 Rel)7RǤrG=n(UѱlyO/?~??pѭ?Oߙ_,2!3TT&%$ifZyI=2J4o&[UjMLx!RO}ˀ!*n V &އ71DMpT ۑ[ij3p͞; -L]ɶԿz1sRpըes$= d3 r *M U2s0q,YÜ`6[ āk)8?4վ/F Әl7qjlkWn;Ա3I1wDBMnj D)rl$|L5:n`T1bRI̙xG1L奂6+ q5j@&Q0k&ҎYQjlbԚo}yT%Zl&dh3]#џ3+ypyD {+~RO<M^~wY[WkQD84ќ5:/e Si=ǝM<žɻB57E*vX*z#n;&pdCD?ER*ṇp{-JfHf&ѣomo!$0 {q!Tƀ"|9z:J6:?)rޟ{+{ųf`Ky{eOJVigqxdjnRp۲.m`308^$]:W-u?u8}q<2&_m5Ozߋ0~mݟw?3 fXz?ǑgNj\:el | JGk&C͌xn AiYmR@0V_ O8Y˪h65'ɾѹgI I,1q)D=O#c&IQzSI!>#ďdft(N9؜bkfG>ô CMx$ d4f o8|oy4aځΏ<5;Kan`sIO*\xXρ, a`I~gfxVK%gx #package zip_test import ( "bytes" "context" "encoding/json" "net/http/httptest" "testing" "github.com/zap-proto/zip" ) type guardIn struct { Org string `json:"org"` } type guardOut struct { OK bool `json:"ok"` } // A GROUP'S RULE COVERS ITS OWN OPS AND NO SIBLING'S. // // Both halves are load-bearing, and each one missing is its own defect. Without // the rule on the guarded group, every write there runs authenticated but // unchecked — a valid bearer editing another org's records. With the rule on the // HOST instead, it becomes the host's rule, and [zip.App.Authorize] covers every // op the host serves, so a sibling subsystem's ops get judged by rules written // about a principal this guard never attached: a refusal on every valid call. // // hanzoai/iam is the service this is about. It used to reach a group's rule by // asserting app.Group("") back to the concrete type, which the router no longer // allows, so the rule needs a name of its own rather than a cast. func TestGroup_AuthorizeCoversItsOwnOpsOnly(t *testing.T) { app := zip.New(zip.Config{AppName: "guarded", DisableStartupMessage: true}) // The guarded subsystem: only its own org may write. guarded := app.Group("/v1/iam").Authorize( func(_ context.Context, _ zip.Op, in any) (zip.Decision, error) { gi, ok := in.(*guardIn) if !ok { t.Fatalf("authorizer got %T, want the decoded *guardIn", in) } if gi.Org != "mine" { return zip.Decision{Effect: zip.Deny, Clause: "org", Reason: "not your org"}, nil } return zip.Decision{Effect: zip.Allow}, nil }) guarded.Post("/records", func(_ context.Context, _ *guardIn) (*guardOut, error) { return &guardOut{OK: true}, nil }) // A sibling that declares no rule of its own, and must not inherit this one. app.Group("/v1/reports").Post("/run", func(_ context.Context, _ *guardIn) (*guardOut, error) { return &guardOut{OK: true}, nil }) if err := app.Build(); err != nil { t.Fatalf("Build: %v", err) } post := func(path, org string) int { b, _ := json.Marshal(guardIn{Org: org}) req := httptest.NewRequest("POST", path, bytes.NewReader(b)) req.Header.Set("Content-Type", "application/json") resp, err := app.Fiber().Test(req) if err != nil { t.Fatalf("%s: %v", path, err) } _ = resp.Body.Close() return resp.StatusCode } if code := post("/v1/iam/records", "mine"); code != 200 { t.Errorf("guarded write by its own org = %d, want 200", code) } if code := post("/v1/iam/records", "someone-else"); code != 403 { t.Errorf("guarded write by another org = %d, want 403 — the group's rule is what checks it", code) } if code := post("/v1/reports/run", "someone-else"); code != 200 { t.Errorf("sibling write = %d, want 200 — a group's rule is not the host's", code) } } Pux_package zip_test import ( "reflect" "strings" "testing" "github.com/zap-proto/zip" ) // A GROUP CANNOT REACH ABOVE ITSELF, and this file is the compile-and-reflect // proof of it. // // It is the property a host relies on to hand a subsystem a bounded surface: the // subsystem holds a group at its own prefix, and there is no method that returns // the app, the parent, the root or the router underneath. So confinement is a // property of the type rather than a rule something has to police — which is // what let hanzoai/cloud delete a whole file whose job was policing it, along // with the bound view, the out-of-bound recording and the boot refusal that // carried it. // // One accessor added back and every subsystem can reach the whole binary again. // A comment asking for the property is not the property, so this test asks the // type. func TestGroup_CannotReachAboveItself(t *testing.T) { g := reflect.TypeOf(&zip.Group{}) app := reflect.TypeOf(&zip.App{}) for i := range g.NumMethod() { m := g.Method(i) switch m.Name { case "App", "Parent", "Root", "Fiber", "Router", "Unwrap": t.Errorf("(*Group).%s exists; a group that hands back its host is not a bound", m.Name) } for j := range m.Type.NumOut() { out := m.Type.Out(j) if out == app { t.Errorf("(*Group).%s returns *App", m.Name) } if p := out.PkgPath(); strings.Contains(p, "fiber") { t.Errorf("(*Group).%s returns %s, a router this package is meant to hide", m.Name, out) } } } // And the state it holds is its own: a caller cannot read the app off it, or // write a prefix onto it, from outside this package. if n := reflect.TypeOf(zip.Group{}).NumField(); n != 0 { for i := range n { if f := reflect.TypeOf(zip.Group{}).Field(i); f.IsExported() { t.Errorf("Group.%s is exported; the handle is only closed while its fields are", f.Name) } } } } HAdxkpackage zip_test import ( "context" "io" "net/http" "strings" "testing" "github.com/zap-proto/zip" ) // groupIn addresses one thing under a group. type groupIn struct { ID string `json:"id"` Note string `json:"note"` } type groupOut struct { ID string `json:"id"` Note string `json:"note"` Seen string `json:"seen"` } func echoGroup(_ context.Context, in *groupIn) (*groupOut, error) { return &groupOut{ID: in.ID, Note: in.Note}, nil } func call2(t *testing.T, a *zip.App, method, path, body string) (int, string) { t.Helper() var r io.Reader if body != "" { r = strings.NewReader(body) } req, err := http.NewRequest(method, path, r) if err != nil { t.Fatal(err) } if body != "" { req.Header.Set("Content-Type", "application/json") } resp, err := a.Fiber().Test(req) if err != nil { t.Fatal(err) } defer resp.Body.Close() raw, _ := io.ReadAll(resp.Body) return resp.StatusCode, string(raw) } // A typed op declared on a Group carries the group's prefix — in the ROUTE it // answers on and in the identity every projection reads. Before this, zip.Get // took the *App only, so an app built on groups had to spell its prefix out per // route to have typed ops at all: friction that made the untyped handler, which // does inherit the prefix, the path of least resistance. func TestGroup_PrefixIsPartOfTheOp(t *testing.T) { a := zip.New(zip.Config{AppName: "g", DisableStartupMessage: true}) v1 := a.Group("/v1") things := v1.Group("/things") things.Get("/:id", echoGroup) v1.Post("/direct", echoGroup) // The route answers under the composed prefix. if code, body := call2(t, a, "GET", "/v1/things/abc?note=hi", ""); code != 200 || !strings.Contains(body, `"id":"abc"`) || !strings.Contains(body, `"note":"hi"`) { t.Fatalf("GET /v1/things/abc = %d %s", code, body) } if code, _ := call2(t, a, "GET", "/things/abc", ""); code != 404 { t.Errorf("GET /things/abc = %d, want 404 — the prefix is part of the route", code) } // And the identity every projection reads is the whole path. paths := map[string]bool{} for _, c := range a.Commands() { paths[c.Path] = true } for _, want := range []string{"/v1/things/:id", "/v1/direct"} { if !paths[want] { t.Errorf("no op at %q; ops are %v", want, keysOf(anyMap(paths))) } } spec, _ := a.OpenAPISpec()["paths"].(map[string]map[string]any) if _, ok := spec["/v1/things/{id}"]; !ok { t.Errorf("document has no /v1/things/{id}; paths = %v", keysOf(anyMap2(spec))) } } // A typed op and an untyped one declared on the SAME group land on the same // prefix. zip composes the typed op's path itself, so this is the test that says // its composition is the router's composition and not a second rule beside it. func TestGroup_TypedAndUntypedComposeAlike(t *testing.T) { a := zip.New(zip.Config{AppName: "g", DisableStartupMessage: true}) g := a.Group("/v1/mix") g.Raw("GET", "/untyped", func(c *zip.Ctx) error { return c.JSON(200, map[string]string{"kind": "untyped"}) }) a.Group("/v1/mix").Get("/typed", echoGroup) if code, body := call2(t, a, "GET", "/v1/mix/untyped", ""); code != 200 || !strings.Contains(body, "untyped") { t.Errorf("untyped leaf = %d %s", code, body) } if code, _ := call2(t, a, "GET", "/v1/mix/typed", ""); code != 200 { t.Errorf("typed leaf = %d, want 200 at the same prefix", code) } } // With() middleware composes around a typed op too. Dropping it silently would // be a hole rather than an inconvenience: With is where the gates go. func TestGroup_WithWrapsATypedOp(t *testing.T) { a := zip.New(zip.Config{AppName: "g", DisableStartupMessage: true}) gate := func(next zip.Handler) zip.Handler { return func(c *zip.Ctx) error { if c.Header("X-Pass") != "yes" { return zip.ErrForbidden("gated") } c.SetHeader("X-Gate", "ran") return next(c) } } a.With(gate).Get("/v1/gated/:id", echoGroup) if code, body := call2(t, a, "GET", "/v1/gated/x", ""); code != 403 { t.Fatalf("ungated request = %d %s, want 403 — the middleware did not run", code, body) } req, _ := http.NewRequest("GET", "/v1/gated/x", nil) req.Header.Set("X-Pass", "yes") resp, err := a.Fiber().Test(req) if err != nil { t.Fatal(err) } defer resp.Body.Close() if resp.StatusCode != 200 { t.Fatalf("gated-through request = %d, want 200", resp.StatusCode) } if resp.Header.Get("X-Gate") != "ran" { t.Errorf("X-Gate = %q, want the middleware's mark", resp.Header.Get("X-Gate")) } // It is still one op, with the whole path. if cmds := a.Commands(); len(cmds) != 1 || cmds[0].Path != "/v1/gated/:id" { t.Errorf("commands = %+v, want one op at /v1/gated/:id", cmds) } } func anyMap(m map[string]bool) map[string]any { out := map[string]any{} for k := range m { out[k] = nil } return out } func anyMap2(m map[string]map[string]any) map[string]any { out := map[string]any{} for k := range m { out[k] = nil } return out } // A GATE REACHES A TYPED OP. It is middleware on the group the op is declared // on, so there is nothing to decorate and nothing to override: the chain is a // property of where the route was declared. // // This is the property that used to need a decorating router implemented outside // this package — override OpScope, carry the chain onto the typed op by hand, // and get an UNGATED op on a router whose whole purpose is the gate if you got // it wrong. hanzoai/commerce's Mint was the real one. With verbs on a concrete // group there is no seam left to get wrong. func TestGroup_AGateReachesATypedOp(t *testing.T) { a := zip.New(zip.Config{AppName: "g", DisableStartupMessage: true}) gate := func(next zip.Handler) zip.Handler { return func(c *zip.Ctx) error { if c.Header("X-Pass") != "yes" { return zip.ErrForbidden("gated") } return next(c) } } mint := a.Group("/v1/mint").With(gate) mint.Post("/deposit", echoGroup) if cmds := a.Commands(); len(cmds) != 1 || cmds[0].Path != "/v1/mint/deposit" { t.Fatalf("commands = %+v, want one op at /v1/mint/deposit", cmds) } if code, _ := call2(t, a, "POST", "/v1/mint/deposit", `{"id":"x"}`); code != 403 { t.Fatalf("ungated = %d, want 403 — the decorator's gate did not reach the op", code) } req, _ := http.NewRequest("POST", "/v1/mint/deposit", strings.NewReader(`{"id":"x"}`)) req.Header.Set("Content-Type", "application/json") req.Header.Set("X-Pass", "yes") resp, err := a.Fiber().Test(req) if err != nil { t.Fatal(err) } defer resp.Body.Close() if resp.StatusCode != 200 { t.Fatalf("gated-through = %d, want 200", resp.StatusCode) } } +/sxUn6W ` qЕM ׀nQF\CQ@Q#YTIuQ{KCN=Yo7{BygtyEڻt@j,H=W+SiST ITW;ݔ*IpL$EW6_V_uy2o{rdmP%8yG|aO|ؐ Fm N3v[&ȁnn+n(˸OLJn4耙i[zfZF&g=%钴`7sJq`arNeD% D5[ﺸ"0 $G I\#mE>{pT-:ۈ@M=JJYW fL88%f77+)5YLv4zi!f2-.'8Nԧ4UULWj?T lYEUWMu9+Wh88pm c1€D`+cjATCW+L36ƭ<2ap8׌V%$u¿RC%/aFq05~[,Lw2lë 7e#d;88m 15c c:GeEBhnF|`N.Zb_!Vb88# 6%"2.=XL8 S2SjgYEĐ}HKaLigG K OFSJo98%3pd$y2D*GwC__9e|gZ G iOٰ$?iD^eT}2HH^v2f}q=lD'RdFO_"_/ɩbCuթsZ䣢?u$z][(Mz"&A2-yHIkEAiؐ$y4C *,?~iCһkE&qIMoCٚR{zjFW }ϯ's̉ +yxJj+ǥX}Z{1|:}.wbkYߵK8Y˾@D6OCI:_*eNSA9`w#EXqkH>i#m0XU`"7I, ځ\hDG''MJ'bT]'`k~*lDY XT]*:MC R~S2՞Jkc,S-fPJָ04:h?MVZ^ s>w~ndyp.j}zM<`}?![1 ۸UGแ|h#F`v: Nc:E⁋ )~V,,mx`ߒ/Ȥ/t$N:繐DM"^bAI !i_f'qO*3^tU/GcʟexֱVߏ YW{S2ܙqp>ݬ 䭧ﳠНiM'1E7cQ<#xuXn=_Q+Xҡ`2@XM K@С9SvOgDsr, K{(!ރALwuիWݚjg~hdGgwf?d4zxFݖetd#9ߑW3WqH9qd?56lG#Uyg+PՎe'g=1V_qӴ;Ku4=_भojX`MczJ[5u^88ngMk5քaMลʷǩ$j[!,%:JyQ:%h<=ikw?C=yפW77?.wÁZ!Sp/PÆLd$6y$m)xjl@Ֆ4!qJK8QQXK_A|]T}m~D?́ϳ1c"kHM%w[@}]d$0$+c'g{d7WtNU~W_!QF^{7;ewL>H.—*ʗbRs" ]vCU !8~?$cג_ fJt7_nnohFMAΑrs%$naXDs@d,8j|_ \uć^8-w|d +X֥`p Q/;Ú+QwZXTR8+XGҵufְXRHUսzy`""h)(cWVS?Rm"I:Jh3& H}6-q ]Pj6Lsk{L G1X8-D%ߺnt#I$D}<β5Β }}O ċX%hSZ6;q|{NsH Dm4[C4J5M;iاdB9]b)g(%a)h&$L9* F(\ìJc{U ^AE7h0FzaP75vCo L7|;_ɿ$%Hff挵&K'Qݐ)vta'oud^VaG裳ALWGGHM4":H1tǴR y:)ToTahٶ38ciܜ:B^jŘ1CtR;J0nRo}Sl=+|Mھ8'阬<]sw\S}4`̱A&F !33ZҐx*'⫙U8585?&/E1ާR+ceiRfi~R.hוC̾S G_'ZcC k4rm/MRI $YA|  `=nv+PA%CYаhzF[q>~=A%WsZcuhiX ^U{nˊ!goS)(,pCZ&<)f4o޽E Mؔ<A-ԷJ@+`d6B9NyN%B0޹ .VI.A{ ]p)wKz/,Q,>KrR5p5q׷Ibtd.`R8{d3VS6$Xtyk3X#/gy8w;'#\O4>.cQE+雦yƓL$Sݷ',蜴dPe0!H9^hJٖVmun}cq=RI֜+W:x)fkLI &J} N}] 0Y%TެS\ :r>35$xXn8Uv"i :Mdw. -6'2)>>>~琖e篛FJ7r~_+[{{InW}GO%xKE­L~,~m*as;?CVGUm=yIU,s#܋OީƋ_s֌uߌfzf]yX}|,NEnjtVB;Q+T!tJ\τ~Rj!$jGaMjNɹPNLl i @n _YSRHI/ri1l TZo#^.okPB')jR.MF(,A/(>ֈԥZ圜C*J߲ IJ,YqKU!PeP(U{@n`׹^{1Ce%^iIt& ȭ XG2xmHKm4 w뚱[=sF KjAPPWhD3Z@ @L,g:̣BB+ \E[I6yqo.NhQ~MN UVH q.RurfKmLp75/ٗE"n p) F ]J֎>@Kfڑ@ A&,ˑ{,E!  )KSaՀrе0^:~/r`PYdj -d-(dh;Ӫzz49$ k v fnʄk[=1<-Px}s!]B#\k)֜Nd@?6׽;A}'RK6=jAYrH2[$l ILr.Nā¢d-y~oj`jr[f:¥E 5;1ia/{`0j'[;̎R+f%-@NAQ:lƪrI>cb"FLw L,&Cw4.t P 2-#J.ZEqkT`}U-g!TNF`ZͭW;2_!bi%$HdZ A$st$x~DBv+apH=ļ, ."_BvcE&JTzn"3aV-\=ES6V5"RZ>s|;|*ڳv쒻fg *)^5]\ty4+>jG4Fl(/pHxvЄԩcS}QPjSuQZjS5Q,ų&.Zh2̧\utlDAFC$+ $߶HfntU؄ ut SaM/رAj2ABFW?U9/+ڹ]6دc/D,QR-ry\Aݧ (U\C`o:}^I?_ߟ= %IVvQU_ikSw@Ve^cUBjejӊk=TNӅ*[~vY弙µTb((Tةtk!ޙvv:m5Sw^A)S#E>MrU/*KoF+3bi.1(jڪEzZأ_ڕfxU%m͜2&0[m^S)/A/z[u[Nz85/]K SqmiZ+N =rW9^jXڊ1: +a^pDjo(ӵ90h0Akt^6H^ɍGWXkKpԲW3۪pu/a5]=bk &#/%7Cpyq:hlIWXsYLr)&Guͱix:$fxQ vcզa'Wӫٟ/^_\\Vի7?Opws"2k'΅CGّ/'X qZ!h|[\$ { j¢hUf]wto* 뭄1Ϡ6\6Z  :|7X+ ) TfgZ(эO\^#c\Y,# j I^!{M#;D4fh>vR>UjTԣ3#8aͨ2thS.+,V/sV2/b-#n@?Pǡ(+'\^9&4iTg-meCfMv52xuah&Q Ij{S8bVP Ԙ*zqu 411DgIvaSz M){kQ;L8+m8~H&}l҄FѡH')q/ LY7{2cmPBpkQ9ԏx :WD!w=: t{薸?9~rgvHy)l&\)|N܇-Z5RrE%=Q|qs8 c[1x2隔 T9Ql*vѼSHa!E` ]{@У3 'xVnG'3wdkJ6헍$ s[[㈕WxK a{3}& }~=|0'_*$Y˚0±ѵͧm\7ޥqxp ! l$ҍ) t֫g烗^@\^.bB~#zh__1sD{!%v<?v.N,}_VBBaǔf  z8fҹOc$b2KiH,%di޽1S,R,]wh-X0Q(A{[˟e&qKLFqdO& r aތ=go9°(P"_xW]o6}ŭnv톽dC금Ѯb-gTIʊ؏//ٹ8na!sR+NZzujL^:~HVehEsy5ORnD.etCʔ(djl&-)GFړυ'zLhyt8R,%^\8*y+鰐$᜴^Mk)4_T qg5Ehm2ֹ)$&ɥ On[HM_JŖg{!g&g&c %ħZݒ&S.T[Wȥ/Y/&CjA!GRj*utQ "b¶= 'V"K34kNh*-1j3(e' '-]UߓuVd%t:J>HvIbVXѕw]i}ւW;Ga qX G5RJ\֯8ն 7tǖ^ݴɓry7* ci%ӲPdZzu_׺pԂ62+3 ucL紜P#YGY)madp?C2~ꅯdWVVE&.^25?OgxJ1.&,\@dF~6}: ZuQAD5,C,.GY<1u?O-HeF- p+fuZWWDZUsu^/qh%wFk)65` /&#Fk'EJL'ARͰHIWC|> sĞ% ~nk3X7+a+>cowIg@+-' DRA$O͞JY:/f*<=h@2 0/ٗ@۪,}[12?zd`S[Rv2V1 Gr$WnQ]'*{0eQ3ДRq\=NczMM.Aafۤo բxڡ4S+atkL4<V5;eUuX͊'tFHXL`~łqBC:gbSE-ҶAu#^oZ mb,x;劂_2t1]%v=Hm-it[pIW82Ғ;M/p"n/x*wGwW6&A.̸(Q\S }̯)lޗX+VtPs~99}1&H8~NL ڜr S>K6aPyP2䚼 szj>'ŀ@Ȝ!vGg1c¾?7p)Xyoynei$Ӈtc?WJB@D#>S\*߶DP9b ?$(y e~xUnF>O1!%*-rlTN IA,ɑ08>DOҙ%;J`Z7jE =E$Ql%Q?RWuZSdin7/Βr8Ep)[,a ),\,1f9OOof]t<`ꃱBOMayP 1@ʃuSHzP+ѳO5Iѕ|{Vr>e}vGJyLT^Bʡ*ny.J/@`__%hlrk M.]̂RB?&[l-Pr>X9٧KUcrX@ŤU@DU:/ nwёG40:$/a|yKhӷKĚ^ߍ`T{U 娩/{&5x낥sK7%O Ji#EB{@ζ;rH3,Y_&f+ҽoNKE-2Qs$2׶-pr=IĦx4-߄9 T)y '1z򀋾8cQGլ;}\nJ W!γ0 @RzHU$D#xC.#}1i֘gq{L[骨el2Ə3TpGP2Xi" jʈQUTX$s[f w0/GāU|q|\{ pL[Dd%Ri7H2m"&Z%Mul$~6_YW٭ܕ_^Ivgʲ*Lm:C ΏTYNL5kvso`[8 uBĶOW+}~ߦ sròUqT#gdte+_te>tx)Ȝ2ŀU7~~ʸwlcchQH|;ȅnr:au%zQ5+Ia. rjBd!u?%) MF],c|&^r(4Ӥ (%s@̫(ɚ\!MB ELm$8Ə?L# `SﯜR`ڪ*W$–2B  ]ʥ:.3R8=tŶ]wC\Θ4-Yϯ8 nZp ]Cy >WR4Py)>(T*0U Q90M^iT<IVVK4Me -N6kH߳5˭YHT8f0&C*c?"ՀRZ8vLJQ2Z2k(^u_kU*׶E /A^gD|&;s9I0"yĈx^j?N;GhL Qd`,d"/^B u\ru%+Z^15hz87¤GA6-^śÀcmnwp~hw.k@Q5 X_QpJzB/h c H P9j~6#9 -.hb>L._|~7cלJ/!{هIL!jqʳxs:Yv Ëҫyɂkc n^ysvn7};υK~>Z}2aG *CT^5EjGtp#\?p8`P0A_r.qpac}Hk Bm r .L&ExW5zڰ@fsg+Ѡ11ui $(zG1$ҲHxL4 uHq yItY|G/-6b8f-KX+]jSa+iy٪5E1jRںl3>-~y>Đaƾ–|u3zPT/5^\zO ̓g.kDnOF&ΰ֭aX^`EF:X5BnU̵frrZ)&ܘiaR ocY31-HIX,J2xZrV-=ō~L qgfWJeGLMm]$V i&}}Ot@E$$?NF~OYu|mndNOgȧ}m ']ypUޭq˲in[]EV\jf-7.k\Q[ȡ3-_G5~M*kޅz"ur_Hgө{ڻ4B@tp"Mv|]eUw]8OyxvW);iö}gHZnx"4YVU_.,O!6OqpK }QN[>wm .+w;?={sj5Ps_etFtP?r==ԡӷw\Q\ ->Ox#n ܺ W"TQmkٓg\(qyqrv^Oܶ]ۗn A8+ ps"qغZv2UY_{8b/G`%Ս=DFS=/]q P:NY&. (ƾ3X$j߸;pg.0.nr~}`Alf {<$P\\ E tY |bмz~60Yv[喻4@D닥l>Q"O]R|B.&De>)Quh:l` &gfxu}s!OA,J*kcXk'0mBD\x˲,M]fFd_ULV- rj.'b"@()ԥ}o2&[`aeeWSg Z;Ms} ܤfclFx @K`%k-ul HMrTt֐A"Ptxݛh9"]+;lYM·aUW,ݤr?BSlbL^vMGٜU`=Ჸwlő"%#,J|VS:ɬYL{8: )SK'76J3I0;5IQp51:|{0MʩI BfEKz/@)iXy n ^SiN(^5MKʴUigЁ۫ͥ%lyi˸gwW[WwW緗W \_]hĉs8|`kk&5! i,쀝j z3$ݼ{{q:cMYXkm 3@0^=1Rf{M6!Oќ#i&LL@Ԫ[ g/l$)CY안&-#N`;-piY֖H\bIJZZZ}2Hz9=Eh1tHNyF7jW%4"isBd$H\= ,Fq<˄CQj iL z+Dv +$K@+7D}K1{R$Z@4*[ RO!; لVxcDEBWF)p12J= =B'(/,G"HPQcz,,/p#I9ABn%_j֣OP`I W 5 L cʱ'4Kqfֲ  )ݫssCRh,xN&;+w+]^*&Ј,,Jz$)SzXKKDjYO+"FpQ0|{>m9ټ=y%-!i s4+'eK-)'`p:(RGRlӧCʈR??҆aU`.;6"BFC'q'\]d("n ,EY3cOa`E|%wfH@?߱q-'18bb#>C\]YcS7TaH0|33wt-Oߚ})ŎPɚ`p h}𷿁[r~c4Au+{Y~-_(V9Ph;y`_wM0Ts0^؟~ .yrrBݜHLb"vWd'Og.JNGv?|>_}Eʊ{?BV` obo]T~my7##VjKiZnk&]` %ILD`gui]֛_2q?>G.(<-27Ȕ[Tn$Nv~x,o[q>łX'*oɸL+IsƾAظ\`%iYLBNHף͓}\ng/?g^Z}8㻻hf\n`2 -<-8X_׏Aa^B#@]eW wiKhst. ،~V|  Fv //d.|W_aZ˯-1b+뷒x]j`Q$ilB_~?ՒJJle.J%pt7g[wsq2n~1ԃž, rEρ)}L\Јɳ-{N,;)+=]D̛˫׶T̻4zJ(6lz/~)+PF,ZDZeu:3iQ<+}.KBW"zgJ%Ʀq_wʳ="?MN·P>rr3ɛH9{=J٦@6kGdMdn LMP%DC\vv)[MA(͊6Brg"OFuoՁYT Ļ-+il%>9*cVݰNhtJ߯e~>2X>Oq@κPw6Vr*E1hBOkތYv~gTfselHӴVf(D&A]IL+_v<Ƒ%ᦩLt0Γ 2>?V>oB Rui5ּ 8`_g$@ (LeNv .bFVLF} vX) |,'}0pF9?ЀWksia*C阴i2yb{>Wνn.ܠq(p.nRV"TQJ$u|ԓ|/FZ~ȯaFJO.FGL1$PAk"?>%i;ޏDX)QHQuF=9*U/&m"F$V|0Ma$CC?1Rwq#9X߹lM{r>5H3,t@g$`ƃ lx[LGg8šr4r݋+.S3 |Fc矧7Ͽ~<6i~;- k_ k[3gRٺkY2T$XMFg'ˬѨ,~0zkIJ W@\NLmƭשTZ[ĺgDlaև.=R1?//a^U7 *әeEdLhz@?#/[}jDi`&9Kɗ9O$/kbUN>='32ړ3f̝T`r&?L*!C:Ѵq2|[ҕ {w7d.9FY?OaEOl֨4?5Bg49c$ib//<L7V|]D4Bj%L[:KAg1J?,yA 'u4NTƾׯ6Fy+#Qpc%9@&y,lp~ui櫓?2a~vb=Ǵ˪ojXZop2*R؀~4-ou-l.3D}Igxŏx6kA<U8ڿQA=gZ)bԿ|%OËwOTDHKH70-eDgZ_1 ķky͉N~hVuLJ^4 H+rVv,e0ڢH7gomž>ID|2pȍhKK5'[RxWnF-=T@TPv eM w[#r( Lr0O'9wHNn$qf܏sϹtq7F}e4!N霏*NfUgp Sw>1)llptE|:].μ*ksyfZ&]1FszoJ5zV\VG3;[DZ~[6.Tp8- LW,|W:D)V7kT9?."( պ*\Fq[\iԕ1]Pzl rXWQozF)8xLTB0i{)2mI[9 6ڶ:U,m̓Bel{3$ C3pmd1#,# uGBmۣ-.B5k _\ ͘R—Ky66R_*iկN0^a3XN`C5d?pjq됸qU TbKG0 t:Δ&j4t z)7<+ AeRA t!fJ1bm+ qЪC@n&99:1?yR;a{6~qߙKԠ[ YcG&AgU_Db6H0} 8% uF%S 7!Փ^G,OG]xT]jBHY;ր0xOr`$_>e ЏIaNӅwQ'#׌t Īv:~)hn<9_>^) K_ENC]~D58J،M_G۱=(| ~K >xr|:꠱ {@zl4Ft/e`v @<# xe3E!t ?DcB]7W?!LJ`We1MޣO!B2|$/(7nhDAǴe0=+8% `.2d.xX݄ZQnrQI0[~Vx2@vE`nsd76r&`n>X`Ga?GP%3.xs+_z#]>* l'Ry9n-4rDBάҤesmc~ek C%]?ޛ~ha㤢qKk2Fޑ+1̙84:U?,gִ0-6辝A ߅uz<'rY#AN7l;x{)T~4fyS"ax sockDir(t nxXn6m?@s[E~K2ز0`mqHUm=ĞpOnv0WbI<;V*RKMoMuá)+WJ?0v9MGC4!oԕoU]pX=}З'& f_R؇kjsWhJ JKj3RT+fi, +OKU&l&V~֯8L TNaI^c &*]{*]y'+aJx>ᔩI+zƟ/ ~G6x>Y[8%1k(ug;j7ZUg<* ]S,[ 7Wfep'vi^p0Gg4oL0'aB8PUon |wTU3·фWBP7w iFnX,M:)ηj6f0ft0E6_BMOx!WnFOC~b'ۿ>؏ևezrD.p髼 k-$ : 2wيIp{X.7ؿF-!l4~-Cz1~*X_t5ll on1>u/Z)>xqvLAi-2D{]_efk#đ5{ZkӢv%VtiǠο MF`e 03r=*bm_Q(֭k Bߚ~TmB.+k=8gR!a ɰ`qR=z%|ц;8Ood8uh2+Gh#EU/\~$ [Z:=cuv\wʗP[ԼE+5[7n`Kld@sޅqGޙ9Z[a|1A?3<៻{[[j yL 6^`iT5u<*k=>E9' 3*z)r:aASM4`-EFVd8\dz 9z.c|;N߆6+oĝ𚗮aF 𷇄w2SL}ʩ8q~[5ł~ðT$#-lA4RKs0#ѣ|$+\[6e1PBmnͦl0Mx 6ѣƃ2hĹ;.]~_qC{au-Vn.^w(/p ph>|UŞc5fźN15 {Z4k)1&R|])W9tAboDRFh1Pu=4H D령;IYrC`RX]lsᮓ%OvߦB@_]pWHYubOg#ף(+C  ˸^YBa)Bn0%CoZsBjsʈ`R-ԗ^c٥9% ;-uVM9 :99DAa%ëW4eε򵻳&UJrW3D8?9aJTԴjB!%%9y +??qܐIO_(J,y#*Uҧ|R65]K!ŝdW^Ji3^11]-x#100644 addr.goet+n0{XZPox// Package addr spells an address, once, for everything that reads one. // // It exists because the rule was written twice — the router composed a group's // prefix with a leaf, and cmd/zipdoc composed the same two things to find the // prose for that route — and two copies of one rule drift. A pattern declared // under one spelling and filed under the other publishes an operation with no // description, which is silent: the document is complete, the sentence is // simply missing. package addr // Norm is a path in its ONE canonical spelling. // // A pattern never ends in "/" — the root aside — because the router serves "/x" // and "/x/" alike, so two spellings are two keys for one address: the document // publishes one, the op is filed under the other, and a lookup that composed the // pattern itself misses. func Norm(path string) string { if path == "" { return "/" } for len(path) > 1 && path[len(path)-1] == '/' { path = path[:len(path)-1] } return path } // Join composes a group's prefix with a leaf, the way the router does. // // An EMPTY LEAF is the prefix itself: declaring "" on a group names the group's // own address, which is how a collection root is spelled. It used to name the // prefix with a trailing slash, so a group could not name its own root and a // service reached for an absolute path on the parent instead — which put the // route outside the middleware of the group it belonged to. func Join(prefix, path string) string { if prefix == "" { return Norm(path) } if path == "" || path == "/" { return Norm(trimRight(prefix)) } if path[0] != '/' { path = "/" + path } return Norm(trimRight(prefix) + path) } func trimRight(s string) string { for len(s) > 0 && s[len(s)-1] == '/' { s = s[:len(s)-1] } return s } LVKxB40000 buckets3ȑq_)ݷ40000 meterqlo Fd#wisx&100644 buckets.gocBwmH{I` ۙdU>N^xTn0<_СG!ȡ0ЇaZ& J2iSəeYZW[a-H`G 11%sxƅ=Oi8EGp Q*KqKT-fqDjL5PӆZ).$YV9>e ImWTnW>jKXip>Xݕ:`zI1ʕ(]ԊB%-t+Ȭŗv=ؘ= i`=0&Xga 0| < JU};_c7t=:,B٭z'Y-WE{4ʤr2Qoa>Lvۊ؛*Tz,Bzbes_@ۂ8r:Ko=JK,d k:y?{gPg;35z@E]Ws/gc]1ց!.ԷF#[zAZ(VHLEm1J3h u 0EoW\{O{M!]X u&fPM!AEZC_D<+Yx tL{ymj kR;"w31@DQ7a"8WX׸qqpRy(虳P,L{y4~AtZ1ѶЯggB{ǟ}w8lw^R7N \N- P1B` ңł.%Zh7Q{7F]͈N,Cw*j$K0>`r\(2H7Ņ\-\lo|C~t,*^Bӫghvg᎑`?:壛2Ty$*̈r^^ȽL3_nȳ#~9OKQ,a!dRSx!>ٖl3z2arr\ia|9{@IB+M+Ou+k%Sb^*ρS8Ʉ޻,ɜ(̟s.ӷ? ^@2x' encoding/json/v2, called with the wire stated as options rather than // taken from whatever the toolchain defaults to. That distinction is the whole // point of this package: v2 answers differently from v1 in several places — it // keeps a zero number Kleaves `<` unescaped,]%L, // and does not sort a map's keys. This package once selected v2 on the //>' so moving a // module to 1.27 silently)So the options say v1's semantics, plus sorted keys, and every one of the // remaining differences is a decision to make here, once, in view of the // clients — never a default to inherit. What v2 gives in return is its API: // Write and Read stream straight to and from the connection with no second // copy, options are per call, and `omitzero` says what omitempty could not. /;nx}TMF=[K40h>1ds0VݒC~D~I^!ޫz&n5z') 3N>$*g }k\7ųSp09%R^pO2Kwa^DL"!N4OUxdb%\M2U#ohIܵ4qX'OHبak+(y.;@Ei"}/pfP2+( 5bMc` }iyN ?Z@r:H4$[TƏx>#Dyi}3T&JG|zK+zTqFNIBF$`?' TB^=rS G4w Xhp8QxRU)"\[E@rH~l~4I)m:~A5 g,EԢEz.GW>|6c8+nŮnXu*yhC.W2ʟIWǣ#f8198t@8?VfoYŃNu|IsLI;$)OrkyQؐJR4aJޒ T5>x[ l)XPfF?|CVR]g"Ǎ3j DqQo/IγB%tLbbvYUK,E,)yC"?Yom|k>|BdZ5H=Ǚfj+dU6 z۫ڧ*n<1j^WTup*dht+z-0IFﾹ"t'nD= @e'<3Ӕ+. :4 \ttvBWt槝ڙO[k2Bk9z଒dP .A͛ 4 S 1=nlt6+ jLgt(h7H14rZqZ=*UZGLK-]Y{XHE`ѲhX(EBʤ2=8?eH)QQ(m8޾E Q6Ql!  .p:#3NF[0q'CȭJ=LQ?=ѕG`dd[VPdJ/zL&cw.TRA"4E#턧ٺEFgm%sHg}΁J<')zZ{pրP1 y /An'ȎMųI䴡X( 8fdž HM;h*HwϕϺa>+=#vܩ# Ą)4F-mO^d7 {yڭ1jXVbi9*HK3/?X|`o _^ %@mĆDž n3D"`*g# NKj1L8`Xwk4,( l}o D+2u a8]!^ ~ :XAOwoK_gt!=iA_ҟ!x]R0=_1,)![ؽB8VW4lZ~IgdKLޛf[:!|O:A#&P(2WB@-F&'(A |z4, ׉I]:8ds'Fة*^Ϙ^Q?Qu印etnDl4MQin<[. r d٦$ܣƄPRp+i0wy28e1۵ &d,ÄDPsBQQs:WÇYbkI!Ev}%ώ#Ie!2"0yکl6)dr3(l ٕGW$*a4unG zޙW( tN!2 ^bU`WVc.ǵP9Th)dM)~#}Oޏq,~^sS*9B9(f%48Wj`SE3x^9Vq ?mn?UR} >_Zvop}o932CF2db<@bSx340031QI/-/I-.KgXzBs ?27 F~ fʞ;I]`P5Uy U udx:2fm/S.^xVnHv`*mR +.J R Bn&8xm"Cwf4).$c9b|%&rPt\iKNV-\-Y1qo!8dvZⱚ~VV~Ya.Dίe1;۝.Al*T"卵<|ɴ̐J\¨½Pij5$pJ*$[K*a3 cYRB0ʄ9VEB6ɘi" M4[{s% =V(S Cln/̥Bu8v D6/;h8I}%3_" 1胡kY+ <`S3´#奜]LǸi%A`pXG2 H."~n8c2<o!z^:[Zۿ=}9κh$~6}Ԁ+>!zLjx"t6@-iuOyrVH_C_c018.6q,L  @f [[t%,#f72pR3^ |8f.3[c# `ֈ~œD&Ll'CUTސnҽ=>%K ! G'jm65+KCz)Lx Y d@{9 ȇPl ꖟz3Zgn`qi1Yssy0 P!uI27cx¢+~]phF( l8إa Vs 똅­vnJ)#^aan܇,$'ğ3Qv@CZa` wW;ґ"/_3pțw\%;4寇VD'/z8 8 8t9.9k|o[~ًE>GCzl 悺l \@17A!m8AFv`V(3F7o>&^e;p*\~VJKu?S:2ǯԋL(sOoRym(/# Гį6D}g&u0͠]]/.?_6t5vf{&#hi3\NfÚ&E6-ћ8M/ <DelJog#:!Scޣm<-C܅uڴu|a,`a *R<w.CXӅjT?NCj2{ (Vso5 -jwEz-rݏ'Z:].W?˽cgz(r_ulUVӂtyYF_ U.M.BHr2 xK%oώ>yAi}yX/0 %/$5fxZmOIl>9`^e%R G::X1Tuϛ\Š]e9;ҙצ'Piq20*?%1LL⸌G//"؜or9FY6(YvbuL_v: cI=At<47h=B<ȃia23a&Hp(sӮ NrNQlF jʼnb0MVMWl0G)xΙ0MvpΪ4Twpщ>7_$0jMo`'ZW e1i  M14hd&H&ιC7 uGX1;5GD\cv(U9Ռc<ykt毷kBǪ;w;\&KbʼnX6ij 0Fk6$įpxOy:?ts4 o|kNwWHPeapi|U?&"HoRG (2H OKۯ:A_ @>jLB_Jڑr1욍G4fi!i4B2MiSd>ǡ<;hg # C鉅tHݭ1K}"5'VjkWQ!$}xNY\T fGgs堌|ґ T:iGHێo欠wC9* WĜԦ>b*Ps(2C,Te]RU~ n-}GP?:YzC;<\hr1$ 5?9:Tč4%Ɔ[$rc{1I:-lƶ{Q^5 X$E>cnf81[ 59!xnhJBa-ózN"u+Gf9Y\ Hj(Oqgھ` TX='rUuU:u(ꦪ{ ]gU݌mn{f?N=@FNU5'g޲@y)j;Lb  񅨺M 3S d{ʢ&>kk2Cb51c?E5I sVWFd!j5Ñ%8dF})]wRr%?I5|Vm*QDJ/w>ǡZKZkT[zzʥb)wxgUĭru%U8> ǠXk!K]c 1qxI67UXo?l պlkz@.BM.<5l@0eՍ1վs3w͓>@n*tEK˴='6d8Prt+w= 65?+P])]W8 1 gKV Q1B퇬!mo?. K?n;Z*Iƞ ՃJ83P puƻ!S[#WpQ'k%`^m ✮` 5 -ci8#cLYcSx{cL#p*cL#PctFeB5PGT:Tb@ AZ {AX}saޖAx'\~;\}FYT;`{%?YjeQ/!i/kGGKsJΓNSrA4i^X.=a ÒJZ/zI[I8GKiQ+Q|%冡2\XX W-Ub.+\E ${U%hFnSegtmb]E΀[z֭<.˺g rÕӘYw]sygWBN BWsZ[gZZb2(cucǹ)ӄv35aڷ^w4/=T!{ 0D/F$k K*zvFZ ? w3B_#~ҁuo@C7ב3T gٍKBQgzBZAw5zs^|qr -п Er"U0t#-"hCe- 7/dW5Q[}HD'y/Z# y><ˆP,ϓ"h,$x340031Q74Kg8XjW"[-['\0D(/I-.S:[+!kÝ,JxZmsƵ,-46Ml)7f KEh&#/>9(J~M,vϞ=9s,5tg2o5~Y:Mb~JH1ɤs]56Irhprb\aM' +֛_yR/诳Wc_RŽʦfk-[IOj=ywm薮(ni.\QsKqk utU=53K[nl]1Gn,ausB~z"rR6O?q(#(}.Ԓg `K-D]$ݙM}D;Bǀ'U,BVIY?1/Iɢr^HhH.Ɂ98ΪEjM?l0SIZ+&6>d l6^PLsM-8΂=iBc"-Z..5$0q'įi/EwMPQ7ΉH;+i?)v9SHs=[_9mEwF9}SQXYrl;6Ua2$q hIj߀4| 3rCT(eкEukOzKN>$oViq8dmm;%<`(= _ì9Ks~qqs93/o_|m& ]ݔzcG0MX4@DSM!Wslַ mHSNۊ /(*kUq| NXBQ#|GDL yF߾D&\( C&`1 n-n[&u.f48zzY,8ˍÁx~W,XA2|pyim^̅&Dv/dB FmO+H   z,P<5G`nolq 0lG`Ĝ*"Cw>cN+AX@@C^[Vn#hjT8X0RE'FHI]05Yh׵8xm}`_1"cO0gTFnw2xms?z<ḙ0$*Wy-=iGS5l[6⪱!1˫9*DIHYkje$Q`dXS;'oZ ߊ٪i^^_ݪ6B҈bz926jxl!DT 2xI]|fV!hoQ:Pn}PT$FP)@DX}>9 [l,!8DL^d:LtmZ#xbٽ_baot@!,:_G=yp;%~hb"IF~Iv /SB7EkVGF} kKA ^$ ۻA;zwÉ9 1@T_w߼x7Pks.(`B-0*!/kC5 t%="3//Td_˔4**Nl['_KO.)>$OT` FJ5<\TwE 1M"?)- zlv>sڄ )QS-ExB:E՝Q*TgZ{K"=*=h< [TvX_u;%u@PP7'os7zXgЧ8 ӂ KD>ctEjEW/o~7ݔK$MΕ<޲HZL^̛ Z9l %nO%mL$GDut.OS*T3$vTƒ73*ꘉb%$|'6 j6:p"Ag-/s c{4 35[(I{IfŨ {>\Ūڛ4cHYgGYsB<4ᩳlvG@Cw*DDm5(dVI[\n; s۶c`8KPXޮĶ!7R$߳i.n^___^u^lȇ&rG-SЬ6+wcKXҌ`pq\092j%4%NBU=8B:琵g]6bc$MhW,&' h`r߃ڪESʚs9'^ 0aӕ}ūHGH3l@MփEXcqqpWv !RN [ ],no&R@ځ( $v'T^P[0jҁqVXN SjvȽPA|RWt̎|D5;{m'sBZ˙c{O>ҲK0|ܻ\%, b) M70qEcoc!s86 ;˖2pgK:;OOdJϪ|Lϔ|x7mnaD*Yb6լx)e ݴMjk1iהyic`EԔ՝UTEVJFnsaڗaN&Ɗ—8D'DA#s::ִ?hNiUftb^H`#>j5dlh>O0@QxF}Džw u2s=%W4}Z|j8MZ V6g c-bA6HڴLKD8ed@J{ .eB ߊkL9 f{R_Cvz{ /N z @$ Ë#4F1 ab['cRUF12:ьz"r)z kHFg qbB|]lk7M?h@-<:s[1᳧'"nӭDy ýB̔|yUݞXx)3z}=Sw/ֶ˽ԡM $[F&($c2otP]ވp,|4.S%s1Qe)K+oSv-Riqz_do ~)$(%!+cND/SxzGI>`A;X5sXߝ`9e7v9AAPAP1͐`ᾇ2c/m YP z>T;1o/ T{nilݵO.m.'GOb'-rr=f+d~u[,4yz!ebY e 3?m{)6CEnTyLCͯe׃d!9 hAɇ M ?bݦ.\~n8z|ATu_Foq_8DAv}(NJUL5Z6[c H_#q"B@ȏYH3L&ZY'䕎xlsIK4 $Ѽܥ,BLƐ5I1"\@0Y8U^' ZJKD_08\&X`Q\*+-=C #_M4YjAp$KYˑGJ!/ 5U/(<yy8O'hN+;cT^Qu)" \О+^єv#,281,.J]ϦZ\h0f lN Y : U 3:KɪCzÀ@~QWذ7{^8sF3C;yMSе6O #Oo}eo0u$`+?7حs` +M/hPU/+*]%֦g#*:m}5j>ctt)e [YVx+\ecqPUQJdz &=>ynK NGLj֏3*T>BysA.88 Ϲ"y$ }T<83:)豼p0ާ|) z^N &Ț)G `SLYiÚIeT< Ns2gΔ;X!Sa".V"uIcc7Lzk#OJ Ј&D8C@)%nQ/ 2V^#8+](.pHgx?I:Iaysv[1"%m&s]bO˱3&f=&*`1d<,o55 kЧx2????~:~6a,dzq8j<&Vd?y4yQ7jl.dCB2`Jsw3"n=Oť4' <\^UѯB1uj~ n~J.bf+$lX> ĕKȪdw&u4w \1] /xqI/5Gg}儐)K8#w-HrW(e2 ;Ic4jXcbJ=8*A:N2mq?uu[;IfU7ӴM^"T^4UE,}E4d:7%>`% (MYz\"Et=c65C.K.zp- ~yRmEb'!j6E(3i@,a 6(qvDA>bMwe%.{/&}eV.t@n`H ]>ݹD+5? ]Q/2@}֬Z:Yw4ټqY)E! "ʘ\3 m||+HD# =MG <.!a~O֭sxsk]2M>ܴvʛdr c#+6 Jwww]|1iS!UE]N"1K'euΆ}V VKQ>#ki+.jFK͹ȖdAbT!Ϻʌ8n\? w<%F7l" ݒqoǹ͸^}>7GgA:ra@Y91ߧ.̪6Eꙭ]r=y}n#cٻ@L%Gx oX9F\|OQHW'.o[.tJ T7UcI ׯ$]i fNۃO•Y`FsX 21dNZg3{\!Ge"Ǟk#ۯN#CNxf*ꂞm8sUWtD^ߖ*=Y.X":q%pWĵ#T>mpHAXH*;F`Uon@-_qȡ  n={lظ^+?j\a?,Q o,^skS[9B n}EVvWah/n}]?B~qdxTMoEC؍C$8؎c6p%B"I$c蝩m1=tx$f5KNC$#3@AU^GNUUիG~i<["EЍFVtUEXm --lYT~0z THe !Yf`4ub[_ttRdY]UA5{ڢmȜh؉Hۉ̉X"5B^+LH2| -!3趹FlIv4W yJ 3`eߐP66I{Lu`r \ ˀB0Ll9]у&KQ[ݖ} GK =օ 葃J/;lkhPJ;.S݅2(hf#-K1}z4Tbo2L2Yqh*W'kR1\h 3`32M!IT-OIh2K'QUxF.|hm]tQ?o6=n?SloicNwY<.k V+ TDPnA *kxe meԡQP%qZZ 2FeZG ?{g6&&GXzt*)mXURְoj(䚬ߪ㟥8ޡ~CHTTzLK(KJK:Dׯ)UZTjLN5JdZ·:|9*c!"yl[r |iyp{C++?SѸrIdͭnǑ[R[[Bp ~t{=8+n)Y=Iw$GnS/?[(&vKe::l@Ĝ0Ћw<8fTY51^.UnW7Vwh^p1|qFVU#}(,38O~G $-0vw qQNq7*pzQ[,ǭ <-xy`#5ZWTަVxњdJ :GYyrm6},)K5:~dmIz JhU#y85?ܣ ޵tZ2+xg } bn CnCQ@qTfƤQH5m0e k!F`k ˝ p_q~uTtO{'sB15 WRɉy4SI]ע [ݱ<%2 O<L@G@?Z8 Oor4|D |TʝAٗY]{_nn]B*=jkΛUb/ G&Hfx W7=1Labb&FUoՠU9m>Oa\=|7 " \i򑗧Rucmj~GiqEy<_ IEqjMkR gg>>XdϽH k܏s8ҩ[m(_K&fZl:Q\iu* 锂7:ȋ:磱Kr}0Rj,HZO(8eT+;n4{%{6lhͿ1l{G+ĮP>aب޲Z#zO=zWfӺuVKMkehdv6XOmk`Sp_nKWzYu8EtSZ#>ր `Q`9͢U@wW F*n\/4FSVz_kR^Sc՛Rc6#wO-r۔@W9\حFӻ!t?::xØ^12";+F[qsUXwlݦRs9spϝ3tȾw6_x3eDD( #.YCv}Ά}2U6cdrͩW]p5n󓮣n&xQ+KhS;m9q.5^lt"A¢ܻȧt IBin7xۚzLod(xKkսO)g%N̂ %G^[mGyiaѧL |MGńFڛsJIQ`]^|bV$×J?S0 l99[8_bB|\H\Oj2n&w~dDI2y" NaB8p%!<?'<,gLx,poZqF_315MKw('єRCOtlF޳4M7<כTZ&sȳ-QVw?p/<y 0c]j{]&kqUu>y +p [`'<-Eם&ΞYMA|lw0|_^Ȇ."vnz8|Yʚ{TK*&)1_`Ťr wظTO ,kfߕO_ZnCr o!!RZFDҠF-gX=JyE 5G?֫޲ DN:2Cʇnߑ9[g"?NJA75f(ƴ-*`~YQbiH&S(k8%];@@Ltxkޤr/DY?)p[z֘1<6yb=w^/̭$?jX!EoER%//#»uڛq(У$Ƿ?:K;ZSEґxl tN&ۂT^ڠy@Hu!! $cXr]1A=K00̀ Au)ϺQվ060:\ӧ.T^ylrHq_pe DY ( 96ģ@4V22s gE1۳D@2B@obFq~vL \ ~GIUtCĽ(s+7ŮU$Qb>#l܍Ruj[PKTwY_esQDVwlB !0ld~kbC}dr.cyu9ߏ1tዦCr Cփ,g+eJ%zzpqͺfcf 3/M*ZZL3*'3,f鼚EbRmh2?'i,f? oCbExH _( Ъx340031QHL,/I-.Kg8oU:;_-?gWC´̊Ԕ_BxHV od8YU\\ZTY W|ǪؙZ&?G4Z TqyfB^y9S7E/xm ,T]UbAj^2HQ߯'ͼ4mJD;(~ Zx4~e?h;xSn0<_vE{*V2aȕwI=ܞDcfvVjd5Y6h߄P:HPNkE5+!YY52H(XJ,l%tRh<(1`C '|;iJ?A:$4jn<`@pz 8PYOzrW)I|VZ3NXml%L&DǝŎ{li2Q-g|/-iա ֜`9xmp i" zڂB,{A!sX)ZN/ư\EaS1V΅h~o> 䗞q )x!c8 _A^ԗﺭz^"QUۀQ:Gٳ$"R4bji=Fq]ذzp\\\lS <b-2h6XϨYoo1=lbJ,+n6&,ݸ.b$<gYk{}kЁmhsZy5ʈ\_:Vxhpackage zapenc import ( "reflect" "strings" "testing" ) // A list of ids is the shape every chain reply is full of, and it is exactly // the shape bytes_fixed exists for. The element has to keep its WIDTH — the // schema is the contract a generated codec is built from, and bytes_fixed[0] // is a contract to read nothing — and the refusal has to be the one that says // what to do about it, not the one that says a kind has no wire form. type fixedList struct { Nodes [][20]byte Chains [][32]byte } func TestFixedListElementKeepsItsWidth(t *testing.T) { sh, err := LayoutOf(reflect.TypeOf(fixedList{})) if err != nil { t.Fatalf("LayoutOf: %v", err) } want := map[string]string{ "Nodes": "list", "Chains": "list", } for _, s := range sh.Slots { if s.Type != want[s.Name] { t.Errorf("%s: schema says %s, want %s", s.Name, s.Type, want[s.Name]) } if s.Elem != strings.TrimSuffix(strings.TrimPrefix(want[s.Name], "list<"), ">") { t.Errorf("%s: element says %q", s.Name, s.Elem) } } } func TestFixedListRefusalNamesTheFix(t *testing.T) { _, err := Marshal(&fixedList{Nodes: [][20]byte{{1}}}) if err == nil { t.Fatal("the reflective codec must refuse bytes_fixed, in a list as in a field") } if !strings.Contains(err.Error(), "MarshalZAP") { t.Fatalf("the refusal has to name the fix, got: %v", err) } } S洎xuV_o6>E@{uu,J}XV$+ Z:DeR );^*`bpdw$gM[!ǻߟSZQ~[?ELSoqH:#fxR%:ֲt/_B"pPjT԰Tev+ߋЈ\@ :mkH:@AȃpR+0XvR@luB? ",>} Rjm(N44(5N)Ԑi '7]!M?4ɦ2GM4;H^KO㽃o1z߹N4E }KJ.\!RPHZw;"ѱw뎠pYPnEƧ`"I|8՜(nyh79pBҤ͇Pnd=* 1Fw(w^C'b!Qh 0vݕaI;;H gc3cPV3yGO3 8aK!=ᢳh*aAWd_#[>U 4`9`2-\AaZóTo{*YD;KIDCPِ}@F[ւ%UҸӚ=T_Eo߾Ӝ}3gT6Ch;3V$J*&ƂliZ*~Nob%"/CL.& sْA DEL86쑀d]?u; },'vfu}D#׷0@z r fOWhVM9On|Jwm*݌O[͕w-8W5ML|O3u7R'qr ͏q>s3~^ëܮ!φ*U T+x.d/ Œ_Qћs;Xs4{ :N433&GIST6E G#p)O$F8cj =ފ YP3` i_[asr1>zn9ҽF* 4M';}g=nxlm5pBIdʗ&4~`K.3?A,K_UXxZr->KZS"t剦URiTrArYiE3}>a9^v=m&wMF(*F#LufEkj⋱@sJDq:j6{X&؎gp'{i4nOĩUY*nfh2$VX>3tҙ؊W'}ד dj+6&2U28\&3f;%ISHp^'-l4.Jff,_zoHmViIB7 gRhOICAʝ,z4~u 89 j 9QcHxM 'NoyƐ.SYg $6~<;Q0ddc&0oG81mOB|cLӘӕ' (#4YȄgω5H^ljaO~}K.N2+r%&ރf `9vnr@`LBY vz9X5  (pLߏP<|mMc|,v>MB4S+G)o8ȗx5uˡ|y/8>V}b9=lRȎ2ѡ!n bIibwh}c[7 } IְT;P7͜$rɹĀz2),0 Xp9ƞӿARH.8t母=(O=)0sSG9lA9aҁ;I,YݧTjq2$%`Ү-zxji^/ߐ*k P':9b[C d]P=YDI=goHE2(gvtEV=t"V,oYoɺ@8ͷ\m!ZB ?kXĈ{J/d)v:b_ļ%<Ė-BS1Y(v\yt+7Bu]Ã5‹B()0Prr9pa! XBemK&/^ N7Ư _ a]qoΘ+N ZyRb[_:8#q|*J9S XoAz9ciu6?~ث]el`9pQp]lB\*ݱdV'u#|:MiWcG}xnOڍشs~W5w~]I.隱f}G$$:){5S 4y71Na<pJaB]-Pժ"o\#3a/NkJJR=3 \߄(:躒 K [>GkԣKFY<$NLOx-Hkty-e?n4eA(5neJyņR}  f0Vn(3UݎW0v%H#  `m ף]NN܋F *UjePv[P *W1H"pbJ]p9]N_%zQtܴIBA(踦7 "h3ZV> ;.lwp<%q~7?8v Ms߼v*;i+Ǖ|*t? /kVwpS@-ʲ.y[x~EGuE}-8rCt:Uw"+IdĹlѦ*B`zV Tq31wSW#(ܲ%\8pLf{JZ4T-8t箕8كk!Mr5Cc1&Rvɱ^&~lPn'HC ,鼋8ڮ8:B҇1{6&Jꐅa ]bs'kZM>w?~\gYŏ'y,K4KۜA~ә% -\ =l,$M&'Qwi _zl-m.}POT+*.Ƚo9t[ӿM\.KE,\?Ym-ƌjFu0YວMuwn@ Kpq+/oa_.Oz/.N/|Ƀĝ_'B*rJƏIK1@U$hJ= rfĪMbi& |N|ׂ%ܨ9=_Br%q.D?6a{Gꪋ+Pl@[r 9&8\rN־ MT4Ubhag9{l< FܞK; е{!n?CmeuU^>d8 c%=&MмVhVN – D^oGwPHPQJ b][tV ?Gqˁ\7g4unUW^:2%wF7K0t [0V>h9ۻvS[w 2*usG֧~~,|%Վ=Zvj3f?Q7_tEsfF;?>WG{|;h v'T (rGqp^+{*:v( y(z)LaOl'W)29?prDn0_K"U[wQ܀C!SwJaRNQɊL c\v)8վD+P*]vp0̇P">F,e%0^/UdU뗧Ց~o*Y- uٞ>3r%XiŚ7m`J{l[t8iѕv_/dlqT lˮ0en;5MLlsHߍS D@-o(!\_ $- e$6؄״KU-wyA`5W }ulq{iɵ%w/;en,l ]`GemAۯox! ;CaevOѣ@lz4P@CetNHK 'b ugScn Si~]S 'n R/ڜ;{àդ=Gt@͝Bûf,Bt,"[\3>$*h LXϤ}&% ^="KiU6&Gmvl-GP RUdDI0ɸX5  ho4wĐUaIg IMz(s1k [lnQ)QNE(eZ sHo1#נraWo6+{4{㸈S1KG?V ~Z#eD#d>V,%0}$%Z GdqSru^^uƪ ;VqLcy$} O*/_cFg3Pt `s!V U0ƦGծ v1 UOʍAc~֋L^ȗijǾ[3IIFӦ"go&e(Iznk|XvGt*9.5:WT~3>K_㼟痆[Uߞfi6o%b7\ԴP!A014&aUwķe1Ň* ab6{zVNeQ֓)/y1u {3qJ_rxk " nv(Zj-K_CoY *8+o̷[2nH, Y$GS|K]/hPj}ʸQs~,Tf;O@L$0hJV3Alwo&#o\Ɋ,:cIUYߞũSIӶ+(aM'4Q1Kn,È4cYFVE/AH„/pl(䚮. x\rGr|9l(E,Wh1I(űU{\S=D!vOu,@SDz`w>{7=sy.3k~IWڤҬӼ&ů^kMl:MYX3{?sԘ6ic5Ӝ[SfiURq4dGb *p6G{6&,+yVFR7U;k u0Uֳ\f5yzUREU.jeM6_M]ԶZg3ה{fiUe::]Ҝ4eI#h01-gsS(90 2s?=9W 0>4yYCݠƴl9M}leeUyIAa׶ln< )geV_̛sO/2:6Xˆ'=<&+ ,ƦsYay2Რϛs"y6;G{CQwT=;L,LZDSm "HձYhNŢtW™D*k[0wglbY3v7I0iT͚=|O8:|yǃO͛?^DVe:摗fv #7ʺ>eNd".2u Q6+{-CipGcl޽Ǐ 1V%Ѫ Ih%:0.m,9[Uv}seGuZe4{ZY8%.J^[Ad;kH[X+^r Sg.߲^ΡvmxC"q8W§6eSRo+P0q 03;=~}W˰>4E[[^`Ѷؐ-CWP{H4AEmeEATD9^:c-WT)#Rws ,hR3鈆!OZ;h`ˌ*+k*漼9+R$küeoM-=NT Z$rQK^wdGz~l~H<͉-9FVuUXj6yhiQ_Ұ=|qSbf'K4 f+̘IZMsI<`sŖi =JDwٔ_cMheɶc":J}xCjt+X\&"ewID&!W2^3=VL z:O߫@5ټNCOS6yLf38=đ1lY_nB^ ` /,I>u +K [ֺE&G(wlGdwp1ݝE0Ge%5Om_Ic+ժU1PfpFN{{ݍ{g`w; <(ڥ&RYsb+^V-}EYh"1BjCHRN,QґZR0sԋ-:JL:XYRʹv1pDl;b[Ue5 OLs]ǞгeKZpja .j1hGH#c'B:b%j𔛜Z 7S.E]k[&7^<_펻 .Z ]5 B\Mya&:Sw;mڊ˱iwZBJ := RaY>a|ǰ/Yji ghZ)3\)+A }¸:8$E,=ЍTV>-Br"-Q!Ec!bn.#Nd 8FW6b7w ,oJ)3NdžQǤV[-:gEF|8EPi!nҪRXld'Sde O)Zq+KmfYm^:2Ct"KZ ~?`J.s"Y$ iz_E%EM.l}GKeH}q׉'kwYX˫[9# qڏ, oe}rl]+=I$Xפ!4*z#=so튩 DOvwAKs-&GG(}|>f\_poР?q)D;4 =O|0󛏎_CAgSꉥ >'ּ{Ʌ{Tu\<,08eLHq|kϱD<@#ߙS9OجGE~D;Ba1@ZR Lo.ow+~";PsPqh PC4138&0&Z5C!: eeiE9PK&ŕqLC,7 `!)GQf3%CtK$uFp!ɜH,,gC֐R}m%%1ԞeEџ{s'퇙]5l9M4K@iB4{YES]nc"\[{';k<[Td8jnPDe/ADra@QRA&4"zVa2;u :H˱n<[N P4e9âA&j5|]*B(EX ޡưwe ?%ЇБn~"Rj\rBJj2V&{߸Ecams֦\$5.B@uZPVK]#ƭtVVTV|dB,qf".L$?FXņC ܱir 82*<&]-yQ!bBV5 i7 0.9Wc,sM D &S<kBSG(2= ;BWԪj 3̜@euf+t <ǽf˸"ƁꀛŸWF ``jAXxNXu26 0;qĉOL>U.lw8LH1ÄDuB+HPĞ<](YVt Uv{HFD!6(.K",b]X7 r}-Hm@MnrUœ&ۊISܳ#H649]r+{TIBGLnYߑ|K䣧}l XUsPl֌<mΑ?,N!q,*xakث-#n)+;l8*nR`DwKkr'=&ܤb  4/F)#b7#??ڨ4%ÀL\L1b: g`(8~CqIm71)%ssX7BJ*Bp{CH gc &7sWb&Lc( il s9T#xm|ܖD&g $<ԟ6}P?54ti6TXa\R/mW1Cu聀 3%suL 8Nm= x\,A"6jȲ9sh"=TM[z{'*~"꫸5fBq6VVDDYTDK.zh' MNAhSH+QJcv S q.h oQp4Lc8v&'(x?vfmBPQP)wj`(ec+0V뢏=UH]Ia+zg̗m5Ѭ߽#nٚǥ4WxK C&Iq ӰP {_ﲧt\Bv\cLbWZSH&=D8Pv_*I2ϥ k( ,"h'?wxkay$μ{-I'՚g;;]صH걫ߕm~Rm{bNiS>5Z)ͦ͢jҼ8J @}&VsmmjB0Lϱ[ >1ܹ|bO:;Q&F%0VA(9Z:ɒ %#i6CnK4"ߠ㍄`SԺ7/>-K$eh*il$>ygMLVGȅ>b=qrSlδ5-)s ٛzd"*~E*||IIpI]]"9,#jŃ?k M$VsD[fnpJ5tn jіƶeB\Y -VَdyEG yc?`?-5[y ֦U E 7A¼{MLVF\ jDk/-\CS<*H/ ]%Yӓ|mRi)eGߤ80 ʿ%sXpNn6Az UUE]5??ވi5DDa M~8r϶cSluBBw ӿ˶am2Lg 8ΧuyĴ+|o{^L Bw8%ǹOa(? MC(,59嘃{]9yMw [Ys ["n[S=>%uROfCFCdik?N7vtC3Ӓ,xnbnzT]'ɖLB>ˌwSZ']r ) aE#(vb)uo-[.-!c&]4 T.}AȢ ߐ`9'j|8m[1' ;<\Jm4IĒC#&:OIN=y:WIHNB*-秒n>TRxEzpdzN svtIRHJoWӌClgߕx>Gey 哜5W&yJzBmb#=1>a7\: D/No]hggpCn'1U~#)Fk5ow}B) b}륨ug H1dKԀ%a.2(r$:!vѩ.@ p0@ϕIIWP/ᣮOl`4%xXn-=IDK\C(] *f1%QҴ,ɑx CICK)~^cua7[3ä}M4* fBSڒ{n6>f匈78M5o"*ǥ>3#^q8K 2'$?0jNrZ5Za-#02{~ϧQBp d)ε\6ٸ0+.7B;٨z^.F:! zYQ`&כ 8qk.pd*+5qU>!_#ܧcui+Ok 4ل奎V:9>4s}|C2rx$v&*FR,.nsZc.LO.mZIYjwv}̆iT,c s2ݝ@_u& ̬̒ *"_AxHlӻw`/(cn:І =SUz!o7TRf +i+Y>=_&"B%ykԦCy6,7)%w,͌mZ7̣ ۧ+ | uO%$;}ONHIz$]KQ_-%W𕈰EGVQQԈ #ɾС8U^PN<;b7T*G,׃T,fs2%ʰ08n]WX&F\ ʉBELbgSu>T:&fi|nS\G>36%֎RAlgVpaz9 7~^[̓V8D&U c|]wmKpSГ@9zS#U`*GF`:@BF!gɥq811+wS>Mh HM@Q*L8qA;v;ܫ4gY'x.&_*O.J" tB1ILBHPp+']A4#ab# %Vs/ց~QV^sıou/[hZR֮֞\m칒& Aqtxđ#a!B jIl2㓣t>8;\VD|( ZbZccWXewY '(*LW]WmMΌAV_@-2#t2aUas-S@+"}`y*w+mk>bsO XWw*Ɗ7GJyk:AߍWx@ڿXäΠ pdb)tH"zޥܬ¸_:GY-`z~Dm 7K:b TL`#>Tk:*>T)~~nsm-:<|MN)0FM6Ny+dc RtzKWpF;s<ƁTgT=cz+<:iy|cM$+yVm ë1ҙ^l .(vSL ŷD<@զwbk+17p-яP)j_\֦a=i~ùx340031QHL,/I-.Kg)7=j?9057$|C+r{yf0%%E`Um]J^o~ nv~M(vr˭\^Py)iipi7/}z 3y2=*-J,N䔖:Y;b_31WSK4Η7tmOY 5VvTn)5 Aj2: d{T+JgfNBZ kR 'vV}*|b a`+ \KCkgduzۥh9#EvޖAg}CS`3ڸƛ:9@?S*s88Z.ɔV9U13[#nDd1. %+b~l5Jy/̏h,_f~SfG*gEQ}E .ɲ\IQjrQyUoy\VΣ]V\LZngՐ'q5Pw4ȨCW=/&_X pxWy}^xٖKo'˩aΪAUfٳb9qX:_10dZ ٢]Ogj4.EU ca2T調E5(NҬ^⦼-F9XI=PhV.NZ堸&rEhAr>]UX&i(<(1؁>T_qb:h>ΜgN1]azSGY?dS )I[e˫yO5/;3( TIJհ@W%r .|5< Ų}O:m ݗ < 1 ^ RUy=C -AF }rj+&,,.K$a2<Za,=M=txv%X&!fb%;P,+U9%caVidX)?fl-au1.ˬvxFm@x Uqx6?W%c,+YDt*dKo+yJ~4ZM.f 7`f7=1dtrUMhF@5I̘&Oktr"|Zb O19@|J (x/OfA\HΘ墂ok o=:wqpKox6NE9T S>e9"ڟWcTJ艹o~oSZܧo@sׁTӶ1d  F{J兊671`?3r s2_S K}ʲ?])Z +AYqZ+zJe̡p2 &uX T0ޱP~՗9cFN`=sivZ%]^'ũޖҬGŸ31>*׍|n7}hG lӏ@ UuT[ 2 <ş5?M'R|w}UU _gO6]ӪvUx*/p-WWd4o!Y0/@B׷-hO>*&MڈF) -@x`ҭsk/Z-CHN:_OJ=7LQz|]"_{{8{ {?xV۽s!?ur%b2_&Yt`z͞@ͷ%3#eHTLo&Oa<:?'۪+DD d#lB&5̀ ȼ/i$N%ݐ,{z¾'膓NHfjjXD-Ѱ Ce_BbF_ MŽ5 3<"RC/ &]]BvUW'H>8%ͦZ{e'9к/N?͞\c, =.!u@mI8'HS9V;MP.3mDY,-j kE/X >fwe~>y3̶QVFLlIbuu]#rIg yzXW;ެ{e~XmM-*Fo|8YcYLO&L'I]&֒'PdA|v09\-_MNN3nXoӹ'R# wVE}>! gEÙ ),h[Jg#J.|dzQʺ Cj\ DU 3?BAxvz֡d钬v.(#B3B,,KVK^쏫ke .ELi̪IUKVP6LyGyk޸gVmeY׃?cyGZ ʯ$zIm>5 W*j!:I L5$r^g.䔴~`@˖ xfKRi|PGN a}VJUL*S keƚ܏5ȭ+#VPgI܌icap$N"OFOM9* *6(%țyO뤑G %0z#?@醬&>[wQ K$ChUWߦ`44]L(p) j `c?j˶<}A1K:kKx?y. bavC$)TTa(!|A7S0<Yr,vZ7

3Iz/pҔtgDJ4\b€3_<+/S3Y+_+=_K+Ve QUƒ˭ nPCE2jnA*͔w9ʠS%h)Z螹.f+օ*334҂QF(#eO ]3P5rVS$yf vs\sjo3CZH5dS Ơ8@DS$”g&*hFR.~h;!Ʀ}"xދ%JIP-)&GDBӳҹ.:g֥ MuMhq-5&زlI޺Fs6(&TWTTu>0[΅&-C̑h1l^TJcAfBZX5;>89#ji4Ө1GA%U;o1ʇLh;ŰxۚF,#{qeܟQ"M_q܉b ]u}#ŗHIEtCESN]LbjN04\Al$͒B5VY)VLj;i8Z63 NKpu-w=]ُN~^1V̨t:\;Q4g?V*LY\˽Laos ΋mn'ˆlYꝻOȎuI@jԿSj%`^q!eꅇ?hfvGU3q؟^G$y`4ғ-~4X^Ȕ 7ϵ|2)#eԱ51Tz.?mEoH+e'fW;ɘ7r@`c&A|qXV:?ů1 S|KzikL-@X`̷+]HWbf 'ȶDZ@I/ci}T~yV93Ұ~ԃX5Ⴅ;+~r'U Fj1ᘒť5n[β14q\- MY ͐'CϾhoJ%Iz[8!iykOս]ȱMZ+)Pٶ V\d\?=oIIB qVU@JlhGG$DV1<Vސ GeB#4wwz\Y1 V7Fk'j8Q*Hed- =S[V['h,XE`(v :!t-B.mNo~_yyr._{*\Y1.X~z{V?YGwyz?ʕcL/MGFeȱ77aE'`k>x榻7o4Nl `Ω>`0boF JM$![1ѵȏ-dY2c7gтv|0pVuﶯ% 0+ Q{w1ᛎszS=Q??%iݐ#ln3rhv;8s;W~a44N$̆L IH.RĘ#_/ &/O/ sv-‰ؓ,iRR;rي~@Bmo?q%1Mm ubA`_&)ܠc^0[70NJa/ED1(񉈐nʹdVLn5.\8"1 ;P(jdXotJY)FVZutxM`\׀B D5TcaGjۭA$)# 2%6db~H^ܦPdyMMZ'%”*W4s`\;nYdNLMgB^hHyuKuz&? f;)wqtO-jr=#0'Vn[FҐky.hW1G!g|"%[)>Qm8ɃUmtá`Ȥ8-/)G+r | ply^yגr{็Z`kn|~ hB݇DR5ḿ'$]-Iu}>zʘgv]Jh ~&9"Gu.DO^>NR|>kVj. )tyø|\N]J;]1q(cCJԉ?TO_?66x&۽z% & ) lAm\QT,Ll[S4癥9)qmo=8b_&Jo?ڡ{Kh;&FiXDT-X9 c`ᖍ*M@箿(>n=ǔ jfΨ6BnׁeltulXZSjt"4&VӔVŘ\rʃ ?22&dg)fN}$wF3|4R:mNZqT`ɶZĿ5Ϊ455=w8o#)ڡR`8_ՙKєUKE4vnkEe}Ne ߦݳ*I=]s"vrG񄮻9nlAA @[6Y݁|:u/"%)o=(Sq|nu|ő#n+K.vg-"[4Db$W+Fl0 rxwwC`~r: `Ć.3 NwPlt*,k۠ CtҩT u 'RI-D̅Abl^~upA>cF k@ϷHvv}LY~;m~3/ԯF{O~gZK_?7^5k:(Ac 8ӐaX@"{z!'ޡHDLVH\Mڌ\bƂts>iT)D R \gXR"#F 'qh *av'0ʺJWuM$+݁51nd1q\ƑVGW`t ò*Z!6-臊S>oy5gD7)Rk|!h=#ct6W_Τ8brLaye1Y:su|+Ihw4ni2AҳjbQwШm|cosuDΜzՙ gz|+ vj\0$QeNnu=Q Fe02GI{R7AdJ6\ev*הɛ2Zg Gy^Y P#w"o֎(1I/tsvl][@aM$5<(1oaq"qk< ,S]@S&a>āY[ w|N (oSe,7'-=50Lrprzm@ 5b #xԯz`AIFq/2& gg :[D.niv1PUbۼFzBfNV;ߔh)5&!e7(rfsO+2244 3CLKfkefQd"'2wț!{d%J/[dʑu 3H +kF'Oxfctѩ"2mݠI>͵dEQRY6.{9{)ge̚r kV-j`œ4JA9}V[LؠgjIC%s6amC^lWJ(* R ʸ BS"lh4>*pA1S> '#.^'5&gki9F Ԑ-.<q_x׺߹ﰜ4yO/_|tv7:HiBR40읋9&1qlf/X44;OEu00γew[ʟ!\3#M;& *#MqݨO8}3q'А5"Ǧ\eCzj>,Z춶[kR~.7Co^r|ǍQp|gO'oC(=g&M)w}FT{C/MuPՐJ1] "^x;}͛AQ=0tn#«u Oc<:p1'tA=% ~+N[K!yc/P#oWikb^lJ@)@J9,,/It402]fQ9բ"Aj]Xɍҁd2 X< ,ؙ_LRB/tmK4̴p~wlծJy/|X 8\i`ܯJr\ 45$qj_1\vbcP-M5OfOM:=aTl"ybUʺej,,+GüsZ||~JJU' 5|["Q2kjԨ0%V*d@@0#n_ipuw}ަt?ݎjLttB'#6vb:}!(Wjz{)Đ@Tϓhzc`V-jkIP&x?#y1 ^$ pPg"c·~g.sbtxRCrIGx?\"xR9#>?n]6|&xEIǁyʔKԓ (&7Zkx:Q18}kt=X!JdFb9u-}DWAo$@~O,}ЍPCo?2L%2DGFު x(w.}(ӫϸ37=;m=:*fIyI%m$~P̦9"/qXY=DaF,cRH MЂ4ą2ߠ+o 4~T MRzgHq.z=l pPPIhMx:NVt;RgcU俼COC2 oV݂L'Dh>nH)JWٰ :k[6̷|΢\guS/69gL׊ssXb{V:[쓸$Ҽn٨=BΆ㑾"_tB y9IIyp?l wS"G1wkIEm;.fO)uK;JZ| "&nOi k]2G1xf>@I,nmʓ2AN9o%NL_ڷےF>I#42RV|\=xHeLzF e݀>wŤ C1qPZp!gS~Dv)qXg']yĈ>p6<e TGInScg_b7'e9o( \G>0I q6U)I}"ԯ~]^Qt<^IqfzyDBb7Ce7 '(ۿ|p?.,zM.|D7lyzz7jy#ptj[PL' Kt<ҽc$^j%(hztKJHI7 >/GR(%i@jAcovՋI9\$F:yI@|KrcC*L9EvnlnHQH)piM6ȃ<je$Mh&#е&)(N>êj'Ջe).P*glA =J; )i'5O)%OK×D)aMKz&p1.N\Mѥay fC(Ix+>'h:Ӓ|ArFV,J;䓴]||]T{}$Z] 9g^3QZ_-g?xN{$H?_CԜ!'G[&-0ӣOC3HѲJeRJv͋wpkCEw یublE'>o~vM\&ǎ"lZuEIp>n,hӮjPL#4LD)Ru?2A5OSiP_`3&[bvhŇbAl҇q-wPh“?t(CqA%^ = DLоSؽzꈻ`zAOlL-!%J R, QiuN4\x:u ~դ:; 8ğcz`$0'Zyn#OMis^}:QX`nAX|Hp-eA-Ac1ڑ 5Fsos׬[%-\t?i4 JiVֿ2H($O{ي(!H[ U%gR roӑ!?iFڅz@ChoAPٿ9ӵ1z|Or4Xw{̤k!HJσcՏf$UBvѳDj9D!ۅ Vi~r\ SɝdT<{O?Sشfp/Vd "ƗMe 1Jlj_Wst:E NV/SV=QS~cr@[ i[ g7p $KHRzH5:}.e2D:G?SOw qx<W E;\zbۡj`T.rc9i~0Ek:@MNGs:jr^?mkxXZлG>I/_'FSܗɪX?yW-JzW'sUжKzȶ4}6$NEw< GE<y'6>뺩 Ŕٌe5"E[smCboyH_͋c\F18A KYLK'C4OmenA6佨D+6/uQsueVm[c*ʠz|5ˤ?q0!&ƃ'$jWz;ѧVL UGT;'w!ɥ9@q|,~큮sWABIu&P5ie-ғN%7Y3v-T،4:kaF2R`+P=*=}P ϥ'C3jSbo˻|2QZ틘󊕱i*%[uYXSOUhM* ?eĺYh:Vw).g<_:(@̏O֋cG8[ W9G2/R`]Axjlѥd ՜L8}.RňMGG7愜Ԝ.xaAՈ m([$4Ɠ;(Ok>2DӛgmE+?#dan d5_[osxTMEl "AQa $QbZm6 V3S=tkŜ@#ܸs@_A\,79LWU{.n]Y}u嗗^]@ %oX;K.#Y5ʻ8Iw||#I)$NVƯ]~LlèyA8ֶS 85HaJNHt h($TfSraWӃkc8b,s3a]H \IMbM#\u+}(Ο A&Q6mA,I l I9TJaFP(ڣaY2ݛBM'#.5#7;|8jQ#%I+ٷ!x9oz}uר"CT>ZQrx[rF*-SE,)6'dg4E@F!I;? )ɮ\}7 ݘkq$"/`wIXj7MRK!^LkGuÝ^&Ejf*MT%y䷶ 4!6 Yp#f\^li*{DbR2Ih2 ⤴QtE*/h2 @6=_vT6-l;y*e*g\ILuɔU%)ݟ1"k|y~B0ݐ>u魬d*&6%3ai=,MV/@)J[-ʌpqnGxWUƮjΞ]N2ctdz1:+GD{ztH;٭) ~( O LQ,ޥ~9iß,^y% x,9+? 7M> X`4(uƻQ03ЄT&@±? ;2 A$Qa*AZn$4hÕw5-Q#Bg`U+{Iv'usfb'6֑׿CyEs]&gJq/$?aG^\) VV%ӄ仜%,i `079 AM- %+)1wָ҂ćёuQ$#_ Kp9n?;3C?yZ0/3a̓*ǻ2Vga PJ5XyVz9{p$~/(uy?O蓱`f0cneY5+DXq0 <0gaj 8 a<[zCEZaty < ia_BCY&0bD rUHȝ-Qʛ<YSӟf}@><\a soڎ<Sc&NoQ$sFF22-]1tU{5&,ˤlFa(n$C:dksR LY3&WyJ;a8mA>DinL䄈JD7 \87Fﵷ<7╓`Wm]j޸z7pW55eUKpcF?ó_(aEQ ;ٌlH~T{DH~a|2afĀ^ }O`_ ?VuAA"(5>{I(6Eg@C Mh,(x8:%eC B#]JLH& 4b. ͬ |²Lp.ZB $|Ռ􂢤bqS50SJ Ʊfy4X+CR=ٮdѱ [UIȈlU57hZdz&Ļj֦0.i {,@L2e.O/&d|vʆh^ez)˄ ]kҸ:!yǹVU65ܬ`Zz>>4 ۴ۓ٦ۿ?8??>[թXF`o%X(ʸq4uHqQ% VG_@ §!(V++6MΔվT27`y$iPְQbS`ZXo.6Ex GFGw??:,Jo\qZ(bM#7qRubET}iBa}lPҒ΄g ˻S) L=4#G֛`׆1~1 "N*VPizPIl}{VE# & 9P톀Oݾr/)9LkG.Y5$VMSDvwJU4ڿo7dNH|D_Lޫ;_s)$T-J6#˔q/36^|"YoP‹|n=O 6'6ėZҢfp&GZEH󶞍҅eSDzȴSo)NqK3$92乨֨XNc=jwS)a$:PI!eqNe8*'p09*=CbFw6>:RR]p+.Sp|pW&TLbp<HE+Ο z/J3q\r1#[o&ym,4PF\/ p_8Dɾ#xtb5̘rO|O;Pm =ynShNm`op a}t4%/g0+8mxJIZTj ee圱Зƶz}6y %YCSr # _绱0ZZ_JA|Z*Jd478&WTA Sk#K3&@9w!W \!B)"pqNJO8frx,Gol%`Βmpkn0ñӳ @*d }-PJ1ppL.cxʞlD+< NV~;-sRѧ4k4H&g0F@{վ^Sev+Z6c-6Xk،2cvJ_ZeSmS1quagTv u-`n^9~3&il7V#5J~%@R&s6䨮r.xUiݜJ O^%yzsM ]n9嚟B nӝrla#qnNkH0;t!+/bg%LZ;3d̆~n W+Gǐ?ɯ_'=~ mAYwreXR5ԽlKn׺mX#2c6p q]5EkLE/ktȰi5wzNvKMohm h볾}OsպDj9uWKwj^;T|;W+إqOUFUNթyCd`6`[5_:n-/Mw{˵z[iTߒͅEI]~xE7רv4uk%Xjk>~: !)?`d܂(Eh꺇%416M61..:i KYr9#Lt`ҧ\KN?}3LtL֩v&B]tH*Lova"$.“p Ώ.uv9F<8@Pr. R{ߜ޺hMˣm$ B ߹sO[ |Lj߸24E_M6z]π x=ÿLfpDK"h-5sG.kѴ n&j_o]6 'aZ 鵵 iK˔g[#>'G{‚X FoQLe˹_27dyJFO oQcl?~l27Z0u{T:JSBsZ]Cȗ $jql8݆[.ԇ_(ߪiO@x[]n밢<t#Jr3ؗFZ$];ԳHZRhޣj;Z0\:d xFs2(8%w2)U,*Ί4KO*>@7~<joYò5xRpackage zipdoc import ( "path/filepath" "strings" "testing" ) // A group handed to another function has a prefix this pass cannot see, and // the op's own path is only the part after it. Filing the comment at that // partial path puts it under an address nothing serves — which is the silent // drop this resolution exists to end — so it is refused and the call is named. func TestExtract_AGroupHandedAcrossAFunctionIsRefused(t *testing.T) { dir, err := filepath.Abs(filepath.Join("testdata", "handoff")) if err != nil { t.Fatal(err) } if _, err := Load(dir, nil); err == nil { t.Fatal("a group reached through a parameter resolved to the empty prefix, so /v1/thing/replay documented as /replay") } else if !strings.Contains(err.Error(), "cannot resolve the path prefix") { t.Fatalf("refused for some other reason: %v", err) } } yj!9cx=package zipdoc import ( "regexp" "strings" "testing" "github.com/zap-proto/zip" ) var described = regexp.MustCompile(`zip\.Describe\("([^"]+)"`) // The key this generator writes for a RAW route has to be the key the registry // finds. A raw route records no registrar — a method, a path and a handler // chain — so an address is all anyone can ask by, while the generated file // files it under the declaring package like every other entry. When the two // spellings drifted, a service's whole untyped half documented as silent. // // twoaddr is two Raw routes with a doc comment, which is the shape that broke. func TestRender_ARawRoutesKeyIsFoundByItsAddress(t *testing.T) { p := load(t, "twoaddr") src, err := p.Render() if err != nil { t.Fatalf("Render: %v", err) } keys := described.FindAllStringSubmatch(string(src), -1) if len(keys) != 2 { t.Fatalf("rendered %d Describe calls, want 2:\n%s", len(keys), src) } for _, m := range keys { key := m[1] f := strings.Fields(key) if len(f) != 3 { t.Fatalf("key %q is not ", key) } pkg, method, path := f[0], f[1], f[2] if pkg != p.Path { t.Errorf("key %q names package %q, want %q", key, pkg, p.Path) } zip.Describe(key, zip.Doc{Description: "The generated sentence for " + method + " " + path + "."}) summary, _, ok := zip.Prose(method, path) if !ok { t.Errorf("%s: the generator wrote %q and the registry cannot find it by address", key, key) continue } if !strings.Contains(summary, path) { t.Errorf("%s: found some other entry: %q", key, summary) } } } H#x31Ĝb5qj+.O&`ĔԊ܂TȯB:n&_tg~"#R9Xʲ$-(}Lql {ޝ Qgv{b)A-dQZ\_dW_?8`¢{#ļTK]Kw|{Tu6~Q?/ILI-f \nsϺ5`-#TAy~bJJy %,qsW4?|AQJpz!'QEBx&100644 workers.go,Y6~\Gh'x}Rn0 =W_AP8kavmv(P.=BQK/eCN~Gq E P.p <$i罀gI&d䅪׈ 1p)hS+Jؙ"Ƅ]&h̍) 5zL_]O;w>3 S}tA 8Xz'Xd]>5+FZ ,څ1PP׵74>gk+8mt/TmQK2Y媥A 7,c5*M<4F.t%w9V1v V?vAeJ vߖRws0]>4W- 3qYnhD3]8D|,x&100644 billing.goZvmڌlKԕ/xXn}3@vI"׋$ XYc%H ð3MrlwF /̗TU7.k?(rTթtu~WF-:JrFWS(oM1J327mUZkL |u1Zo|_qcekmYPZ*7^YVD1V[h!-mWknkUU 8amSyT6$ij7P.ti~xͦ D+SOVk`G7 CrXpp6d|_a.&<` F\ieg88L<@x^k8,cd@J>6npgn5@-MT^e֭2u%f3%P>%QnZNmt%`?0Q4ΪѵDNbܷ6[궢E@Yt^Efӄm-J H8MCȟ$/)jgXy78AzV3ߘw`+AX[?YVg-YCӚ 5!|$iXզ3pY"0q n; K[U#?"X*蕮EF/ #RK[Lp6X$"+7IT>iv5r<|epc-ݯ %(7ڎn͎P9!t;?$sFpBJpv-.rb_lYN"5I ؑ$.H0Σ{="fEhk$֠_Xike (}VW/A]9"ɹaMo^NQ;z +Ɲw O@;b>C6o`誺-@TEiI΅ٛWX|}eچW@GpV97!PTpp| ]iI]ѫR!"k^;,%ҩjJŠYFQ非^_^]\~JmjˬպEQmƨ?|?+nQof2{@--aDCP+pyNW99~/(@ Jc=7ُ3q H\V#'WrehfbVʒUIp),[PaL xDF,Cs }L.VL,PRpm;B^X%=_0OT&gc9EAWʲ"&_gMKp9?[|RԙMɵT (TlJ\rP2v9D|@ MHa;ۧܢF&/2;̦P'yǼekĬ%l k+H-+0Q<bIGз -h4 yB#^ۑĞ% C6R#binT#Jpr\(5]hiUޠ-X03r$^EyS-'ꒈ kOX},j&wH+YU܉Qr5Z7l+ q}gSiQB@{~ !cE(5ڑ_Q VZ}C`$Y%GiG7T00q` aqZE_B7h`WU0AM#5Nw v@&W2vNu]CˇeYs{,0^鲆yr|T%|̓ޝ*jTf|ˌYL  \+KLDFꙏ{~j(av)1htp#n]k|+HU0=H°=Zɏx*Fmr]}{ VW+(,f$R34Ѡߗ ?ǀS5sQ!(BƂ @z۰*$K倄Â4LpׁJ+d dw&Et^- F4[h˹IɍكHDcxYx(k;)' xٓ8Ln]fFU$) Jgd"/S  t&Fdl[MaT9MGTW5 Ͻ|jw}Vww 7nƢ~)o鷉  gRZVi %'D?HN#/P8'\[](}mq5f㹫?V_|tnWsBh}.1»`>3~2VnBYV& DKvPXjD(}Vj(F&QQAӾ[3 m̷;X[{4&MEB-Y3n`w MBŞ-\H]c+^¿.GWlEk5 ?*ͅ%y4mIM '=-i?~#ɪ.!q#VAAG7U?;s6ZB =mh ;{u޹Sd =Vشm6ӦW;F^ cr"K%``b$n?y>Ȗ Je rG 0@#!x5 Watch streams the account's activity as it happens. // // It reads the address it was asked at rather than being handed one by a // wrapper, which is what keeps the declaration below a bound method this pass // can see. func (a *API) Watch(ctx context.Co1if op, ok := zip.OpOf(ctx); ok { _ = op.Path } // A handler that reads its own address is still a bound method here, so it // is documented like any other. Composing the aSddress in a helper instead is // what made a whole service's operations invisible.A/watch", api.Watch) } xx340031Q(IKKg7-j_~گ?7R\ ̿@BLPTjZ(uJ>%[jx\Zbe+8$т'LIZFHhhȂǐ3!( 4hmTaS*hUېJgT &JL|qqN𭺑t7< ]L,\@j8!gh]*Bwy9mWʵ!8n%iR#a,ko< :¦`4cl(87k`byʶCdF k+t+q/y02,3UA y';GJԡ䉸&I_mlLϘG,ĥLͭxM100644 items.goaOwKս׋ z100644 zipdoc_gen.gof]P桞XV02 Oxpackage tables import ( "context" "github.com/zap-proto/zip" ) // ItemIn describes an item input. type ItemIn struct { // Name of the item. Name string `json:"name"` // Price in cents. Price int64 `json:"price"` } // ItemOut describes an item output. type ItemOut struct { // ID of the created item. ID string `json:"id"` // OK indicates status. OK bool `json:"ok"` } type API struct{} // CreateItem creates a new catalog item. // // Example: {"name": "Widget", "price": 999} // Response: {"id": "itm_1", "ok": true} func (a *API) CreateItem(_ context.Context, in *ItemIn) (*ItemOut, error) { return &ItemOut{ID: "itm_1", OK: true}, nil } // LegacyCreate creates a new catalog item via legacy registrar. // // Example: {"name": "Widget", "price": 999} // Response: {"id": "itm_1", "ok": true} func LegacyCreate(_ context.Context, in *ItemIn) (*ItemOut, error) { return &ItemOut{ID: "itm_1", OK: true}, nil } func Register(app *zip.App) { // At the root, where the app itself is the table. app.Post("/v1/legacy/items", LegacyCreate) // On a group, with a metadata chain after the declaration. v1 := app.Group("/v1").Tag("catalog") items := v1.Group("/items") items.Post("/", (&API{}).CreateItem). ID("items.create"). Summary("Create an item") } !QDxOk1֧xd"G;l4RC4Q+ mާ*-6cObF)8GIZ=6#h;8pnQ;# pc `.f ^}K/iט0gb sXq3y;/Ei1v8ש'L^a&Iλ/[PYeѴʏ_4M})r8 s2ͅ~9YKg{$9WzQcq퐭% qQy۴p4T $/^L\oxٓ6:5x(100644 reminders.go+msXr}$kc%1gW(Ƽx// Package twoaddr registers one handler at two addresses with two plain Raw // calls, which is how one handler answers at two addresses. package twoaddr import "github.com/zap-proto/zip" //go:generate zipdoc // Remind sends the invoice reminder. func Remind(c *zip.Ctx) error { return c.NoContent(204) } // Register declares both spellings. func Register(app *zip.App) { g := app.Group("/v1/billing") g.Raw("POST", "/invoices/:id/reminders", Remind) g.Raw("POST", "/send-invoice-reminder", Remind) } e 'x;ynZi^BHjqkEIQbrI|Hy~PbsbNNcQS~IK~rinj^Ij %))EJ\i 9yzŚ F23*L$$9e&3N鑔WZo_ZT_fSZ U S:ّ) @ UZTR%Ϳf-nkgO vp\} UyMɜGF5P @ܚҒoz!'ygQU x~hFmS0rCf灔̎Q_zm#a9ip%e %!ܟW^}|c_=TOoDRWZQ5M\*ւI3yob^'@۟ICfT/jMӽOŏ_TT LZrL6悢}:+~t:eCűrU%`K{ֈgZ~7|lϔQUŃ} 3eΕ?z<*_X+QgndxW]o6}ׯhjg}= m5GPg}hDj$eG) i?`//ٹN-@b"/=\)ݫf~W,eIu[yVBoZTRm6Ir|yhŭQ;UHr<`t 9\"Jy+l3tƚBLj>3wi◜ 7yۑYS>bt7SSCi[@HDT^ƠNz_R~|J6'=MP5%{،n>a*NZX\s , IDq^M%kؿ;EaN=!BDj1{g!+8J)'u8dcnl댚nWU~XJ`/\MG3OwGvVUG7DNIi^ Lb='K#csȏc=uY,)g -]u ?, Z՚&jnRpK4E*qm@Mv[IcJ 4þw2-ItۋPu+mpԨ9c( sG] x'uѡYY-ACUE#;$Ynd T aruoC@拼Șu,M `7;?R[ؿ#PQ0$R,qȜ[+eB hE '\u@)nDɻtI0I,%gpҸN**6эx4dkQ.xKŏok jwYHJ/iL6At>1Yrfq'hV: `A矦=lz3IR~7&-N:Q.nժ#]/5^N/b}[rN v)7p@CI]+1zy"ܬƛ%Hhx09\__eɿ$@疼xVo6~`dKm XnC=EHV"UrwGJl1a ;g1`jRFQ^V8` jnct:#E_p7Y^HxR18#%0Y&,΍]^Ze.9 `,B" w-c!W0ןAetVtZ,DQ$* 0rr16EUSH2p  S(E!Iq7#l3)dI Q6Sq ˵ pQ|<:Cm9M(&5/'DGB"s!;vp9hk7i pa㏊smJFgţA>P{0}"%‰2 ƻh˛ 8v1nAԺ qqoZd|,*B±G*M;HNt2>}RAe&@ ˕xÕ_G:t?>ku `>xvtȱjս^nw~_ o\ygBm<rr}_pػ#zC}p&1|B{\H˄x[#\ 19;1=U!x#,CJxYnm?GvǖE?<iM0` FhGVY}>a9$%q6i -<<|琙̈́T&͒p]:{[%JDRe,T)V" yfr8󅘉Ld]LO:*L֘ԱIyW];#?R|)D&b]DO$F˸R:U4JJ+a<]בNBTc=~Nz-TX 8&uY%1צuT(2󼤅P^6|Ĩ*l9gِ7%rU*Z&x < "LXKr:$>XFɧ2i2 FY8[F i^ X:> Nu LF:kV}[Ϣ* !m{R,*VrB;o.h$,**r`Ϝ"J zbQ +Ot͉8,,"x)'W9{2OP x (I 6PPC1pEk0@G d  8QUT+"*{Ᏺfx BqWzWZ"F@MSROʦ*,% p y'rFȂՉ(Vgw)$Hϟc,23Bl s9k+\çB5K/aV-e'Q,:fI l;68n# ZFɆ!C"?Rb50RGͼ+40LmO+L'AzbO?7i-GP| hQ"ͬҕOILTl42IR4w\7"]\ ] ha;#7`Sb~`븬G,4 fXZf exg}7iMdN>00EA![DqM?dmsLs o-&9vPJ[zi!T bc#Ci9&$MBLcO݌6c|ŦѽƟs#p`|'rj&'oWesv?5QIO6wdrd@;ttsm["rgS^0-n-(6)V(m ,49'Q;,KQer--(}M=7vceeJ7Y_RYGfڎ5jżӱЂУy7҂{w5Lԙe^CP4b>[G5e#K춝 TTR2,fƵ(?V}xJ+(`|uZ0TYNi1J.%U #78bK,̨S.,EIp"E ZaQ i@d9TE)..zy{Ϙf֪+9ƉlJ1Oi.pr#QDhrE Kjt# ~Q U§p9u2zjގw?HΜIcye*pVuU9>֊!Θ".F[M-2F34liO:sCr..=<h JmɄW0O5;cbeGfB'NY=f3Y8gh)ظV[SϣO_sDK9ޢHԍU6OpEvU8"  s'^\!qUG8\_ ~e+!ut(=~ :>iV].&G5s 4ʡV>9nߗE s* `3j2;[q$ț4cع{yo﷡BkS BGAogs|ѶYxMj_I7OM:&Oy8hwxτgл!\l~2쮕Yp11_=o<3Ze׎fE`{'-ENv=Y`Z{,>_PPS-kp:u cά5S'$ˣIw=zK`>]97J\4Ӿ뫌B!Ӊ;~䥖Ҷ7X^ܛ<<F[KꀊߢP^c[RU^|Dg8,&/ƻt]nIN@x[0_1XZɆC Z.mjR;ؓ^]TXVfM_93nTM-4֢Y45y&,7vQ3KE[[„ lhL'n^6|Woȉ]$;P޻5-;EB?(xkUU 3ExX_s66?3!rsw/ι3LS%8@$$&(fC'(87$v.8\輐u:30U>̕F23.tѠ3𣚠Xjd~9@ݴnnr2,o^^ۦal^g`<1vQ"_i#)7_L̔TP{_"aUgFQQl{i+LTI j.Gcb+(\FBA9ġ3i0 b)ˊb r"dM;M &v`#LѮyX.uZdrB2ܺ]IE6:*R) AC.Ot@)$ddtٻf":X9ӆxzTX,U*4Wͬ0,FZT_s9UfS~^~An|QVnKڦ_z]WB!ga $4`b6' %3 Lw_z)iD^qOO{G>Nl03>lxu<&%"LR|48s ,K4oF`i_Z+kcHE̊,v[3KS!2_n(v#"&f ﺉ<*NJr$?-|z)K; |O SС?mǘ }%RW. m3xcj3d_,9(VC-q,1[=> e J7R"J3 iT(f1B 7GSk(&O=f^4Gh!RĞ*jB(h@h@w'U#(!P3-t:`o-S43b [J t ?lY"n:C3E7"tݕ~<0&lG|dҋ{j)EΔ?ħ1 GV|6L;sEY{_|緻[[㤩 7f]u}Q~]fJ_HicD3 ĎyOwJ].4NxƿPZa^ϖpa` 1΄d\5VLӖ3RSX+q쵂B8ˆ=0/$|H|~08qAZ\bo16qdB9ndaA LL;}wӖl"_?!gsN^(:Y/xqy/"6F\m>okMjZ_3WB+" ?b@c|A>,y\;oC A漌{G-:}(дɟ\+QvI36i쿵 yv~z[1ms;n OiJΩ8~}TݎgAu c~/V*;?j O} =Mo~YU!ItEL$vxݦ f[ Z4O_ښ( P8@t =?k udgm73M КjxTMoF=b@);E. |H 96C VJdLrݕ?j.*jvv>޼y\ȕ"n]ը8NGIJ |[冥s8e3U|d"yUr=+3 ߻_E<ᐦp-jem1H4~茲ȖS Z$j=5\ W6F~U}ԃ2B)Fɚ.K`@#UI\rs88)KFWd4tuW Ue;Y'8lNMQ):6ys|2ȬrF$Vm7#rfRQQpN2Xls]<m3x08jxuJmU3ΥC# AvwgvزKmQP-JwJC[ @4|x 7Rkq)r8=,IfOAN63Pمb{3lgTiSB򴆌olWδ &eٙ./Lne5).RctI>}K0x=*0 [ g|6ϛ~͕ήFHdra[jCȼ-4Ff"OCf_>~0ONVM6뷣' 5%;x;%CZ -wt_j%,~!j)G5UHU]9`} TH3:s#gsa}2tLh(۶ ,|'=AXh'*pP/P Vevg2M|Q)w;CgF$,/[^dL&`ܕ:@^8'9d}.=') q7~ e{.D@cd:x+³ /o,+]A[xYǕ^x["P 19;1=U!x"gUbnAQ~I 7xeMN09S7$RߣX!N2M\'!qNI۴Tbey}=Y SSު^:bGuޑkWE=⬞]4I2wKa9}2P&mlwhti9Ey-a{|@9B=?_HH&=[-; H|G0R)ݾ\ABBk dbwi\_>8ߖ .yB$5~9'xZQ~~8uI |`JZI#.)Y6S@__ofvIJw!mܑٙof36lb픩fVMwN=[}iVFekV֭SlSzzv[0jkZ^\=T]/K֟6-L׿K4$#!3z?Mb.\j[M3-#WtIBv(-t Tni|} ~?嗹j7j:AUv eU9)Z/8y:[ptP8ZzZzӊYڍS.EWOgVk۶ůXU]FVRc?odRH n+IG&KjRH\s֔HYpi n[vamsebytB{oxBKV] C>? ۑIY R%u|/]gBHyv0yjsV+(GJ9n;2'͞Ԇl"8D$m፸siWzmVʦByߞGu|V?zq2kਜ਼5Olғi>% \Ԉ9 le׈'цŴ7fL >N'g~0tB:m7^j;W>2ƍk W؈l)!lޅ +ˠVWaA 6m,-mӗFʳR$PDtff;| =*u;eI "=`Ƽo\!uPu iJ+o<,3AF(‚WOC^w-#mmϟGT:j1ʱ:Z{MXn]ei=!L I:uא -z/y,lUih+1A(q:"Os琇VsdYoZW&ly`RbozPf),v[! @|O 0P%?+Æ.n MN >pJCv֭:QO;D8( MvvM߰3b ļ y^+'_pX @9}GPLI΁&g\ew3 .' Ubw:+oyX2Y@}5\O'Ș^/D5lx~ӈ" W3%^HϬQ"Eԇ èd{`@=@5ٽzJ3T_zzg9~ Ձ06ٶʿa-ս{I i5\ ^4;φo*:ߋog2W H -!>8lzONFȼ\%գtwXe 0͞ڮ-(EHe]ƧBP2m7x ҴYkhNpYe'NgodhZ}\};E *^OG{F<{[ڛD̡{^?v;}&^R)ע@w4;Pr/##{%?i6|J,}l@r GV)TziLjZSE5@a1435G2g]CC&͡Ay7#V56*x5y;ػ4tteK;nH5TeA /$ LTr+$m k5DLAdDS}BJmMz;;F%K$0Tᕌ'd;EW$t=jߓhU_t.^ƻɾd%3D0$``iHA~X(˰;VN1FǠLvA\;gk^Xy3l YZN?=h/,I[]xբpY/ 'er"Ŷ2O- J҃2BK,%:\6ޓ&Cby= ئQO&n>MCK`aPF!9\$q ls`ޑ9:(2 c׼Ò~ ovo JӰS[J-¨t2Gg2ق H~j%BC%l5ͼj`s >r?F>']#ݦ†NdcZM{-{ koNǧ?i *QxK֫:%Q $fbuCl@ǔ7[%Xk"Op·aLݳ&&G Dćw yO]1O3#Y^d%_ӛ21g1#޺+"|qPo8SIN2co_ I>"$#mjL KfsHh~qGԦ?t4ڔ3JU'F"u$$i⨤٘a?:0 ƿ=Fs ŋ `U'!e:(uOt'#?uj>N7"Q:##F+C2^[⅓i߇!u|?;i:4Ob]Or,<0Hݜr.!Dc h,ƹYeIͤ]sxVn`N'w}FPYi0w?o!`RP/|~W1_p:ե* q*%Z,9t̨%I2}xpphqt.y_~nNEF(*#wPDf"qbU]G$$^bKTB tkv[3 t#Ybw}lCqG^jjsQNjJZOY̵}E׏臄u3WѥsxX䐝 '<ےיu4)pӤ# D_I]qY@(T.L4`Θ( s4x0)O?z9¹P۬yH<0&ֻ]lxn:b5K~\FdPFs\l.n }/i,皈>r <!}D10 ymN]N^)zJygu`k2`XwN^[dI+'307KϿwl P$בQkq1{/͘I&tue Qq;I"؈DF?p+stI~*5A Ӄ9BXx L#T.OU`1\a0=t- w͕9w`#̲-Aإu H݉ƻwsr5O aI5sҠKBZqSꁚl+GyaxVmo6lR빉X ȲvH7Aѡ%LIR%#)[M8@otsϝnr0rbΓD8ȒNZhK'ǭj!M$y^L{WցgcNLD(8H 5@JJ)0vpWMyKX=_8 C0LXbFmxM/TK̾;o1טdiwm1 h'//m {P͏h'1'$b _Ut wӅKnjSKו˚waFW.8|J{or4*$"e؝u ;^(rZd>ty-$Ϝx~JќKw2yd e-ٲ$KCO.,r;Rg̓/FN&?/%KK)^bk=m`*lq * n슑XbhR2ԧ$" q,GH˻4Uc%g5 :W%-)9>h)v-ou\gpv CÇ}Y;kil` {A ϟ#wpۋd ٓ c_Y~kqb->ԅ(5Zp9|?ZLTҫ=_namk1`}3kߓp6Tp**ޡӀ|W([:zXGӣ]3zl[} 쟫Z+`RZ\ͱSLXzC3S(ˆA¦Y yEBbGAoTFgʩ*7ooyfXDYgxkJXmr ư)zm*ڱrs?>2;ٵxb  >1.u 2!8j9iwg)-LB=t4=ýΈ x[!X 19;1=U!x#LnClxTMo6=KbC Ŷ6 S֢l\J])ck#o(iM5fGS/,0:*pY۴nZ7:7yzq_YYjEs}t gFϗ{-K)7jӔ0))DHe1$"m|_9g R6zk.BV{.~$"4tz*^UhFېB%e; FH 䓥jw{ ][8RTQ;Kr;vIGPd\{G Qott!aiE7NuKɳQkw`É^ѡtl[pWhP@/%P ƴVe*hxHWbz(SF^Ix16S+4;skĀ`҂_>3Iʋ%q7V5*9&oi#=p\V(YCY`\ecUC q^4d`ѻ`vZ-4H3=- }K3×q+sbUJp\je g=hͤl5.R2x͒h@ E ,.E=A!57t%A꼗J-![h3jx8e\3YC[҅ P!^,`$o:N 8NNQ@[XpNC>9z-w96G3ֳC {5.(P9j8iuI.-Koj᧙bn*sYQ` 嚬6/!7gxVQo6~~U@6Ul^e@Q4Ey5{(D*"uwGȺAwǻx5؂íQժ1Lz%0_ܴ4SQhnYAptoUU)PUɡRyb x@_`d%22[e7p1@ n40h}+IV39WhPbv MUtR&GhZJ5,-3I#խSxS = hFTxlg'аF3!eƤ"c66P23BIЙ1$꿎 t$n_`;/,gꊥ+!Wp=N MkP \" ȔĚ{:4+gϢz6 o =3 3SjF9Q{1^swDXm> T%" ޫC-r c;r _2ӳVZj%$j6'Y -(uFU1|9$CM-06RZԲJϹ0#] F6u!:WG-$1_T3#n Kƈ<2z.8D 48q ӑ1nWy Lj3>JI6㏘RPZ/3|y+J'@~ԣި%R~5~rR ؒ?OB>IsHΌ,'EsaMfT岕ڋ/KlZO iV\)ۅJsqObmrp Qj}.E[6JHNMCx۸\ f%JjkQRaKYZMID(E.Bh#t65vN6fAj}5W\b,m ե6ڗ$d8֥߯ηRu&e?rٜ'Y83N}rD=3 Z 3*Bz/V=h;F!d"|)`>:ZW/_(baBuXKJ}:^e=$j).x*dL&*goU^k?#M{!^^zRj?tnYn/b{mO!-{mB5o) vYr壕r"=/m嘂QRpi&A.BVM2rBh n*Q h~lQ.ڼ.%gJU+C⣥",)PPPWpiv$).J"@rD"Vb)umS 5l_'9Tׄ@6ZK[PEP[b}gAh U0dWvBcG&0dҷ@Yyeؠb[?DGa!QyzZS?챁&Nsש~ah x;";ʐ?1RO]>7 -dtiy&٥ڍ魟yU} z[4P[]1 bve$ Q]QBNcn]6DL;1EB"H؛翡jD*"q#eBL^H]f;!ːxqy!Sx<%E̎H'e'J.*CQEN1P…:'xC6I5Gk dxAnm$8 >\'A\O}ؑ0@fyIǖTpaL-˱ـGJUuN*B#1lklҶ&%d=rUlX!DUHA ˄t R*=\#5Ij8$\ky)v70V[SWVl5-1<$@ HD7ߓjBJ3KٔVC<RQv:Y[-dt5|kDCe ~ hLXHdPbG{a ȧ~#yb9zypmD37rBCO_x8F=* {4e!q:d 2pA@/% `.vFNVKiKnSGQhD`q0n?xÇ숰 t4b lujG.`٘Q#H?{Wg(S0&:s0Ղ.!li?q78I$}$M#'~ CMubϞ^$OpRnMI,F7ܳҌ.~TׇÀ a#g w8gp[Wv=f3g񤿓XM+tho ㌗Bweee1hHeL#᱂`Ētx ]3Һ3Sf3Z2Z (N8nA3@0QEtU8x ņ=ΑֶM'G:)lzxHLt׈mB|}ib$Yc]{ns) -LRbb ^Ǘ[y|e'+X5:r=QE5tF/-5Blq5z1/fp@ uIk`fCMo87tڏaŎ*ۙovff)Dz.Flv[M c=EV'5 XOI0~kuʿ^:(<ӎ]r]4(U9TϔgUwdidI=R{#弴2#s: 1|9p}cXIBM.M'4pI{Xty3Ӹe2/`[w ]?zyk1,0; rF3E>:}ښv6Qm6yWs1]>9 $EqhsƋZ8KɶBNC QHpn(,5^ K͕Im7̂qQhudM(REOQgo{}`scsm}7hQgBk[ N3*y"29DX3DE2CJHy*7o\NeN򢀩c kl)" \c1eԤMEȩoE Aw-Y U*Wׇ~dj7%.o@!(ME1@h K@P 4а*\ yLTU+.!68iȿwmm ղYgCU="Ce Pܘ&4`aٲ@) Վ :'. 7ِ]Rf<~a!;& L(֣p$R_jNH̺!:A93+3jFCCEHr"t,9u}'vcrQ5i(1k[nC+ ֓85/sQu>2EBW=bb!wO^=ciC=[AQk,AC8|r^/, 6-8SAle[\ȸQ9CUx'=b&8,_gg8j'W2R;+3s|U] r-͍\F.pSեE#_J88kr]@w+誤-\6K嘩ܣ/_B|?p&Wrx> :?QF\x,'UU@z3xRn0 >/O[ CԽ [֖r{=H;^o`2E~?$y2-B̎Gg W m8" j"y7go/p0]6`LuKƥ@@uꃏ {EU @a 9~% @ Jap8`+!>'V4'@Zc =j5$FmL$ﺓ[K|u!pلM})*[o,!rbbs/GҏGXəHB4x6EVyy aanxwk`Kz{Ut]) AU.ѻ/-5/[pq5i{;f)\i4^ u4[LM6VVF6kZuAiW~UW9ɋ[roy0Y:tE2ˍz%#,o: Um_)DyRn^UZNe:+#B^݈I֪MpE/ BJlZte8*`hTZ ɑLb5MnZyWv+;ΞT&Ou?a𕽣crgx+wE#7]{lԴ?]S!_^xA5kxI/F'}kNvjXq&hINVh2Uqe,(xC\k6sy T8Iϓ3+,$%++?v4`d>O]SES?uY't2Vj, x*|A 19;1=U!x#1NI.xXmoElŦ9qCWԦQc@[^zw{]'uH| ~!gvH|(H*]vgfgvyfJ\;UXil;]Y 隗?7$3H|w*a:[(+CfuȳehMpvBԯEXȂS]UTv ^ߥu=,{K Dd94 oрw(KgeR#{`Tǝ wvwn^@S2؆KQِS \rtLƘ"dAS)O0`B u?@Kg |Yc'jKE \YHB|k#nkOP ?-xEsC2w|!ii~L"3o @1S~7jy}~ 1\R8ZĠ[,!7\1;7G\t.{qؼ ͯnchr!֗|%B*@}xE0:5X?!AOWBkCkx7uKʢA>j^wC-c_j킻SEiDV02|o%rY !'L9>ɻ [={1N s 2"%r-߮f[x>$p~nm74ƿ;u#)x2#'/internal/jsonench Raw("POST", XyRawp   Raw("POST", ? — as // the ENCODER reports it, not as a second copy of the string. // // It was a literal, and the literal is what drifted: the encoder moved to v2 // and the test went on asserting the old name, so the suite went red over two // spellings of one fac&t rather than over any behaviour. funce(jsonenc.Variant!encoder reports %q", zip.JSONVariant, jsonenc.Variant) } if zip.JSONVariant == "" { t.Fatal("JSONVariant is empty; zip.New logs it at startup") } }  x]ms֙,v8N֓*ֱ5:i PCU73#/s\d'4V$qq_Yd篳Eo.y̚j9L6bz,1vc*,/1Tqq$kjD- jל*ȸP4Xil|L]4!ÏϱtZ͏?1gfW878YD8/(F_/ Ӟ{tJ\TeUs iCPe1D?pZl[j9Sbsؙ9vůV(N`SfOYyEjN)# I%zu e5 Q@ H4O7"bN$9hV]q0'u1҈}V_7]S1NfIc֖&ZfwM|9^iYXR P'H)jwhZk 9#E{f/A Q C)5Ѥˊۈ6M0zYO+($8M'~4+ zZtyw/;<ʛgd鴦D9[bV 7PZ E5.Ugn8;y܁yDa׼''|܈qLg \T2}qkkܠ?`{TnX/e=tn80@fv@vrn!q 6x[wo4a  ̆X`H ~(0p[r[!Hvd\\fgTۛ#️}GDw8 Rv D|o:pmIDw)&5^ĎL#CO*15-]Ye%hh &T{9(Ɔ!n/Z7EYF&i:20 6 IZu>0Wi- prYU?'HkBdA3,L V2 QAr,/kv.xn9cFFs/r4fC_| XLu<1+a'L:K5s؄ȎkuA` L4U Bdq9Mel4d.VFwͩL/5OEZ A0bF a"Z4, qA570p\K\lmF`s 4l:Ѐ=7)pz.Z:EF|-+Tøk!zgXݼ:&RE"{*D0S?Ġ4!E8ߥoF&8at#]+xC3Єz<5rFڱG׈ÓHړt)[WY&ޢu7,yRE1V۾+!-W=|EɥӓUCA7#QCxyG28 r_倰gM8gyvtngU̇|Z0.[g7r*N(4EF'O N4vp"Т}wE[tfXDeqԀ 7(mtpČ'kL?\>:qiA9&? ~qJhIV0܇`q5lFヘDl5+89'.n87' #H3ȗH2}#\5 (@wEnx<t8hxvhpK~#dzrخz7srQ0:eHT\ i $BtXLuЌT@]GREX_"56dD!-tpM4 @QpiΛԌS'p{?; dS(X5!sކ,˰o8>`(Qxe|̠%b1ޛLKH~r-z扎U1c?W1 "'ƚ 1 8`@lypp>x^&IdH``eh[` *njppkWr9o_vy/U!|'Ep4&o}A+ 17)⸾G_OYުaשƸ&d4%$Fe%t Xc=sZI.< 'pR?q9'ݾŀ^- ,5e}sٮi+ n$aӢ',Ud/9v*l8wd7t.JOaf+< " ˌiswnYE $+' JhΐkT J Cu_xt:w@YkW3ע܌t*{/eJNkFf;l۟8`uzA\0юnRwh2|1.mOZO\4O<<5_f0}FƮ:2~(,*q>^4pn]vꚅ2~( x kFγc ,)ɹ_P~e u[% n$AT5Ų(%)t:J2!8n2B:h}'^~Y]вjX;SBU5܉eI/v$R=&u[t("=FQ bS2!D㪽S\($F~lc2nȟ |@%5f%QHM9m ?W0{|d;֪ĹiS4 PAR%|xS.Knx$aj$FMuf@sw#:,^mt@iF.+E]D{JػS"#i7:xԴEf/.G#qa-ӺZ!HhsSd5j6 "H (d̳}94AbE/`Z-{Nsc&;Rnk[$e:zvjy/-q9: ;XNy6@%><.K}›N2NghoBx='nˀ͏)tユj3L[8¶bCb۱oa=V%#T2 6QC@fgRo-rDs7Z>5d0'`j+9 B,1}0 A^#[U]8`J#lOJJ1T"flT,Ey4QMhVF6rϜYn[s?QrPLɥ4IJ5Zz|(0&H GY2[T66n<5LmuQO ؋ohsNTdo_(xjjNondܼ"s_ ^͡ԶaP^ d܀_IZ:nQФKOF(~: G~$2[_?@WO:'@IſݰHTͳH[C$޽E7OF;7?"{dCkvN 8UV1=@wv:E+9{ 0s^U3$ߥ@OXHj2%8W;'f¡u!% ]2ɢOyQN匎 }!=/˽%FvCu,sDr>J9!ND^1XͅfSUd)OI|9t u0Lnpȁc%ZXf8x+1 8pFy9m{kw=fw&%:69gqB9I,sS螺qp>3Nf10u#M`0MC3S-5L{lch6r#>b4d7\ѦMȒc/tZрY턋%xc@&@ϘT %a|UL1mdʹ*r |tO%0/Ax:xV` X5%4 K=`;=`ud*E&B:ذOkfe|qF~7_m}H|?Wi04rnϸ]VF_cVWV9Ķ}U[]v88nxSU۞k͞|8?0%Ďc~_ F0=ˑ`I jgoCݢ@ȑ֑HʽZr_:O7vTJƖ:%Zfk.T!vJtcgvv BeHIoCQF6̂ĽHdg#0x3|L:x%c |_=>lL!kؑm.d8/ޥ txK=aߌic]`{#ǃO f [^$p1: 4ŝSH]6$ QZGNHY&^l6*9v@ XdAR<~ٺV7<)Eٰwb:tR

)޺ij܃Υ5r֣#bqX'.ƻ׺p$uHG?*nK#/lw"4I*./$ fF3Nc2?> ,&SL ;iͤ礳`- 9yݰ'/9t'=ؾ;s̬` GSm$@A6,zB *Yhi𾂘A]Jq1K05 ơlx rtfG4?O-euǨi%>jD,=HgdȞA0YŰgSmmZm*9;nf@,5ntTMm:rNhHYP$KER,|*\3s #);N,%5#jҰ55V|&4̳8zJk-,&9|,RߔB%]qnvB| B%@!7,fs 5O/ŐwW|k#OGPqU VXT>Nnuo蹉x0gGǨ(Γ8t;#>~`D,[ Hm0!Xg>aEȚW ZyfIHYS^i6тMxw+oJRcϘ@&a`̂q`ڑj;0%C^Gru+џBbW*RIN)Qľ_f#9] WƐ]RL=;n"E'f3A Ow:$_of9c8s%pG|:+`.!Kv,G$pFĂim0f#jZi̙|GrݛiڇH!LtG}\K;q J,8ry2"NP sYϐ/UcE!Q*];y!”`gbBHAD6X%YB>8Av˯`N>9gs%|aNA#EJ4-26 Ц1B kLrBk`N" z|WI.cQ~ <A.K US X8?y{턐-'IQEbFu \{0Ġ͎7<'8k f v흓{Y{C..f;9.rŌ'&v.5m(&Ő=[t!7ãrq9&\b@Kij[H[IBzuٴ^/q bTćb8>t{p*^Çň " A@W'޵BeϞƺ<,{*]a%(W 4~^TDxzD dJ6؇Hv ;:P@c?{]u$3s#Ƒ&j|ǔ\?zy &YiKrpsaɩ_]E/fZHP6GХw`%ޏM1jq.HlQۭۗ8c~Ol^U#Ij{&R#ۆ|/&m@7`-Op[.aNCس>0qoMtAOyQmdLgm.v5!gh[.2amjM,kh+hEc|06Ri_( 0=.?_Wם?n+iQ#[>PB4Ἑ-} tfu8F!DLP[eGxzq6X$ ,:zh<Gp|$JZ=)xl*lrJ6~G 7@4Cb*A3_pi_0?^)LTToubrت+wJ3A̞AmpIM'rz۹spXbs3>_>(?(14ф^P'+AOLQR\"nEpmu"&Dz +vv-6EhHt;x=ǭ|jY7Vt`G$z&SLAdǟ3ϔ}w$[7sEI 1 .:~W[(QB5lxi4(GbC[{Ҟu- 7Z;M|3|t+/v8DU1+},q+AYڞ =Imݪ,p^ԍW' =fkK^yQ4 -|ytܮٜ; bA#1݋aU+O9Ա`J ה Am4}4``uFocBխ^T}P,UppVvxG^{).w/-~vlA%}=[nf=nX/){7l~BȢ6rՐmu^@N4*lmAcvvt}fs9WuJ"&UN{TS^7`n_@[=)t8Nk8i7˗|k4 7R5?oچFVT&tes_S=~(?OTlp>?p =`dL&! VR[av"!/N?3;$_zAn/)JP/u] $iJ;c$֓!$=~c1mMN5[S`mK±<R0"=6HA(\ZI=c'H@RIV7 $dEGY󌞂6ԃ`4tJ{׎PZ eB""E) 5&Aʘ%!v]m4x#Sm qQ8m'|ʣC"6٠ XZmPTAkr)"k۱Jhf0̔gkc|Vŷ:ix;Ot#`ۀ^KCn8Eq9fPv`b0WЇU +uv$ W`ßtN5A&g`_:YyaL9Te% A&Ojxz~*)$ !?¬e˩f4B,eF q$Z畂 T yd{l}h4ъ-rq:Q:"".`4wsḰ cR3P.Cb|wwMR/1) I}&YAbIHW"!-v" 1cLBís\XZJo:@h:&Ti4F2f1YzAfEJm#Iq]p8G PB oTs_UcqOuTj(i;aʝ<'ml\L<|%XD蘒] :esݗ3thМ B'36͞1[#{%V GU'pK6-}z ʑh7x]RۊAE g/"jL|^Cf!k$Y]d*Iw31a]}'| jwR9oOeh]%M=5;&Pw4m,fF:E.D7f1fG.Gp0|`zFɰ zEBVI%9J$k!//ǹrd\],==xg:gC~z7it~ǧj"u!*wCfb2ŕUhyfrK^416£2WK?6??VnZas ~! lsx= 8ev(m*mݞJ0Ȥf#jYQvo>w#r ,6#=Xn)%?f23ʟ<‘7SQc禘N_UYU1˴r/dιl)"8"dr"nR4y\.iBKCMHІSH~٦M Ո NYT̤l+pp3g1~uTf!M?!B,=si+kKYD"cnHU6@Y rxX+&b45KƘ6^YX@v!.I]ֵB{-/e‘s%g|1fvЩc%&jPژ=Ͽ t O7Rz v*\iSjkw^vхsqZ!LiBn\Noha/` h}>8=p\qo3i1ANzsgq YW _[yaj'ȋ=~)Jϸ >$ebfzM M4Ɋ(5lExtd]G8:84((͌$|RƈXgEЭ3n*ۣu!i鿍P ߁4uNz(dž%Zv}E3qj;_ܔ Bh {Fд҆tr\=FD4m>oab~C^s:?g0Zv?>FG?8ѸzJgoz#G1!edV<zi q dJJ̓WTt} ] 8p-"M|9(f2WL^Ȫ4uEoy7$o%bn!"@~RH%b3ChC! ?q)r>{RߓQW7o"N0||`O_vWǒruk.\ prS&.sBřAi5{43 ,X n80^e;pۥq#@? 8vq6zPL'okȑl"sBgviW ]ylc͙2"(~&THgQ\LWln P-P. %%,"Q %0̣G>=-L|8<>bIrGzxd_i`T|cy\|nNqs6Ϗ賧}FZ a0}s(hw=n'3XHF1rY򆮥\Jݘ#뮑8T+ڡEuSY0IxW*wqܭ'~R1Xj(F (s#91]ž= {×y\\%dޡ4WT Znm+5\'`Η| /֌9A?i]$NKCM0>p8eDm)߽p?nh MXGϫx{]뎺KKBk1wunw02A+RV QM:9{Zz[/Ҁ=sU,~Ljt>O`hߎ7Jc_ugm[68ootI:7E~Eސ\U8/W2V4!A?B| kUDh,AaނVս -xܵCd/A kH]!@83G13ٻ)ܺiw ꤴs Dh͓}x7WqxWf;Ao#N01Rk7%l(6~=y>U+4&e~]֜/wBm9v joWb(lq;ajӮ &fo! 헖\5kd"B:1[av7b9Cnyf?/{CuP0H(pvl.w 3~yԀ$=z-z#M*0vGTVxTVts>{1\-DŒ]j.o/f:wg;FIvxVn6][_qG@9(ݤE&IgNb`kE"'1ЏKz.E;袛DsKQ ?uei]F_` ˃,AE| 82ynjL(/-hLsg[qMaB ZXrǤ=Yٚ$>GZ vnѩorSVw PT4$S{F'o'սG2+6dxc~?KZETwy5;Miәm!+xB*5g#ն^s(r[ZW(*? wcs}CYYA!cZڡo  HƷI"eƄSiz˓iDbK:[vA!hD 4\kmƀ>Ē_v+KAf@ȏՠ .hh%EHUG c)q9cN>l\o" %@6\Re÷IGhUPf^ {9DznsD{ XP\&k=4rruv:ĥf\ܤWK`2Nyee*B!9G00(Bwbdyac5y͎v1HBlZL8U"qƁqVŸ4c]׫g {^uWٽsΝj>Y]VulqS.Uun'\]VjYuꤝՋq ϪzYhF_Uv_㋦qm)ByZ-RW͚B1HN괙7StU/Žj nu5j֭./&r^~(0y'frϓfM5fZ4In6HSg׋U{VW夻6U\ m]w~/-Y-kh࢝Ϲ]]xbfZ3x烘<2-y_/o$S|>:<=݃]}{=fëzT91`ލAzx\/Zʬ+Gsl\̢Z "ծկ'M./RyL ['B\]v)㫱.ɜ!vV]6Lc8-,geѳdC^iDM!@2^S+׿~⠪v'#t>}W F~Sn؇wݽW?ZO5>_XVU_9=`=kZD -/5jD.z|! '\=Ϥ0d٠w^urV-Fd°Y LS-j\Ģ3*.a7bX5`pXsN{1?i|gn/ݪtkD٘,FYD3M*LoZ )=_lm7+ڿ[BH|պj zn `^kδ[\>O蝭gJw0yYS_5'5Q*jYmvHʤ]ǭ^E3kϽ݃Zw~dxUoIi |dFqjyYϥXE\:i⬹Lgn>_r%3K?Q [v|.c1SF9ogRwoxuPCf3"P "gHZ.dݫ'I=NLngb3"-ngZä=kLk<;ڂk)@P>^]mY84]*bÐa5@;Qn+plYMOQUȱ_ A]4璁EՓgoUrBͲR^7jνkZ/㈳._]vkkm $By8A3NNIf k<SOHJj 9d\Pl5 jWPvfʺ: w~ qfwa!*|_u(ϻN431ij<Dz KX4G¢rgEs,n X0+Y^ WP܈ Y>@yw;^^7z~&ϒhMJ;Ļ]t3;wZa?UJ^b3XHbٲz~(FJ~ULJ^vpʪ {GK|R'My1EW|?Gocr-H#6sn ZWM79ջ ;9c.0YtI݇5@\`6؊XFݛ7T'ݥv  |r>ߔykRvh4A/Tf=޸O>YUbg֋qiLYU:}!2=nIshh\:-//E(j4jIJ{IVqA  $fHb$MT%J8-3oGrͬ>dE$=] g+A-!E' ,jx(}tCKyC Eo!{%u0P8wa[HJOx:W~5C݈b2~M}Y_J< /Ѣ4owO$Ɨuf?j]re5o-ŋ=X9]'|w D-v祗~IeB/ڕ   =eMM&UyM5LM꟎^X0qMȫ sizO#-QGkIkfr~W [CtUp.XvY/NTC}i30FC q?0~ˉ1e;i5>hSzHl WB?^/2N8yiLx$Os6d{:&\!My7=C81 %#d,ly6#1zʰ+/HTؗ0!9 !FN_*.9#p[TE/sx;^RPif{*;*4T,+kcۆNU ׀%ϴxWӪh =4$MWv.1eߕDZ6!Ht>wʠ)9w, Ikߖ? ?5^RJb,QV.zegR/W^TL 6*'`c GOš87L@@o7z<&2AN;,TbqD$ZfbX ǓPER2Ȳ׃F[ovtfRs8/,Lv*=C)UEP@K2\"%VLKvxjU a .Ȏ.4߭P$ "܎WټeT%СT6 )ZQ1No>A A݃C6QQS#-@׾vEUW|+)n萣̿J[Ե/j%_eI/ 4HX5W by%j WfS".rk3bz~gθ \ zf Ru044UO@ /vRd a?3eT5'(-(هf3<\9$CJC/dG.+t~oIx#+sů* B۬^8: SNQOI{"5QMjÈ)$4r0LLn2~YXĕu9䩕V)dMZԧR,ה#zPbMiGЌc4Ь%P8K4di)W' EȺ/+y0B6eu;tNf>w!⍛})A̩zQ_(pԮM4yRT?YV%f+b*LTz4o̐bK ni>UmxYSrSUtҡ@p?䖞>P(N C#>azКu^!sr nS 3#7O8I` E?b@_(ת%c kDjvSW7>zThٴOwGTR>MFe ට8{u3|/W~r)eN2R|@҂+l-i>z>ڥT%ѓ)\(K ԅy+ C`ix !CN O^>R]Iȭ># |2ɗt;%ު7zPsZ1>F+N:PJ[nJa]h|z !KTD|W@ք$6T4GP.h9օ FD$#;;e}b 7X4҆{Y2< a_Ufm$UDϕ$aYjJ"kkK/bZKZ DjZ Tٕ(47F{-vLP*tE6݊/\+7~@<`pR)쩹HMY2y3/[N$䙏x_4U6eF_Qzlė\Ч$UĀ` BΙU)[KWK,60R c`] +$Y4D. Ʈ"A. nSfw kn} !-%?p%n e"y{[£zSrC/22׼o(Ȫ[;b-#}k8]I*M6a1  I2 uJ-TcF"ms_GԒDeis +CP# !f+DD0f=;oܙ19YUf W hK$c;@5Y|5[aY+bu8#$UB:)))Ve0NҀK`+PdzUT DC=hQcаhN 9\~/ $WO^ $([0og9vK ^w g%p_Y`+a8|3ރI#yQ~o?>Ow$C 0rb֤{GcˎQŔĵ{[p 6 !)qE+$.ےM|dۏ?Xʡ mGDU[~iidEhk[ U>B0D2 ?@57¶jnvuzBxq[;~Ȳ\bƱIFd/᏶0$jFn*'792/=Y Yۚz,lg*jDnIpK'{wٛU_蒔ïRX"4ӳx”@s7j]3KPv({d&Ю$e&zBH㱩{s6N(„p@츍_b|.=ڻ+HQyI0c JHG0~TS!UY#^ iJjRb_Hr& Wܥ)G";&o>?|t7Pc U7ƓuJ6fT欜vXܚ>emk+#*#b]hHCMOT}wM,4lQh,B2ިr^ri>(IBMX=6Ho>?vӐܰ\%Mq 6DɄmCI"R%e6>#)&f!PfX Jzhy2ս0ʄr7M.yPtV z^s]GS*pT@rf ȿM6ڍi[z"B̽r*B!H5=s!V>eZ$] ՐGz+n/d=OkaSRNЛpm"Ko^^Tg?ph/W%0]1ߐ꺼N8@;a4>Ĩ_NgnJ-cIO糳m{N[{w8䚙 9ћ(޴\N+`$=,_}T7J!M\BZT.{- IέVdQzҒwF@&ТH A#vDYоGAUii*k6D˩o1߂`)J^9=|s?"D,4 r&q |?+ PUO#|$@^_v3bndnօGO)>FdʃMG׾(j 3̰Ե7!冒YDԎ~WofG9uBi72NC69ɸ"I4u@rʠA‚,J0h 26ЈϾz0/Ж륶 伦%Q O4pk,vPCt2f wCes*ҷ^U5]Awv7l"8}?G!q6Sز*aȘ)1"Qy=2}% 9U vS"!Di TS 6mlJR)%IPutw6G8Vr?n.>~8\ѤfbF/9Wkn1HD&&t(03JCﲯDߝRUؐf@=kAYh~j|ǩ&9 zh2 \[(g|`A1! e7bϯ~@rIK2̋ls䯥D*G|Ԉ V: ˾7Z.g7ђ@`:b^R5mxpDS%P ?dNFp"MP*.{$c6S|l%Xҏz0{Awb\7Rij0hye^OHrb_K! bnzpWqlrFKd| % ![qb G@X@ɁިfsEns^Ve9ޚcY /={t$/zXR@F' I}o}Kbe8j1!!8nʱuϲD <# &J/0?MFn:*ٞm+wI΅ CW1?놤m|wO?h2dYzt3#zVR{$ԁ$&EP$#Vmfy2wKϊ*d!:WՀPd'A "{(F[tvZ rZzXxmz B>C3 p#Kvc7ܒlQʘKElN=,nwge/ob,L TebK*N WA_j,lg2[+tyDA҄hS&!൝P8&g` 9ethKd}%y C` :Ql*ɬc9ϜdCHamB=r>/7sؑ.-"n甞GO`2Nu [ ތ7އajm%ؤ ?[u7R gd2 nxl%YWUsuLv"T7:*f' a> n˞>o0`B Sˤ"2|{4"v͍ݿ~ي[PI4FjO[%1 eMÍ(6`5@$}}އ(I4Џ{f'|u07"AE@,*+%t D@8GYu4B]f`K wY{Fj@Z'ΝZ;zߋ-ܙ^ߵ|j\gs 7Ul3؉ rd }.Ptj "-QX( BlVxޥ?"*[G3dVH Nn9qN.(P4œ:E5f "qq8*Mf@][%]g0y_YlHn`A>tiQ.ޢؤ)FBcy) : AH!`.c%׬;.3_ojዎŀXa0BI adZO'qݻ-.z`tCQ9q࣎~^"Lx㘥;(o2*S)pT noT/N@W\ڑ88; Osi\aw+u(Qj_Ϭ|yнm.1LQuHnؑ qڡ_d"mpdlb2ە%B܄e;W^{R-59z=5jAQ'ׅl~/W)'V+G vuC<=-Ws ^pŕQ! :qC5Zcc&YAo-:uMHӤwΈu3J=Xj_Z$&km"rY+Yh858қ=ġXO%<,`h½RLCU0'Eh;˴O~ A\&_9 /W쳎4MmG >)ǴMV-,o}t _!G{/9$/opEU碁~8ʿt5ٱXyry5Lfmq՞NY]e$#1F%L8ǘ$k3' 'osruȴ1\ }X0 م?So=$UW1 *DɃ 3`ڒJ1|I0ߗҁp46HmI{"i=H]_u$o DI^x@? tTNG?mQ*Xj7qUPG]!pLU@Z$oV,!: KP}kf[rF=9JPpL- Ny?#C_H);5D^ ^L/r$bH˨޿!eU7);2t&͛n{6HPMO" nEPnu>+@xO~"S@:G7>_IP$׉9l0Zh#?vIGWS~ &'qωϏ ᄘlYeGBqy G5IoqMx9A?>Q ܧ[zi\NoзrhU:ڣ?ڕs5:f.^9ɪ?'F=2V`rI$P e\BN?'(g{DSB!d8br2m3yCG9[E:67HV$ԬVhm[]$%ݲ9F.td2Hk-NgYc."9]sMLMhߔ%l8[i.D3">ʾ*6@U,G+ [ *M;!NHR7?|p's_ʟ!B> -k{pr%:{z@`->~>w!~n ɱudLJf֗T&y,U,VEh?H['`eP`oEMWllE sM[A~đϡŇǴjP/o?sn\"d+ƾ}o~wIgnA3yAUo;[|n+շ-PB wɦ }q6S#"#Hqn\zaT W9FzFD8ѡ$K!Ź|91_j"CMA}[K.mz6NdSVŃeG6+M6λ$xh>$ 6mdWfǹVGj Qp2nήֱ @ 'o+;T\VzcG=DS?@_Rqg4ʟɩ&@A9cNDJ20EsmqX<8WbݗEkHLR*ͽ P5^%Ή&SԬE1搾^i.Tɭkm< N~F&väF0`ɕ6(˪.̈M˪tRA`8W߅LŖ]ެƿ0 ž¯Ai)^i+7aJdmi# t=w֣O&X` 4dYy| ';4%4`9>VpzNR{oH7R>hD&qE*fN7`Hu$ -J'<%Chsγ"N0NT`{WFX%*c yO:p6VΒcB.Kʏ%%!1Ųm[چp*Sy~ic>>gWo|_x]w={Vm2Tf',OZƬcݦQMFq$-advzwݍ/zoaɳVyg#/x]1O@ tH@"8e"EH)B睳W^X;k.nwIO_ 5iV73o~ܺ籼98],+0zКT͡H9 V+ζT,LNj8A#!N҆czߘ,ogcɪ>¥LSXTLCX*P+JE2E[t~p};UqM ##$-錉̲&D GgWexs÷1w4bqEy.49(FױmGv6/koz~fi(eqYh>t8-jV4X&V#)kǛw#S1%z xrWrbvA/ko*)]ˮ,HʛqC`HL`m*'̓u33P7_$68s>ie,fxZq//b{Ål/l{ߓl=ͦvAMbQ?Y_?l}2Ѕr>L?QjVҋhj^Y>Ozb}:9- d:< g$)=WI>e$mũ߼<+$,On%dl^N*58fI>I?V%-$dlt\ Y&â%|4HΊl| zq$̣w|G ViV5f]ˤG֟#U:ΒP#U2(zI=.OJVkNZo5䇍kl4Ƶb>Ko%qgz-I*/ewZ ŋ@/j{wvΊo<:[׮unIi>6nխz`o{FuĀ+PN+=]@p7 ~:,lk+[g$ܕ\<.br<j`ݹW(;ŗ_eUOf<{nRyujfh3BkZc1oZܤV u@w48߀Ug$$5$ebV]JDAɣ(bw҉neVMI1xZ3\lĜdF;]B:^r;~1B6#؊A~j;E]fQfN `#}dE[uN?\ד|w ϧ<& PJ> q.wdlveI"t(77XHĦ9˰*&9߻JAJD|w%<…vFE4N6O4|:5^=?YVU%$> &G0sT,FFM7d9HY^I1 .Iq\gD[ʁˬрgj+r۸~&/TͷO?{.>ѭ[7Hsg;A_9YUp@/jwq[?!9Kp8,>i>߲lZe幤 O']=\`״ s[#d$i; !^DHY),G#[+QFV \b^koZok OڭSŒzSÇ|<9 0D%?H]BuleMqFAgj(PDhoa4]8+0CQ9<?_HّXu9x!o4=ftŢ_Rb~fPMt.D5SHDL(S3m,LI w4"&ģ,όOͥadMeԔSO=3z0fE1}]6斲g˱}k8Unzw4MLM/Qb\gh^VR&Η8ܸA(C`&vg/`PO9(ѻ;* 4~?nS@HUhH=?|0F~$7 faEGFvفog 3Ӂl_Ua\,Lo 㣃Hp&2e MuA -ѨUKSqDVFrDIFT-*F.u|%| q寓$Z3ccrKΒː Çe՝t&DPND#Cpe9^VM(PSc-V j[Jv3e,CA3؇q}(za0h%%3eJY+Ar=y`*\ðK7U:R6LNFɊe(pٴj(%^^4Og;zb(?$Pڶo4uN<E$QΥFaF|~ $;/.[޻2VBlq-fOmnFepb}EpkiR5BV x*lGDMyXrv'Q.Ul5%/kЩD(48Z +-9nFη=aש!tsuY9(V- +puՏecFu'\r,rYGe/WDk_m_ SӶޙT` o`B^h3K9(XH,0kux5Z"fS/wּ¤[M skzلUpxf ͆#O{Gޣ߲Pa{ y252=% paRFb[wKtY\;X&Lx}uJ<&o}3o(4, t3|ּA0hN|/[bg{mkIW?"~͉I % o9ҊK`V!.W$H XIxKmX}b`qw)M>8r?P8%Cqӊ IņRRO^#׉ +<ݰ1A06eVI{ <-rFKWU%IeJVL=.%tqʧ n+ Ľ$iE<()^:H9RŦnqŨo9)P5{-=zGL>*Q˴:Cؤb`HKSpWyESV^bBPIʂ@VHkM@KiDda yM {YGxhUڥ`P2([?XOޔ?DJ%կ^K}RҀq!=ku$SbfZ!*QE28A+/& 9V6UAQ\ cHͯ0Y4H9ӨmY ʱ=}zBɹYclqK DB%  jLs{/1LEǨ[j$,z hK匬a8i}MQ'K#ԙ0푪j4:1 [ kKc8>t./*5Ǎ]Ry1&GNq\^ ոK8 fs$@a$esj> lg` ε=, 8pk2zI Fu|7`,vw%l*BDz;\^ mi(W!sssmRQ^QU߂LsD~04 E9e1ALh?5p}f" XLԜQ4++E+ -V"j7v8"#S6 *f)k(1iZL{ٱM{6]롃?WiJH;~[^r@[u&]q @gK&xm} R(}.!?kF|VXLYvZPV/’ٮۅayT+j-Vd&-]_vL6PcoNo˿݄JЌauGSt:?0L5rxX?/sS )}yfFPQN_+cc⡢s9wĬV;:t wwLxFW43h`/)˙k<ɇ dl1}X (=ǎ7UV*YvLjQũ$t$kq2H.]SaK Q;"ړٓ[ZQ(I;,skRkdi@^5O }Qv/?H"[QG0%QH6uHRG%j J؇!ĜT!9.܅/d_ٮU$C\u7?sdvL&֥J=yp fX0{O ݣaPuAPVrq.*-RahӎX'.LV͎GmU_v{ F]$N(%v *v03v˷P.x.^&?ŽRJi缚C]sIāY ywT6TÌ!Ku,8!JN7([(F 0t(:LڽiA|1fTqh?AtYYUvOWD逫6[Sϟu]to*z:ieGsBgGS?f(rElʪ[Zj.LpUܰ}th4 Z _ӪT$VrT9ڗ9O- `1 H5a<2S#Iqںq~2g wZϛ jZ|#ps'*jÕ(J,RQ^* KØ_kwvXMЍ:-+),~iZYٔSSʏ ~Fz {gjkZI}xUjIزp5T6:KKv =A+ b4--JHP$#UlF-f4(":Y~8ܜ}u^ 17H-ןD$P*EMyo*86xJ::4n+. fa 3+yhAr"Ɲk`W) pϹjCSX*OM$o0KpVsj.=%Th'ɼ&^08(πqp2D׊A$}*q:1֭ B[Ƀ>c!3+qS!Cts0c?l%JQ?}aGG‚`;Yuܧe=_-m=G^2*4 (AƂyH mZdVL@LA7>ysO?_@Mc=%̿*n@w5k *Bb3(ռO(G&V}{°5̠x]0KT$٩P׮wG]{rtȾ>E-|p'.ޕ߼1QjC^QRkWT0Q~4VDv2!KqR)!XA %ZܝxB>X}*ae^i _"#U#yXV+,0In ]3ulS$ߚB'X,5}Wj!0/׊?̩hq$j+bX v}mr}UgmI@+[ jr7rvuW̐ Z`e&G&<݂1 .KtL8 @"oy:q1GD#>#g5-I$FWHܪG^Hwԥ.o_ݮ<}GUu4(Ci2+A`czD[P'񵺛4\VCE_"T-俔oKة=CJ|s$fQߑpS]JfyX%v%~8%^VQ"޷]mf# ~c"#t L<:uܸH>Jʚz嵥uNK@";iU'c{_b~0)O?Udؤ>K:N{}A1lnq7n|/Ю[TI[;N|:^Ȯ佴46tu^{#f^1t F'Jwg:22oL=%mL˞4y٭ZT֬F,I|.KZ #zeZ!d^Eg?t(Dw@iXJ1+1g[rr&%n|7-q6,W^lj:o-)ΊE X?nb-a`_+lÎ xRaw(A4^SU T xrV HLO.rlюly%{fkU Db`Њ}}}}%'uUb8>}WOQ1&8˶y;}zOيjZUv/7{hs8,d5Λ~Oǚ硽ìӃ0072yhl6?vXV5norRMǦ*G<-ZUy> c&U.~dN3/ F&+hUW(Cъ^ =x7aYW?zQE_mg:^WaZMV ظgO_~ӧilڄ,|tu>=^ڂY9yq n+[ƯoGC۫)LUB6cx\_DnBV03&̫2g$I&õ9$m|K+SU&\g74Rᰢ#_25]&F_"L\Tme#%jl*&WM|(+oSy8bs JMXkCDˀ6pr^jF92 YfQHo8s |4T3{UKKXYE+ۢ L_(YJ=E^QhJc*“no-惚y"\^ポm2l* P%va+S/e06 (VkIKK0C0"]-UpLiD$\HE$EɆtfNt[rrĨ$pqL[mW Xaa|uқhR;gqZ|w;VNj'/^vl&N/I-fLgX\S\YiFBϴ^^/VJ j!W)L]f Gr^<{(|ұ _gQ nnG QHDz./b2媤OyXX,0ěI],^(M"X?j )gq(N]c*G$A;IR~Rx(@OE|BZ# jwQEs?-c-*DAa/,璬HȖ˽( $l&Κ%GGʺEIoou  EԀ[0kҶ<}`k_s{6JQzMr[|Oα[0Nϑ[>KO+6O^A$pV#Z٫E/?]3_)Ip R 7yL,T\4 x вQ +CЍ= U-5J@EqN":g"GToKJW$< xxHNR~eتdȎNO8*7,;aS/bySNY:J 6ވbAn''㜝oI=X+fG"I6lH?Y up!-{çɠ*)Ga餟`jG!C萪J|>1m{ĝ J5 ;BED2J:q/B)X ߍ>=`_0a;7;B(,\C2v24bj,;]-2|Ӂ_<-^n;).˕Œ׌6Ofa8i&\))ϊ7ϭOȐy6l7·3[O|,HYg$D?)YpV:5abG7^&%^TSim:]Rco>-z\qe ,J+O˪)6I*TPqƖ2[<,<+IΖYMy3[ Ql0Ш9J,+*߁bJ@7Jis5k %Dc Ҋa.d4T<$J᧕/Q4i= |ώWg<䬓tA=9dkIA`c|]$*$ҏLJ:eD>QIWu!?ÙP|̟:ʗ jW\lȓekfEqRqwP-!R&X8Y. : >,"i#SpjFɳ'?|@XNN_bNF žC*+껎} a}K/zoUʞoy/BTP,V+[AnVSo4۵er ;?~ZSbV|--3 i5hB6N_jm= hRV<'.|CEkm/Wh ^hTT*=TD kL*U$pp/䝁sÎ- 3G˛EEt=Cocșmn sz8鸇no. sܦOrVP}sLc@OMn a{L'iS2Wu L*V"QN^50Rp$Ȟ )ĩԀzd&eɛ'ߜ<>2%R2]H?;3a-7Et8f P(-R v\ e(MN4.j&L  rU}d ,*2L&NV禆ZbQU-SXWΤ[hz]P"$V>{&umsņPxE&b~6bX_=z \x lqZJPbAVnMILE䖖Vxxz0P kǃ[O)۟8RY2Уq6HpzA8z8 o:$-%6ӜVҐMWm*%"w͒Oٝot)xUCb(bQ1sC\b7@Rhʤ Y.p?fȡϚS+_ټAUqK C$ S*/ٗze(H  8H LrmF1u8" ӉwÊ>b$NiE@YW_l8Hz3@(> Av> wdClLQ`wHPRٛzGoaJTQׁ^p4#*iy9kЛ$/b,&0EH*WyF~ZgwCyFlX)-YeT]'i0Wipl^rǯ!D+iE!%TɗTug U0q,(]H ;ccׂ2ЦR+Ͱ?Fh36u>ZH^F~yc RwWSAPNpϞBY!5&),ⰶQqSyPq ˰G.x 5yi{W:õV̟vQL ՋIY_$]b]:PuouhClAO?d:)YH徻V6q*W^XJE_X)j2%ȯU3$ܺJbW)׼x#?RBu|{ ]&ȆN7ۑMd띵S,܍OHtBh D+~ShJʖq~2Z|mqk@ѣ@E gGOʪϬB5PT{;Uh<7(dvwm@b$Yk%ѿeq߼%ă;ܤ@_kqD~dWFh?"paXl?4TL$>A 9ᓟR+Bѵ6q~ocbiCb/'J-Pg֯KQih Xp/)'2($ юH.^|48G lqC.2qx,?8U8d,oG#-d)>KYU`BңU_*Kh%~&ĹzZtNq~{O.h=l!8ҭa%%Mk3{}X^itA>, n giOdKd}ȕ'?3;6c]Fato۹fQ{L ոg$DbL-KW?M8ݫQ\q0v .t 4;ǦO|>︸۱bGé dhI;\5=ǝvJc)^gJUyW''ɣ#6Uz|\Lp79&yU-6v2ÜN-yը5c׫NkoZla>DJ> f*  ]f{hdyom&U$M'JPa7I^}/R-PhM|9{J0 6O86Ui9ln}s[[cYc/a 8E2.nۃ՚V h-M)LB*R yNMMr.vp;b\}+8;L&Z-.Z< ߛG]N Lv1yM$n2?Zlf]UvIk㗪x=хߏ8  w;`T|ZOa IL I5 J "b}BRd`m(pW>R !9 Bdp1qHM_IV i ]QOjY/`G8`nYX+N-A땸%Gco;Beb/v5=jǖGk+[ETGX'Xu-W bH*blKZ`#5ρh#ci:;PYE3GЩ;ֻgU|mὋ  Lg֥!f`-)!*`/6+{(='BH DhӱJba(QjG˖6X\ͽ`b =L4|zi/KYGWpyam]jGYr︦|{sƱ"g*>W*HЪ{ˇa`iw }tԝ#Da°>z] SSͤk8x߮C sD߫)@%@j@6Nɯ;_h bXyo7z5gΏTvZt/\7xpackage that REGISTERED the op — where the registration is // written, which is the source its prose was read from, not wherCever the // handler happens to be declared. Origin is the app that //3 this op, which is what //B;Wx}Ƶ癧@9l5ьٕ5q\j*j?l}${~OwJֺ{H%qKGEUv}7?]yy*jߗ{tkvtLz;OeExKVMUW5./7:9|2|FqNoʬI'Ǐ'?IvwWg [tyU }ft-O:i]N/KYjO͵]_$M\d咿]y"YV$+ߔds!t S_TVUEnUpdU5ɷWĽs4[GIexUrzn'=xx]?j]^&K6iEVI-[~ >[tBUU꭛eZKƸ'Sq."m/j2eU5sZ-/kaۆ)kZz/ޖ}lNKN ]M&O:&4,۔/X(ڃeGܖz0[g GOu7仛WIAJ֩4b&:jwY>54ʇd-ir\63"4͒LQΏyZ%&{zvJ{ S6qhZX9z%-oח/O^=OrGthOD'$oNˑIp&̄dal16/ U.dNG_]a>arxDkp_[ݕYT[L*}޽x'ސ;Xj,b>歵Œ{M&nµ 6k[bI1.\Ɉ搿s #,QW(l5Mdj6:_ʢsL=ˢs:/dK.UpirM;Ʀ$>kVH_(Nn[}Yu% ⳼n~E2Ok[h+hlY!=w}>I\Uͳw.*$|׉lwR7#HWb*حK.z)H/|եH;b L}U'$iŗ,T/}$?pDl^iVGXe) ʶEH"Nȏ4'yA 6Ԇ iE:F1%ߋ]X /jt$5 O ߔo5AO[O[btf6M7uKy"|* Z쵐4[LdkgftuQ6` [ $:lj.IR r],v5=a~Eu+VW6*j'(;fі,@r%">|wUJᔃ(<6]Dg4.}$QvC`xe32jTjpƢў_p QyNjƿ?A/^>[gj楠'FMKģc۷?̉g']ld]$_Wі saj)y>fƂJ4!t ze}E{$Zo6KYZ2 4BYekȷbwH{N.pw$P;jMQK"DuqI{0 zHcXW ;z5E3 ,f[ B[, "zс;x7MNe5nQdDL%XwGdXuB$晈ʼUsGl#˃lˣbd!.eMU|7¬1Euwҫ7-qѭwiOvofGkC029W൱$.ۉ}vD`K)\DBt'5%y Ǣ vpA[D`ܼgsu~B}[눟sBN6 Bߺ]KK F#10Tl7Zy*Yhf(DV HƊ*'qDhw ϒն\{[T} \QB4L2es7Kr8Zp: xqME TUiM2B.>(m9|&VK`:J~֑\ /\W`̛z+Iuzw `eR%#q]΂8"dK$Uk,A'#eڴD ~A RX,%<@cr' 7 j0mȂ0[&,]{x+Q~$Z=W@}O'h*'" hFd)ߘL&2]Z rAIԐKa (k -F=hG/xd05h쐈XSzuK *S%q¯.tA2iwMs'wbޖC&gGʄxb3?m-1Gxz }=Ǎf"V5;[:E<^VuPF@h2뎙^>D*]~\&eVJ:N} /fA;XIw^-v=g##E BP}OXP[HGqm$I-jXՌ0+@:Z @/}>_GoW^(7YC۵M/IYREz]G?/*p 9P!Ji*D7$ax5RViвNjjSWȲmi?w4b$,PA"\fHЋTc2v"e -7s;otv!R*Wѐ!'+: ?tM9 ~s|Oƅ+Yzx 4M w[l/ UOO{~^``f!K0K3<%irx&PS3hC'{Gxhyyɣi,_ABPB'GZRk1aw5U1 @3S/.S[-` 4ܪr/; 3kHHƨ_&O߈`u˧c9 Օ#l7_1+>ƺthΒQ/uF?GޡgD)-qkbלUʇłg$0J:}Sy]6.U5,Dž)^[ 7"KHk$DD6't͉:oQej) a2mVP%-B`c%=0BZ`V"ɗ-1{cɱ틈u[v8rw:|.X@`r<`V/F5L[e&ay%-*I ZL%\retJ.YyC !4')]({6wij toYZ_OcWKb4Ȱ1Ӆ.Rj Ȋ"5BoNg5:_ׁ'rqAL 0N'y R5g)y f$g(IVgada@ W/R*nH $`_2EA"!岁G pwS2t=E;CIg̞Uf&OĠ&_hħ`B S̽dIXOfé"4Onesme\‰DLIbz+$ NZY {bvlC#,mNHF`L(, eʆ0aAƵ5rJY~FH&+ae(Tڙ[\c2 r֚4Z4p_O_WUqL&T!C#G3ÔaK{4Iy~{P%#6bVeH1_̏p)~!gݦ><'4M%T7 oFOcE#x~n0NJ,h@Ӹ'ua^ZIFqlV{f]*jk_yƆ62zAlʛإl1$U~쒚=yi!Bej\ՓIpcڻ?fM_LvՉ2bqMQLx#/aj 'g.%s4M*u/\1|9+^)O?'z Dm"Ebz۔ޕa4.z 8d^J7<뎧d]G)qD wدKFl70}JXLP'!D^~+ kW,#KM rĄJm FP%eK*M`&dO_p'bM}.!(sJ(0mr33Ji(Q'-^ʕVj>-\_<㣶gr}a[i*J PL"5݁:;YQ6I+iir' uN3Ze{ G|(Xg*uURU.9W޵}CaֳA~Oz3SbK/HR+uBERL rJV)ߴ/'+SxD2XÎZI~,8 p"/aXNகFttu"/ԮjX4huzС$mynw;if&!&@ Vx0%"-F7!~N7hB)aS4<׌aN^$d;#IQxA1Պ'ea\-u#b+A\X!&֩(FFLwN*VQgrMkIO0_LH!KI/DIjcY/Vzj)jűdzfYPv,^I[ :h )Wj:1dϼg(-Alcp"@]\E'׍.xMd{]V .1/-qZk\2tUL_scb6D`%_#A2W5VJBI&{6[ M>_Cn8F껍kSB\ NrnR@Է1Ux7 [v0l4KIP˶%' Ĩ0;ʜ#FaՁRYEh~%ӊKT+rjՀ#:<eQCOey$OU\^ M=_in{/ +X@d/z= ן|}\Q#ʒC#<>:82hp08=3BH q $w`bIx[ŏZW|[o~t8P#*O*ç}:n!=>-JS2ȕu ݔ8 EO:?=;u&vH~*‚4%!K PJNy"AZd5JhuLh`;dPa 9WpOD20@/hCVP8l q;$c!wy.yIlhK"jJG(9@i6*j3tGb?{9>ߍYP2\H5fЬu,$DH>OQFS(яkiPJ´Y(?$S tAf[S>ߦc'9tHItʹSB9S*\oT 8rO ⲅ'$#FK˛է0SF#)2ЪB"7u LrQNJ^U$ؒw[$8Z*=xYsךCYLg !޲{71x<4xpX%5>ة0cf)(훠BCN.w!+,u2e _8-NBSjWɗ@L=v x}qLZf o5TrenҚ|0i"'q/,-7-I ]ߡH J/_\WܚH9vrv)4;#xuEf8pYbC y/S&4Fm^crEK,)ŗ 뼣 DϋadslzXo1.f}M03+M5&^Oy(+~)A8%G)0\đgI$#񠂔/}!Jcw1ط(RӞgM02\.[q+$^U~W'%yWI5U~ CL}!8cbeLCыm7jP R{h"s̲]8Sؗ4!OXp@x8k _mV4$2 B<:jB<<D$*7q#4ԗq|\ dGq(nMLJVzAh)jr.5ZE<^# 'HGF9)΂sv /OI804{ǹ x" 0R:L2vD:3z>ao UNe6tglQ9 NEZN#gb|QX{2\iNOEZ{i>rbĹ.VR&&ѓ1RSq-+iLg'B#˯6mnv#I%Y[T..Z#}wOFs0ZfBPV#^Ȏ}Ȱ!D cs5PEVbh:g<,$}aO h٬,b^jXwn5C}鋋!kVƏU۫Xi+vBဗ*vv;MkWgȷ.mlmqx+G{pػbPMgn Vw)B[v}hy'a=^L\/:Boɿo?&>+8h[?מ↼CxR \osiAR# BK==xNF`Ahٮ fOPwx cwSLXCmpWoﰰznW-_Kߨ,`T UφڣI Dun1Ot >ב2͸SE2c<#\T"_P.MvWߟ|wy$ѺVs"ggt~[3_w ƭGZae06HpTʖ66|Z99K.G Jmykޜ& ,BfѤ.ne yRbsK߭dU`DN ,Aep( k ld@_ D_sk?_E#e-WV@zvIIl`ϒ'. ޸K,Hgsr7΀|AhO:m,:U.C$[(7mI+oC:ivƠ(VHDn%3 13Z^_}[ @'_HA܎EkQ/D-LCϾRv҂an :uhe#7;?=bb.%xyr!#ˢ>J7IM!Aj[< R,hOzqGMlW7p[Y&l傝&tHO"0*Dh5}4\_WK7u|ݟ1n 7Dū;z8(bͼm*?|vBƀGu_BqfS!c ZCes86qTeMۉC\;5K64VgPUF? >/5߸]jK{)Hm`z||T4wlO㑀#]˸pF X65CKEgsl<9`c3*#{hճ+ f^{p ]I#bpsct#if.PZ\ I ?QrP|$юRsnKEʨJ{l6e-#%A n4#癩/ĝ*oriV\8=<+D*}ALY}4 VHS'>9zQaQ8d/Sk8UbxXI|YJl/9B. sO3?aBƭ:>ѻ+}˖|^,UbćEUH ( EBܰǥIиW3㈶90w?+"4>p+ w=P.(3dTcпfP0 CPKbN#$w#逕/G0Ile1)ɳJ VnڔYZRşA9wlC8nsҬCXrЄ{m @+}F$~ U0h!ꔾsH}udU < rHT&Xsx[q-1__34qӻ@#.`OrOLYja}$0.o:Q -THt;Mi6 F+RB^ b[Aރ>f=`ね32fC[o.r4T"gRL?ea>X⑽H~5уH|&%X'z%@QYqtu)jB_"9 RX.k O\16-ѣ]zcW8=a24>5py$+cH&@Bzj!Wgj#OVp=x~Z%T8G|#>?oY 0M_F<պG͚)ѧ\0ݩ5 vNԣ jWk6ٽg2+k'ه友yDWr튮vȹS1#>Έ vB~ѪOrWk=QT" {kHB~8080 cKdpiDatw"Tŀ3Pc \| 9%C̐'Źut72VڈDĦ]ppO?x3अtw8t^@ TxZ.f9Hj0 C2$7)3{Ք#= '*,=ɡC:=z?/cع!׌uԬ=NXsh=HBNb˛ wdjFknvK4NLP,)ֵH$Q}J7ZQwmev+ ȵ.{v{iО%вʱU/h^;̝>pbK Kk/n:7)nCHAj I$TUJ-VZ|0HM{Oi\ '"ɕ-ᜃ3lM\o%VfIPQp煢[eUB_VlȦKHR$k,cG9׫%ް űH4S jm=qupEUS%]]`U7ōy{kݴW{J׽L#ø`8$I GkKL>ʟoM!8+ʯg(޷-w#Ev_f *͢ϡĄ\k *yKe[2t0l:Eu$trL0d%Lr{s3 +*CΑpk_P=9hʖLRU>EM7ێkgd#davvf+&^}=+obbJtxZRF>>~t2u f$х*&-ά2Kg.G:NF.h~n*$} ƖX8|z<:3th?),MLF,JpFbmo{k.|@[6\ au&>UDn5B_gTDF{tmڪE&I`b#.Vz` Ͳl0& DCLW,q,qL5&,F{ o2Q͜IkDIAτ20/JGܢ9]k.|4vxc,M"o ̳*kg6YXPt|rt~ b݉dq m?_;h(6"SyۆX5ѥ8 ѲR0cfkmq6/K]zŃ?D" Y?}vx3HU&E( RE :+_ q_; mC 9FՎw}^`>fj\ )+Tp(Ohn71{ (toLxvuFZƒ)rb mT|1dM\ʹJ@?=Gw)5Q*F.;ꑓ\NS$Yi٩slxmHD >t,c,L ,swMIm"-;#93!wI+} A9tr+BR_T3Pɩ̽@JU Lpn&\Irr)wyTL6S61(K)QDAr<ǑCq]r­*g)sVʐ<(QWwE\s(RMC.-|mQj=VR }^GaYf`ޥmrJ~mʴ.N2%Eou5ᑰbA¼^[DoL7LW"k68yYT,5P]7,0I7 ܑH/軗 k$PEF,g7.6fQ޶&i,L<nVep&n4t~qjp[08@;u<2T+Xmg~#x2CDH Nƙ ՟UƲK}2xH[Lv)0W:~ ϒjR*6@ DQVtL$6&82)ڗ*Fظ"SMtW@\ᚯ!)i-~'ƯY[,̎2`gG'8 ڔEGf0 8m D^/O fSΨ~A,Zq6wj}:?&"oTӺf"]=7KBXBb=)_w{vu8=( &y2|oгG新9n`FQtĺΛS:g) 8ѮuwCQ7Zrs=K-cHa'Է\hcރyo_^1 Go20ӊENAJlեX쓓R ,d)g&ݸ M.@*3@ ݺd]YI/(P9?Tw7Q X_7Z Oww X9L'NUa27| B;{{c)2.+m^ z{_^^X8NcNn1pxRr)VF@>۷WC"VjRYyU^;:}溦$lmVs&xr/RC77>Gk $Qq-&ksFe;O nԀF+t5. rIR]@Nl1Prٱ1ȜGRPڵE+Yu{CEwsOF/`IZ"mG>g2Tr4XrX[ 2`&}c]>r}}F71,爠wY^2mYEOfnH"LAdQ7%c0˳Q=GfA'XRB s:p(냸a+BbmgbUI3A?1GiK7fWzOXD*86hFtEojTyemG&~X Z[_of& IneDV$))$6/Sgr IlĬqؾu)Ig'fu&l$ #\.2zC:w[僁8Q:n"7N&MYf%(*9lj-0ϒcX(>ꎒ( wѩm`Pwm9#F֏Di2k :9y7y "iw__ .FQi IeUP"k<=)Z³)mnb8"( ݆lإ2KcshcTӥ$ Jͮ=Lҩ'}|[n֨oɝ.uޅIC[7e! % PIBoO =꺥/F~|^=y,!QHxy8 Uct!!_Ă=O5b7&sYpkX&~i;s?7]}ԐG&R1Ki'>j*)G Spk{~7'k;K' xSx}TQO@ ~N~w(ҔM` BHFr]}I[@tQ#]|ϟ3{ƱjZc=$q$ = S*=vF-8mS fϻ۬0̈́Lo&t#QO&pxp~|a|,6f%9B#u)+ H(jړ v---)9)+ѲGY証 >kDKhg)́Jc,yFB8TP貸t@On$f#x# 292RQг!ܔDk$UzQž2;? }˾P_gtLF)}Nl<M2tTC 9wD SЪ #H/*{.抡E:r#)L';\'wov6w{ p[/ a) t]̓LN . ;~L'HČ ~\z`PyD`)ﮤ[G^uEI/n@9&l ewV^;t 0Dl7EРSfHa SB\svEv8^Ô8Oױ)-_'Ń%u:($ d:xY > // A client that asks for a revision this door speaks is answered in it; one that // asks for anything else is answered in the newest. The official TypeScript and // Python clients both refuse an initialize answered in a revision they did not // ask forE and do not know. func TestInitializeAnswersTheRevisionTheClientAskedq&for asked, want := range map[string]string{ "2025-11-25": "2025-11-25", "2025-06-18": "2025-06-18", "2026-07-28": "2026-0\7-28", "2024-11-05": mcpProtocolVersion, "": mcpProtocolVersion, } { params`(map[string]any{"protocolVersion": asked}w (err) }:"initialize", Kind: zapmcp.Request, ID: "1", Params: params}) var got struct { ProtocolVersion string `json:"protocolVersion"f.Result, &got);}asked %q: %v", asked, err) } if got.ProtocolVersion != want { t.Errorf("asked %q: answered %q, want %q", asked, got.ProtocolVersion, want) } } } P*xXr8=K_* adkN3&+T!S # KuhIfkNt~̮LE=2NAUک[_*/lﳭ4}ЊE`:u: ^df74{60 GޞxpzPi1KϪdRH?G\R]*DˆjyM^dQW'UVyUaQ9-VٵrXaX15rl%2iL,Ltj)WBZqEuu( JrwdY*# :KS|* dN4E?wvTk`i.˩óTWZڌlz uYVȉUщԭ\\c2T=??/ $Y=r6lଘf,S6=;'f3LxmuG+M WȲ᪪{AvIk}, ,Ε,|tT37U]co [L|=:S˰EN f ZV.'y6:@Ɯ;E< 9fTFX>SuZܦhl]GAl9a tׅVp]U8mYYp :ܿ?W aӭju\&sp8mt&H'݊@ ; Y_z%AefbZ%NppPL ~-f|]f5%K4f?%"ʕLQ1IϢltB׍;j!1gBfgD3`f3|+tpZ o6fA.#QW"1[+y{['woeh %{d7ti1ך҅9;63"W4 i6PW-!TȄn;@܊ӫeQ1Qev؉gȦ3ѕxF+\V> Jx;P>eMaWDy*n|XXJ3'k=b =ClFl,rqwrz:{|< 2!^ZQI'^:جi z">E|~tG|Ѩ/rOE0>(JSW>5m,P0Q 2G,9.U:YƑ&$qͥYꝺE3^6.,6Vɰh+FZ$1 J$ >oXT3W%ŊDLl@mee8W&Cj:x&..=;#e$UuҫEh>Iˉ, mc!eƌG~m@qEМFQo"{D8x3#G5u$lMqJ%)DRr" BzyGRS4rT2tGo@yҽQ lXT&c?JV0- D7)xp^r^j$P0EGYXeU7}HKMٜ3AЇjEjifص }$7SLoȎ#Pwq_R_߬0X Ws| 8j|t'!dU+: y~.G8K@=WqQ0);Ng8 -ޏon7n&P8QYKPl$(jnX-"QAen^iapu>xq{!wd2qTI02YzL*Ku'_ eJ^2?̌bJ1+.K{EɰPA\]^ud*N(sȮжép6;{*?.p>xf|u\{Jrpl%u﬘j7TWJq AgV$]-<EԥtaB'Ɔ淇Qupe)F`\էH/pf'lKAz0dflթ&#/p0uH|G|nS/B<,ntҵcs&n$`pKevnWq 3/)fgnpH쩞KiEa "# הiԸe,˺AJ*R$;u'{*@}Pj k &IJ1d e2$sU*BfTctT |>nu:t3~50vr="G"4^M3*.cUD8H6qbzT畏tT1<±o29Y-h9tA!u]lG[+[=.P`7*ne[Ք}K9~xuM-PӂIOYU}ʅ1](a@W3HaJ_K~ v9Z~ *DQet{2h 7<$qKMijRFCMsHujڞeJ9B/+Yu6kϦ ahw+&Efx@wMt=?^ Kgx&FGVmH3aډjU՗S:C]5N(ej<\D.]W2[9dA J+We)Tv*yE3F G#x8Mo,҇vzX˟?>83/y5oxc/3Nyܝ<@r v,>^IcĦT]Z\!T&ܸ,%?4֝*xXr>OFlמVʒiレ @VUy]S]8KYW~ w&YoaR]vN2.K_W"zp :>iG<) lޘ#舮aOaN*}= "VU' m4a/ٺDSf NTTf ReIӕ0S2rJ cACr0N?EkgyYQBLϕ)6eyܒ63D™Պ`QCa?1YXr*00+DZ ,U+K A`kUJ7.J]\JĽ!BMA " UUfx9#Ld?(%S!`'$GXr1?5$>=zmgU\_9A]~"ðU!p8Os =]KsšgU= 34p w}`Mi* i%o#a JȮrt!ὤgok+^}ڣOߧ@meQOB$v81X&ʗN6\1nQ9OhLK-@. )(:E6b %3^1Vtbpb{؋,?YAb/wKDzӟ*.U`1*F ){aM= (u+{&UkqbdMt1[©gV@kֆڪύ!C+& pD--gy4`]رt4(ZqH" Ӎ-lq_j𵻥Aa /WFqa[n eMۧ{qʈnE73niWplSx M3z>n+i NO~f@:9^U{2j 5}EzIbE۟Ç]ϰeÑف-,d;¶ƌ-X|=lf,߱!w}3mgk ǹs9֮s,M{a:L魦D!!bd5fq%kyd|MWH*[V`|k|;ȭCyCLz<=+ FvLT3!? zf"54R )`qn= m#z5 MlnZT Nz'I@e7alqY$!maF`NTm)е&_-+SO}-)X(GV:rk.%y Q8YF K3|hwuP'ZL1'>ki"̖Lgc M)=>#+S28E) 8Gc^yXNǷ?4;08}dl鄚^ֆr ,(T08+NZhT~ZW۽HQ:w[dfE/۸A7cLՉOe}z_x St-%CY d9e1V r{0Ӄ+\m`$7(R&0t>0MkF[)Xro>p =,݃xg03L,ع85ܰ{+-xZr۶LZ*t('i;IƆHHbM ZqS!},;997gcX~vJroy5J' Ju{WU:ޯVx0[\w¹9ey:C/XzYtzISp0˧ʈhE=MRMVNp4퉓/=+Lp8$b_JeBW"B YJzU Ĵ΋L|,3HYV zEZ1$kNt_ZRYi^4zyYje"+iFt!uaܺʬ.k;!ut.HBROuWd12 +RGKIRH#Q 2T ^X&U~Gj- cW$!S*3@ɺ(ӜDo!P(ȫt^VDDZFp7]MHyA.HhS'> 5c6ʚ>!1LkcT鞓wPW$d&PЄޛ]m <smtMxTv2'ka mTׄ| 49yr|`E* HsI%U2 xgp 󕼒Z:p8TVk1'R%9.eڟl+&Y? $i,N ɿp>bz%3" g`ٍz$f~hvDtJ0"(S65yr %,+˪vt7DG^S>ZǴ}K? ZHH$'"eMUE*S8S=+wZ!DmњOЩeR{}{[ۼ;{r)2 e6#|Gbx/Sc1F L:HKs&⮍>t6d$Wh!Gjb‡5G3˦ۯ*ġ偪g%͹ Dz(>R+J耗`gYV (V؉{!%'caM*߃d=JB8[*&tHLJ{qr_a @z$?[C8*M XlBI mpƢXɑǣѨs9 \S8"1.=gwíKJG/x"b_A IhAڧG勣(BL"}T4 "#%6_G?MX,a#2qKKLx7 2ӎ9VjK1tAȠ\4D ^$~*T0c,g%XjJRuO s{ۀMmT@oVyu㽱8xvO)7d7z#hÒ\amѣ{BX]ա>`}{>a ^eZ]ɂ]RaNEiן&(Ƕ`4Џ./)ZIGK|2j ([+Zco+ Vn #*ãm ,aS˂ۘ*y1֘/, 1T7/xU]2{fSMDSޜ4xJnP&5זFYdF Q\㠙KHD"|jc)ui~r-rݾ!lIJNgw$z6(zs 07M_ yoyn_WFrowSbM3 1OBog(%6ӰJ+Kq߹3IX?%HwMaY@]*HraHPKNdv̋ڠ97 :D^2]Q<~xf GEqI*QWsJ<읷S/qTm%9yƼ*e q+Yv72Uwu]6+"3i]c |: LDK~ng[r_A?b #W|=!ftAFe= (YMR*,Y4y0-4}:r )kPsbd\ɯ) hF.m4izlX9[*pۮ~l?plˊB+G'{L잠χWj4کwz+B#l5[1)CQHXIx'娊.m _KQi$FL(p S_P$ܓB[E044sBE3;0y5h}u i*/z+e  |m6]"F#1?k^ַޕ]b KHWTn7݉D|׎( mX L|t,\q*s%RIkW$[=hFGí#9,7y#*tXsfZ8ANe`#5Zp-js-o}+yr+J?dzר9ݓ+L[i=% _G% y|O3ՕXy4xɓ⛾S iH|)!-.@oi4\%5@\u-`E͍S*x/(n.Ë႐+<9sʬ,W임O39;Jo:+/gP/ DN*y-)⪰#-OC!!q@`"/:hW.0:Dz '<¾(Ï*v/^ sN!=qp}N/ ƺOk{HAO3Ms >:*,a2Dp; \1 Mۚoa{q br#>vvxϠPc{$mvuSs PY77c YB<p'[̊j؎}ϲ'nC|q5M/}mzQ j~bw3ϕAgu!V8.4E{: yp5o/sSdK@hwdA.`!ltqEf~7砡wkyRuUle,'ȷKwmQR΃u{ ްC o*yxYrF}*9M}aVe;ƶʔwVq#`H"10f vT__{$DRujbs9};3TAM5}ʫ3yejGqo/JMo.§.St5%XWOއo:cYsf>PRj8Q͜6?aUg0"{=4MkQIPԤ>^&޳PDАgQTM^,z߻yݸZ>UQs?*;{!T/=cqSOT ^hKܒo=#7댧~թMIf1MlBT,*#lzXwzT`;2+tMvfdA9Чc2(?_q:sE+]>9>j;TMieM <)y55Βi\SiCc3f u}3SU5$ת>6M25I}4:0L^ErO??*v"qVzT*s싰э7CنMlP|F!Y<P^l}3 ]צ<2ttQ%lʼ/p|R+#g|efM|I}d'Γ, wp֩tFgD.7Cߧ2=6g̢òݏ''1XI{z NC=CSUH`ϕl.; D^^.Gҽ=mu^2#h=NE(Ϣ7䭛|Fk{OD)m K⹪N}ֿSIIMw]['zG=qK+IMZ;G D!T_SsVhUT4o0 ̵%)֪,$Oꤷ'R*k<*ЍJ9@Xx:o6`Za hjgGE@c:}m(S_߱ڐAa*6yݙahP CѢ643Bj48eh=E{;^ 2˵ݹ']#^+ū7|MAbӉH~j36)plg%U)"n&dj5`\rAQ0Lܬ6t4 VRgܾp5kT`Yn0m/2PH -k(ޡXؚ_m #,Ö%!Ty6vE/Wp}~u3g̕!ZjY'hf=ӟX~Sk&(Uhb LY,KP; GdҔ9bj)eDZz^dX`G, BJ S*01P\Ū<036KsLTj8Jgen6[C͔8f V@E-|#C9乎b*ynxhR·5~#>d$!:,zp65;/eifPu/\ZS5H5!qKRbI43#çًBV&w#dcI\Zg+mCf~(EZOOs/}фp ' 5ʈ߇YY8'T;/\2dxlxi9t4[>ټִrݵLVӖvT}{^L6N|7ӵON3zŀ9WJy59*xm"-Fm#ּH q {%#:ANcDA/WMQΑ~W+Ge W@]C1~g&n{y@^ߩ:!5'N%(fVbnaPчqNvf%W, Pn "Ӆru_o.WqOn!| lRq_@~s* =ehم}[ +*s:1,/,oM8ܡ9eEr[.&>;ma/{]5GtGɖX;+Z??zq XE`?}b?$ Ęg CW`3y[;SE쭽=&]!bVR22VPJdm豹#_I*oB [^b$ө]FZٕaMj=X훣{g/%+0ҧyP)& ԠaUX`g\94|78Y;khha oV'LAѵ~fF4=Bgl B=X'mo||q~&[}`ξ \LMBs猂+uxZRHOQ;1"n텓\B&Jggk2 KmAV+j0TC3nɲ1ًV_SDYt״tiaJu;AlJ<<6InjM΅w+g{RU"&4|JP|<רƅ Nj2nci(Me&:m5hU4 i纴VQY)^0PQ :'\jI,*ɘ*C5j@7ý#u~_ʍzJ2<ӑ.I4JV3\-gfClzlJWv"|{Qͅ]!&QdۅػQuDZ{V_4*"-~;>\1\Y)Y^Q'7ldS_4eO:@~2CpBy F߼^X/i3(eK˵|+WIn@' 3q w\ $^X/bf_`VG~g)Qވ+NJ1~,pFjh'{y>  ᰎ$f{\},P\\HPA_tMX{NÈUTEٸdrb6Dۀ${n]/_89Տ5wN3ݍ%l'`fLg.OEz7{2峢wq}%F=/([~A/v@:ױbM8 'a@74S.WeV0[`!X*\ 뵗@%p I"S[qEB_d&?b{Z(R'[%^~eBr$+ɾ fE".Ԏ8J gk*R}`>>ZfH*a{uz fQ<" kjNx;F9<ū5W5ۘALZs!rJ.E1"ӕtzc56fY,D4O+

Lؿ)8g2ŧq)T?!0<i^|T~nQ~-?OKr pqm$[QE{Oߨ3Ws7G",.GVr lX6auEٽ:v;,R0 ]iКΘZ]^T =w;Qvz_.:٦֐!n~"㥌^70ש|%UjO!61GmJe WvSJU'zŌ#\^{M)¹iOG0i G'WN$U5))>~t^grP'R ־ B J=Wb|T\B]4j6n-|SSW}5@*kA a;gdu4ٚWZq/9C;ais9LCh$CʘA$k\W-1mHO.29DR&F3D Zmm=[T|GԅF&79=tQCso?*KǕ-Y ٴJ˰TH-}܎ʒDێW]na&f/yy۬Ympa^ï3#7[s4:N+=ĖVl^x1f`+oxmTn6={bⓔj p;5AE5XKBRV~a3䥋0$g̼y3FjO,[ E`ۀ΃B-( ApNI[J'WN6<"4'8?X1KΚAd]Cyp*b{qsޘ*k:o1BiTU?MA~3d؎9yRRr׷?]zz4Jq脗 @{dyTU)#pq~}=cë.0EAv{IlB`?++qn-iDbw Ro kDI,@kl3*ZN3[ZVei']>\7\@f#>ʷ(D^0=ciTQR*ʆMS!(UEC]FQd-=ViH\G"?`c1sS)6KaN1 ʯY[U7 s"2(2,>QIm")HYe⹺ 1 pUO>acʛ|eRIzhㄭ^c"WA.wڭ*ӘX!K+='"C^u: P_ZJ5|E3Bx340031QrutuMalɆ?we:ܬ>aQTZֽtGӯ ]޲5''>8[-tУJs3SRrRRA 33= 뮕@ن6 ƦߚrNô;ş*"kN.(O)M.)7b+c|4{|a 07" fڨ[ehTuQbIjNfn&X]jSm3nbuxU]o6}篸h^d,CCC DK)R#);ad⯠fD{xxxuBCUp-- 5Z*`n,F.3"u-4?)Jz2Bo -8omI#PBEM~Ͳ4B{#)gM#/& [&ϟ{7^H|pboWPu& \$)9Sx\7m'idqYMFcZٚo &kxuv5cTwLo:< +9m Wz/0^UZ::ރԠ|RRЦ쥿BI޽5&*#{ԐQIbZ"y+i+Ã>cPa%n%ju)*lMb7IbɘgwVJR2wPck_u CW[tюffFE1ນ8 $&=;?{=`@wИN{XU#O97b_c%!BušxmI]Qx@.^d3\x$EQFȶ~s.6ާps8@*fq0'mzOܺHqpiehxgg(#)^f){"|k.^+(^/zE܁k9|r/ ID1 䏡6k-0 Ǻ ?|l2/'JxYr۸Tڴ©;nv3qf"gzPBC*@ZV2C $@L;߁6EXJVumalc;1Nߋ3kvj-OgTݪ/ʬ/56l6XY|vʉn%|E)EJxiD!*e^uY=Q{lVX8Y 7[gQU.tâڰnU+d*rP+҃?lVSV^W/^._ Z>ҵٲ'ݙ(|kT`4TmIΨ)^i z-pR!(x#\_U9Q.xb85V6ރ·:x47F7j w}^"1wH 6qzy5,[A&ԅAVvt6\Hk>U+wӮKٝtrE>z  ذ7'5b'b[ |ʙ i$Wvwл\t.q*]V}9L#5ID 7g,Ú%˼(]圅*o+ */[NuCzA_tH^O2"/Ĝ^4ʺno4mZeP.:F)W WΡ1ȏuZX|K$s'Gp[΄Y훶pN5 U#T w~K/D{BC c(Md MThz]!‹9 %B^ ^[4^};M'JE K\cΣ}|BWfPKy&T#:)z }~r[Vd-T"kfTs8P8q`3 \9wÝ(X6[LhtIf)AC+t.FV{`]\ALJsQd.Hڨ/0 kCIн[kTZbesVnZvባ&br{ k1X*VP40)VP`TqA.Zڡ Mڑ|m>hC,4e@&Vѷ` !Aڬz Vr u/&?D}}'f'?i!o`6"?<$.٫UV-Wtx'ɊI^F@-e:f'XL1 q'ן tI뎾 >{0}ﵯ[qa6G; F"TvA$3<@)X]Kzrx5;yvE;}s'dXHxN S?]w*L' ͋=ςSbm]lBCt=Yl~C*~4*uZȞ7Vy92?&TJy6;Ͱ}mx])Ae=g`dN C`+S);f2Bb %S$I ~POC!{'K6l9?"RLnqL )>Q2"H_?lVE.,FC=Pn>o됌`ku0M$1-8I=o3SӌyS8Z$e46`-:t P  'pwc8Ze}L @~8Bb[l,f}%&}l$V Bv' W1kez H.'aj/vJ &7Qc-+ %~-0NXu)"%NI~O\Ef9tROX9'## 3}b{QHceڃҏߪ"Yt}mdg2256no1Ç5X; (xkv| xv(C$RϽc W.bhTKmӛֈ FN[5E C?'8eaֈZ?{mї11(utbqO'‚%Y0hH_~(GT\W?$Fܝd#zjnt F5|tgӥ43gW27ܣakmވ[we!hEb路SU،DxuywiODƛp^kꙥv:\ ,@%Y@Ѻ&B.MU}KėWԵ+^0sqԲ;KE '_虦j[ \T4dRfDvHk0#IKMߐړ[gz[I0}(l֥Ü#O\J{TE\g f|Hzp@1Z~PƉ4+tYV;c.|F9&NDz]#*=ih'Tx_U%*,?ꆏ ~}i(#XdxxXnF>KO1@Jd8UE CX#iaj.%;>DOҙ]R$%Q4=ԀLjwv~Q";1A(q!RZ4ݖDVTCo ڄ̓ RMܫaM/i(lHvT[AsvK:^ ÷ ӱz89r,р"<h3 .I0r028tNG{̀=T] /r|lFp|Rapx/  jy}O,T^;ڃ eK2HH{X Y+zxj1<q]ge3aEiL%8ks}hoF.Ji##ą+h77ujT`,Sc!q주 Ja?,3/8B0GN{)3gT ?!bHSpSwz_9\3,MQs#,niָlIZ?F O* 8p)yWSG,D-K!f'2ԹNJm[Sٳj4j@c՚5BVz^xoD<&s*ÏJ\(M,../>l2mjud:3GO҈Qf9 ؕ bVC`w:F7.ή˝^8]}\] _^00ɍ)Y|K?vGiȗ}9T!޻+r9jY$`l.@c]lCbf:B&X]f;(HՔRd 06s@f\I~KgBWx\]zd3xB¹sH~'pkϞr#Yb+k^wz5x~s-rϲWM`"#OY\@*V(A$jv:jX$\uϏbbgo%-ӎǕ_Zqˊ UP0"g B);͂iӋFQUy*g?2u)6͘tvTD@[ݶjz/"f5EӅ@{;cD_Tژvv~zF0džEA2:i0ЫXOd(fjq!.U#MЦK׶C+5-U-,DQxD  xnXt5%q+@ 98>#Ck+mg8wr)tgo"x <@ mgӨ1(BT+(a+[4|TBL("(e-,yƴYjd2n}c6!rxm(Z|)*0 BQo!SJt`o wÜ'ՔA6o1ьZ:A5v5~T Nbe #s{D0;A|d07NtE^%tFÊl(q!|%C6/[2PZ)4X#ǓX(Y(of~ 6Ά@6|C,h> K>aݧ&d~aPMTnI0Q!W@6I::.!A2ԕY1a "[/I.0I #n ދ-UyٝN gS(Z6<7 3cZRAOq2W`bE_|Ѕ|| .B$-)Y@`.1Dq̞Ugc,,"-9s-Fhu(QG Q©Nx\ ی"y ]]{Dmvzmê@*w %D`Qs euaA )htk%)AnHaƵCA- $te u1W=O hZk'm՚Zm<^ihr-٫Y>C߁=2Ձ11q pk͐XPèx?qjl/g?j|s;ysĦ5/8D1c~h߉d)QDi <ƀH9DӭKO0Na廙/ӣZ䇰x yxG@oP>wMC7H!g$| 1/|ecz>v~AqĴ%2hQ.?]a>B \2R0G;OpK#}>G)YOK~P=ΥěۄLbiyU:(%Lزt^,K2-oATY\ξXoXA!`cCԎ  erTNO" x`W3›APwh/#w' Yx?-m+Y9LZga>J񴈾u4>Wc?ApMoxUTnAV"@:CO9ql)E$V D뽱o"T4=@<@AޝP\73ni,/J^NK_uhűJ i@lV@i`j .,0 cKb J^>hEC Zۃw y;` f 呐}P38B@)2~C9K t(?d+m<שw`*5A9rk(i 5tHxgT%q .E" D=NX4!`mʇFmBXᩱtJgZcrT@=G\H3G~6J'zlf"w`uBHgQNUg ErI+iR>qTWv1Di[R2C@wEhOz;KXR4+Iq52뚣9iytB, HIe%'׈ AUn 2UVTW=i4 %JKl;ݘJ09_|NG䞬UK7[KnxV]n7~N1] ʐVAA (%@EapwGZ+rCr-;Wz3R:IyCrٕX!e/Znu݊WU"j{%]QIUF; C{} Qn0yo4,fӳl7>dx>hqL'c ԛRZBV`v9V]`}M!hajJZ`C 3xfUN3V p-ojҢw9AUd_PBFs -@VhV,(t6s`vQ9J b' ɢwV&lRpkȡ(;],}x[H¶nm;RB>P*Qg, \D lز߇=BX|@DkYޟ]׊ |JMQ8tc4ILS\ҖA[)(Vm:Xktq42GvF=_^f79AqKhl{ӻPVvt@qT/G I/_vm{ye i?vāk&hЛ 3F$ť2DMZa7+a بqcmb|wy_ աŶRoD{b;$3Y{r\t($,uWT|(\"ԼṢ<7tj䁄wA4MoHOb+y9OQ>ΌW8emZ@EwBPuPiE,'O? Nѓو!d{ z7;3Xpj=\tf^SC~5G=1gF^SI"~=^SztQmńL Ob1nH* cD7W $BQN W- D 2/K}kkO KYz {4Ru*#ed~*VY$@++yC6\8a^YS&fe& 'nTDIQ "-qquuN VO\X 58""/gpMw t4C%ӟZ_E) *5 +$5%Fg%,xtMP,d˖\ǟ ~΂Kn't]w+rEnۘAg,qopɈRg"{A[3َo5o Aςo?6 h}QNOH+?9xVnF}6b—Im6nmII$V.,~X3$%vP.;{v ;Qa-ō0Eri ^JE^AtYgӳQ4Ac֭, -a,]vc-t[m6(=^ ,cIU}Uo+u8{꾪[ mt}I՗Nj7GV5x-3Jnӏ'?prrr6:Zyr/QThj~h/ՑGa~~4t\*Zނ;֪n6T 'Vۗ%Z#BUe q2y>u#r09r\*{I >M#f(_Z:GK6lޅ=*t| qǃ_y9\9T`pg NT9lj#ָf 5\Q<C>KIin޿p^`̡hÙ"bqLpnYd*1=nqxqq $6L&Cjpеڬ+BI_|@&)⁒ZX8 jYPH3 UIWeݷ(V5$*sE:E'c*˜~ҟ<{vGl6{lv< ?YdP1P$`WR?E.&gPGG^.nJ-yLoXJ.<\u}~ZԂo)#AmxxLqxDeCPWBfqJ'NHQ JE*FShP( e`$ %Nc{ǁyb 1w, Z+Wf3 *c\Z1{%ħul'^d+f>QHGC"2NDCBpIPH72&iu h7ӍEsFʢ r}!Az x4h NkV硐'/%-pzg$=ӬYRx\=eB~9u::z!N(,J߸4̩eC1Ƀ݅b7A1O2JN^LLs('eNU9%ئ;9'a=~|v2 f; _X9gxXn8;~ v#id~$ݶA],P-6YTD*''!)Kvf{{{ +7C<f2M31d64 raSc)e>;Di55ETʨgI[W:N٨yz qJL%?]a5A51 w}mͤ>`30-1Rj-8~VD WPdcQd ]Þ:B=.di !2 &d0b B[~pPtr^ *D=p.G(5 G ;=3sóq7ez_l6hZOb{M2@ܷO6_.|1A5k 5Ǹ@8eS]Ҿ{DFhһgX;Gd`UK>Hr,,QMy&*) ̙ x e!˰V 3'ZǦC#]ʩ^ƞ $nЪJs^HB437AɁ ug3본Y4̖kz h̯pK8;ebdfH|-dv;ɬ(BVX 9ͪZW&!5x 3M(j n^D@ʳthmN(>^xU_Cx5@-ڥS {G}W]V`j}W5p+xQ+q W+nخE!#,:[{wi /'E` /T$qth9ɡ3`Ni [иԕD\ L.P6twݕs!?p{{Lq-W3+4TrkK wk~++Zihcm8+K@DSC|x,Q]'G/_V>.sV<ɪT kzCBhi¶۝+,4=S7>z j&˜鯙Loˍ BD)#& Vr@-:xfP= 'CAQ uT sxIpdK8" 黔EY H EdM[[я8Gm,[`#b)dq;YZ٨|ސꀡx6 C.asUei42wQ;zfŝX9h7>X>C:{z뎡چYw>)+^'u!\2!zsc۬'TPv6R3{sCPZR7V:SΑ5xxTnF}&bB5iJTM$hi0$B.\VV{gfc$(9sf{U uF9cyH(J^VߌeQnAy﬷O,g3x<֝Ϭi *ozt cF_~18@"fJt`p~\<hSMGSR$wUl)bU)ۊKmFO b}>:5R7ܾ0ީʇr 0NlS{r&+"&wH0z-ﰳnQ{U PcmGqI(n0Fˑ5 _+²Q"fdiլ>GLKeHEBlRXx9i y# lK8qNr F9I,; (~nH3iY,WRO]}B:= 6RkSVR#΄NiÛ@ 0Qިq`s ?M$i*DUMpw^Lͳuy5uSUuٔ#l2.Ltun%sRVL -\V4Kse3+M+޳cOQIǕuZg4q]tʶ"QI|vN휃Qd:tTmyci^^Cߡ̋l(繱Cu]փn0/w׿ToZ6r2/C'rP_V"ƷQnRcԧb&Y#yvkT We ڦf Ƈn *WX5r E̳Eq%2y` 1\j luzGTD8Jlu:ݦܮlRLЭ54`gskiUBĉܗԇk2bC}/yT`%^&eu?}%r9VVγNum%LRGkZVkHmAPP.W^]htpx5´zMsSp"K^)>&]gGU^d!dPڿF+v z"mCfxR B;r],fVTp1߭Α  SᛐKq:x)aU.^fYY km?!P/?+wQl)[RVjJ2^Ƹ52\#u]`i [_ۼ74|^pin< Ul}|@"c B^.`l;^"[IC~#faݸB m턝>p@-g+$쐫p6c$TTd,]l29o1|:8vge7(Dd7%vVA)lΔW,_zj~>\n\EKhIG wg>غ U,v߮15䆟 jl;E\a\‡#tɩ\TĘ) &K q+H(ҵŒl B9xB~ޒ~^ms}Fآ@fd;}5-! 4/#)_YV.L?32U$[(5*kj^]3TͽZ*ud>y]dwƟTHAZ=?ᯓzT{^y񔻄1xe<>||;8έP?`GlhQeIQ>oְ1p+dچ~5 &fb]F؝s`B0Kr(Hf f]H2uZyOu'9CmM+ f,d'oP2KqQttk @R7+n3]jkMS뤲1z-Za}#H͐6!7(V(rRP0YF&UV p.L&xZu!|h*vJ5ۊBr;6QDEagÝnc/aڴyUR7πĩ< sM@Ӊ\l,9e SN_O]W ҥ] em>.Fh63\|=98 mB=(eB*N-P~*z YQW DiqY=V޴ 9<o%#?ͧϵj1IS[qScW<qn`^Z{Q4]sb$w]:!?F.Z?Gf t枼G(;rithLWZ2z"|#)G)GN&Go^NO& +yH mjWK9 ,~cCWtCF쏈mhӐ#F 1H~hջB@gPF\[EjsT:3t4xa)2z]B'ày>ut h\nc4D[hUK aLKaҟjJ`Df¨4rd 4jh1wcm9< #.oEy?>>CD\A`K=wZ<)^Z *F_~,J&=&op"G-9)ڱD-`#CQ*jb_h+ÝEWU﷈p f?)R{yc=*ySr(_G(u ,ܵCHӬSgڭ+|ҚPd9! 8HiѰU 8JX Kv4ލE#;7z/ҾкkCrΛxw2=2c* aolFmVk[R3y|?*6(沷s'믽[ԟ][GJe~$]2C7/|O̊jn% Y4ăMHk.0$Z| k>YcƏVVVgD!nf,|эu~%;:xy1>G{7ϳŒ_Y"jL|3~Ffn+UEMb{У7@ZDx3GBZ J"_"6t%|ǺMZZM̼kK@NpF4.l[,mQ^ $R~_9uS/!Ee>looE;myH}X|逸 &kefqK`GJ5 ~`C@(Փw@')6vpz܈\o* +Mnn#r28OM%$2VԆ2 >ހxXl5}6%1T)i R9 bp #OI_bB"HC;[YcMxXNqc"fU 'o@`>s"$ox+w~s~N^[9N@|]һ~x/ `Z 8f*i2~]7Y_2*-.<yҀX߃#8D1Gl D0L]iޜx Z|VZEK('/D4&ċ3> 3j 2(OC|4n?& O7O4[bywj cC}BMKxNNc raw(here(1), j}xVMo8=GbJ p]MMprX(Zm?b IEk7 PlB7o]+ xFjXke2< ByhEo%l :R$<si4u=n#cﲦUVVEIeN?h^T%4ɵm3`nj1t"n;.f!6&'s0E7 㓭I"PQodA1x.$O xɇus#MIH{vetJ*M_ʓ99!cp8t5{[ʀS#}>lBȍu+xHW<ΠJ)Xcw]:[pUa_PnnӱR=8 n@ЪW1 ^yGA mkGd!hрj-w ߱ssS]l>0/4]-ƠġGPOn- Z޺Mu Zbŭ9uF>-ōmj >Azp^\De6_oϲ+QtRyvzM9ySuXd껈?on![gbKfAr/.hiWNl[^b惍t0 fۑ*|#)$D|kA 1oFclao7F`UʞݢR$쩔9R+8Sz)MRc{TEfM!0uCDr^B"A b+,Y`{.dh/j/9-u|4"}]t!MY5-&T&bNFp69N;bM6q4N #0J|k;D#[pLk[QUK>X4!Uos X 49Yq7OCԯɞڟj!'r;sx.,6f9̂GɓU~F_YIZ~xWn6?ŭbrI^t8Hn0DǬeR%)^`'ܓ\Je+E*Q8B3q+OUt:j^)D[o]G/sv:>yH OW؞q&gIf=-ID'DhK姰 ִJ'Jk4q@/[#27ޜ `a:6X}0|5{A{AwS2(eK/nnӽFįL] ^\tWo[/73-G-PQ-aյ`V>ڹ)WF^}XvjO[m@mol-cU7B6bWKܔY:nڴ!ݛ_ޤ}mPfb4؅ W*|t[G W̠5b f='NFyhz W˧z~MnFҝؒ{6iКsNwZU=ntAP\ov3TƤGwνo zYQ 9Mbr|>^Ӗ۷mfʛAT_x}Ҏ0SsN2w26ŸfxG T0\VޢvUc hVo8ܙy!=+LV`F2hvF"z3XlK\0y,$ \l~v̽7crj7 í9QXvJ`) Ynj/jxVn6}b" /$]h]0Zc64)T0ЏK:CJ _,9g]=rSA .-DA'̴ņhl)ԣGˍ0 Yə}x,l-[p1Ѫ*\ ~̠{Ap8cTˋ00ZzU68=ќSfKL k@{L eSImPȱ9S4U*(.ZڹSKtgtk }C;^!ooWB-p 4$;[cVhտBC;.RPP?S!]S[&)xF(x!NbD[tdM8I+^Gx `Wtg/t`_gggVLbJpf"H~[G'w3)rp;6B͢I/hZS±sN`6|LD3ZW{O0"[ 72F4Eha=C%MgY vr>`NUq)glkk6np[Ak]୫K#t6mC-TgzpHE`U ke+fvZphln\J0coQȽ+«?pTs 57}?mam :[Ȳu+_3+/kx'\+XM"k+LF!2X~Vȕ(yx |7}|?iΦ*c6>UګlDuI/ѢLkQzR3@;I`'_Y%kް~Yw/eCdP̱~Jxdמt~mүbJR?SL kaln0 _=99chi+:ڐ_l}Nnw& %IIZl#cD__j x\rFm=ENȘ$cFRlؒ˒7r "1E3WCn4@P{23ID\rܱ&oV%ו.dȋJ5] IU}?u6$3\Hr;/ eUГ<.=MrNobQU~@ nw ,JqfZMfIeBa:s_Z;?R9_Ou|^BGH=k/U/x||AjnVvP}ٌNއ|ߧ%%#m;)ƺ$Ow?i$ .8BK2ƝYf6)} CUQzŏPݽvoѳ$"R2}hez<^iN,E4:sXf8Q;Q춭"akKM7_e0'V_e'`%8,OZD{4C,8$ldfbA?@o>U|vW<"*#ӄVf e:=?Qq>Y5W>WU*,aNQ2xAa,(*9yںدWIAPdG "[׺X85L`n"7xYzށm vw^$2?Qs÷~ngG~0eý;D;?{,ˆ<=se0 *ҙ((1V%OfzNk^fi-:4'-ܻS.ɬꜮA1ox27"6? [ď_2T]ZWLo&,3)YbWʨE_님-0} GkH6C3UYaIpYbVSaMXED)8dЅr@z*\/_ Ju>N 9]3j)j!du,[SdɆ Ĵ]`^L Cƥ0! p  ro&pv 4ZoۛvCyG'.c1`qi-Kacn`Ag./bY-{.cmt1N"s{-&/|<%3z7z_ff;n7>"=YͪU,T*1kM>q'>p,eJ(MMx^"k0'X]@, .W4<<$DCf []_A:S6P0fьvg5݌rW,bocZKbA0}Øh0W"86N2w#]61PtpI ru FK")HPx6 tx:w$sƿHdKڰAɧCyo7Kj[|Dq:r|#.o/-$}!*,3p"K^ʎ׾m8 4>W$ΗdZ46-౹=}Wc1""_-nK ]WI=L,1ACޏ6`j-$0閄BC&uVE)ƲTg _/$4ya8m&l\p/ΔB7Ao[^6<[RGzz O$=k ՕTCs1[ae4x#$lU@‘K(TqsP1zf,h-ʇZ MTU5v2t`KR|1#&@zlvqa?!j-|[|6Io]_DL Y-Sxc7hdKcz A=}snㄇX`6#n7gĘ2BQE^aImLW4BƫMIoUW!Ro QBrҝiʒʿHV&gb,Q*V"؎꼈"9~6Y7 d#j&R3cNpϞ6&l94 >ZwN7L*]xC6V˳yw;B3ZE\ yx4N5Zbo_Av9FΈ ZE#L L8?<2ݐ,J{vƀQt2ɤ#G19q6nTnUyt\jdU*bɹb3Y؄QMص!"!za~\xf70[|OÀ',J2їdܳ񸮃DnVE^!A+B|*җ 4 Fʈ$8$=2S) uKUIMHz~ˣ OeU MMsk! axzzNŲ257Rb2g 8mc&4_ GA Y 67$\|r!Eȡ[u8u`JTd&Aj k1S3V;!ikv_(Ŭ?4|n]4k9E :~;W`**~vݻ1Mr3Z amQ*u1Ռ*gwU<}3sXC>-IO n֞>g H 7]΂ѵVTi ˲quEu;.k$/DYm^ܶogbWlPumu0!;b6Q$w[$XnP_uK\·Ploݛx?K(JShA][%UMSiW5uB`EMFbU!-d |iXe{k0#DIYZ!rhvA-ԸAN%+hr8=f4v͢Rʜy:.Zm]GD~BF6p]MǣGcl#6UHdFDonooܽצI` sxx|`iN !5?MuٛW܉C~n$͐cT;؝%}u>W}J-pV{؇X }4b]ZClѪ05e)j‹RJ9F&FuLf%ڢ-wVLV̗E08.l(_)i;8T;EnN8]GXo[oISYVwN;h cdCFoA ߟw,]y~v^׆H&Bh>6 kkhMN.ýn/$ E,cs#adl_rR:mLڙohZr)erpžd Z i+LUFF;>[P̒C}q Z؁3Iç'Eu>?`,Ix˜'YXKƔt$tq!_ƃl]ɇF#9'^))D (!VQuLT؊F+k¸I N徔8tQh ^0":vhI ƶ^dLk2zQ*M>f \ں & ":v{hG\DTcѳc!U6Ld݁nQfCж#u,83m(cn*.9=,h/iYv u5+v !Wf.hWj;eImc[ ~_Lvܚ4 ߕ[M[}j `[;mm4ju'E}a[$pћߛDQN_1wiWdQBvKq+:)k.+}V,$Zӡ]`}XI3h=(]|̗̈́r沑3:=?#wwpz[8\&ќ:!b^KT2WlHXѥ"U@^;-ҹO;{J$_U"lg 5]|v+Nل^uM'm1:R mh¥1Ś)jÙ2_^kT"fu': F1Ql@Ӷh*@ə: spJ8Lqʙ)yAQ7&5e%[.Zb`I2?8 5M׼fkTDOobnv<[,o4νSʏ!lng,ʪ! jaO5A[hʘO 2pKpׇ nA#]94cɚiB6z&oom,7zŧ,ݒ-},ݱ,=`Cg-DqK $;t rhI"--2h!u:/dn3[TF;>yڅxh7[a]b+< nuKːn#{pw[Z짇88Nhڵ)E>?Ѱ xUnF}6bB-iyhYb>&kj]ZV~agv;@$wzL#;q+憎jh(B+']W ]Vv/XgiIGii#mNA-͢ 4d y\0˟nM7ݪZڿt7|}kEMvyqqS0ۣcz a̔U&#h",Y)L1%hC/ JDPNɍ$Icp%Ճu#V!ҎccU%5,J wIJU7TB2ҵF~5 wO9 ER;ħ=||EHcB6iIOZ]x@L(:> K\lhn2@EP~Dm%]ۇ"Na8{8 d@z3 tNUJ ,1@7GG)$6?,fƜ9HU5$Wɗu ]<~4EOOK* W qRE,5@YPF g0ӛ#f}BoȉJلMC뀜\=Cw;ʜKڶ ,@Ǖu-G˽B'X n BSDo!ܤ2{y| /㴚3^VǁC㰙< _{ٕP<\N]4ױ FJ]c LKi S]K-aY,+@ fYpqAsuG 0Eq#Wd,~HjUi_gT`aIF#Q;uӬJ8(A: g* y 4 YA^XwxpF|mAL\c<ֺ-F.fr FkwO|!/[ԅMVAql,IJyUFXi" o`b$Ӽ J1)0pֲA7O]#K9]#[4 ?,\q,ntإmGo{.(U\Rp7IaVJ0`AcDx: :.ԙ4paLgWSdYnʜh4>}k*j)6!p=Gy<{M8ܷ?Z"IfFUL26Yle/Ba{m$m Ӹ°#n}WXCZ'}l:.oa? YVN4gg,8}GhzٷL|˸FK}OJa%敺78="|bGV "2 OpEX)]N> -$Fz#khBKggG3G/,YR~oP5HnƳJeIjK q`z+PxS{% Deʎc)c k؊Q޵N@3ޒ5G[%-Y20ċg_"NJZ' =XR8<߾g䭓;zP'Ά_G 'S24=D]@lTdh<2w~*K@pא8Fk IAsvkp xWf&Qތʦ`q]j mF}>-nOt_ HYp&GN:1M4EbVqC,tH?GD󌺭|C.FM򦶃L!>9QSx[aj9] v+VwQ)iϟ^ (?)hW\M.ԙv}@it҅ 1:0!e:|iC7P DTyp@ wxxW}h|uKΫ/O?tMov6*2@ȶ}$NCsh N572A`t޾yr˾7$n/8ualjݥs{xN'A,U;mեLmiW#xo+pRYT'.m;j\W:Mo?r7}};۰Q 7*xpackage zip import "context" // opKey carries the invocation's operation. Its own type, so nothing else can collide // with it or read it by guessing a string. type opKey struct{} // invocation is what a handler may ask about the invocation it is inside: which // operation, and the address this particular call was made to. // // The address is a FUNCTION because computing it reads the decoded input, and // most ops never ask. An op whose pattern carries no parameter pays a string // compare; one that does pays reflection, and only if something reads it. type invocation struct { op Op addr func() string } // OpOf is the operation whose handler is running, and whether there is one. // // The path is the PATTERN the operation is served at — a group's prefix composed // with the leaf, resolved for the occurrence answering this call, which is not // knowable at registration. A definition composed under two hosts has two // addresses and one handler, so it is a property of the CALL. // // That is why this is a context value rather than something a group hands out at // declaration: a prefix read at registration is the local join, and an address // built from it named something nothing served the moment the definition was // composed twice. // // There is no operation exactly when a handler is called directly rather than // through the declaration that registered it — in a unit test, say — which is // worth naming rather than papering over with a guessed address. func OpOf(ctx context.Context) (Op, bool) { c, ok := ctx.Value(opKey{}).(*invocation) if !ok { return Op{}, false } return c.op, true } // AddressOf is the address THIS call was made to, with the pattern's parameters // filled in from the input — "/v1/traces/:id" answered as "/v1/traces/abc". // // It is what a handler that FORWARDS needs: the pattern says which operation, // the address says which resource, and a relay has to name both. It is computed // from the same values [Address] takes, at the one seam that holds them both, so // every projection gets the same answer — including a tools/call or an // in-process invoke, where there is no request to read a path from. // // It is deliberately NOT a field on [Op]. Op is what the [Authorizer] is handed // and what [App.OnResult] is told, and both are narrow on purpose: the result // hook is given the operation and the outcome and never the input. A concrete // address carries path parameters, which are input, so putting it there would // widen two contracts as a side effect of serving a third. A handler asks for // it; a recorder is not handed it. func AddressOf(ctx context.Context) (string, bool) { c, ok := ctx.Value(opKey{}).(*invocation) if !ok || c.addr == nil { return "", false } return c.addr(), true } // withOp states the operation being served, before the input is decoded. The // seam that KNOWS the occurrence calls it — the REST route, which matched, and // the by-name seams, which looked the op up in the composed registry — so the // pattern in the context is the resolved one. func withOp(ctx context.Context, op Op) context.Context { return context.WithValue(ctx, opKey{}, &invocation{op: op}) } // withAddress restates the call once the input is known, so [AddressOf] can // answer. It keeps whatever pattern a seam already resolved and falls back to // the declaration when none did. func withAddress[In any](ctx context.Context, declared Op, in *In) context.Context { op := declared if c, ok := ctx.Value(opKey{}).(*invocation); ok { op = c.op } pattern := op.Path return context.WithValue(ctx, opKey{}, &invocation{ op: op, addr: func() string { return Address(pattern, in) }, }) } // servedOp is the identity of an op taken from the COMPOSED registry, where the // path is already the address it answers at. The by-name seams — an MCP // tools/call, the call plane, the in-process CLI — resolve an op by looking it // up there, so what they hold is the occurrence, and this states it. func servedOp(op *registeredOp) Op { return Op{Method: op.Method, Path: op.Path, OperationID: opName(op)} } qx}rVS iStgҴ]ŒcMے[;ӣF J@ }}G']9)ITm-rp.H&WE-66r?eѣ dQ"m/ft"T?i~ioȚ8ퟒ֢*r{jmgEVEhz~I.zxN%ehJ˔7)d괺N(k꨼)EZۏd9Ooc2Kɤɮh,ӊތoK&YG-MU"O4_Qф "*g6"M`%}>XV6 'eTxHIEG$OCa@3.˺,*ޠ |nS^D&󭫂.i"~9ڋvUeY̲ ,YV-^β).RҤ`.JQl͗{ISZ+vJ/>ݙArD7и'YNabvY1+q^N.֓*[}0iQ?/w$~? hH{7UV'㜶^.ӵnUI0Sc\dF N d8!^4*P,hiB pAfbb1X;KC$dvحo'Iu /xA6˪xp&ЏF/h2˧:P w`o.h}b۴,ߥњagHy|DiUjc6I|6-6f67z)y6aL"yFf'nstW= 0\ӡʗ ' yBD)c@?$~JmsIS[t0Y emO&"uC0E?ꑰ˵ B~{=>A:H)g}/̴_qWcHxe`ƌW)aa[F33eI0v:Cd ^6jnJUHtV:o dS54OHICČ0qjEzs̏9Mg@88tWc:e5`-^ay*bjxe[a uP=@ /4Y5/1o^fo5315lc8g|]Msگ&fą|=wx7B1!}%>&Rm0π A?bx?ԟx0(|y=s}LP~3Ix0[XUhm|-2538ڛ/E:ڌMx}t>;$-HdLBDX~ImneSz(vuM(eP}c^E\VE<+!!oвH9 X C ڜD!s62ݝ2jI蘓[9&&yIc Mn!XU*CG=٣G $6d1q Xirdxy:OiD}I7YI|jDC)V$tpI}E%cڕ8aU-f@̂9p#9إy=zw=B&gY:D%*hs/I5E8hr32Lq `}䀕g:7o#L0%f^!ЦH=G [8)· 8U kll'q4)zl4-J/R`))`!.@b 6pD4˜ԟѦlF"5!'k+V+! \6\at_fA߳gtiLp5z$04ɒ8 0bX1ۗIfț b (7O S߰ ;4 @4!7<o%2֌cwzH7vx0r>O[h?,. l 8 ybShTVQU a2Q/f)ȷpMa[e0,5K2`mکWX H@KVl"w ܌ʊAF)o^O:Tpi/Tyh< dgAfYU7$ Ol3Ƽ9CSOz}:URdǎҿ.I% `zo"J#%k@'I&0j,j|З+ Mb08ĉހ͓+rE^V|aLUHMRi67i # }rx,&SG8LfY&$KKy)08=jͲ5=]o5k1G[=H[o:xv<?FETt(W'ٻDz{"ÎPkTI|05MIԁH֭cOSft l"\(0%:$*¼T́p3>UG)e fوxAp7!荠 M&e_&Dy�DA 1dF Y1m0Տ֬as7s~^tު }8zSWX=\D&ԑc avt<3$1.W\ ӽO S֎G[VYfEEG֘"5MF 4Kj܂޴ڈ* *XG#(+T3XwY7u/SP'?pO;$o ožK JG':B<~zZ640 TvۄQ4xJFf^*'Q/MgnD,{oNlpZ2G!~PH$L lNe:A4' X.<< U Zy, 1N!GU0zf$Cubܞ9 `#YУ{zsRXGp152+&}!JXjx%/Pn 2g)EL|@NF2#j]ߔ񛫖B_(͉J~G~nf0^5S\(49K}`;МB.EFlb6tWȋ}PEj7'),Q?JOL`ge)mO!HpJ(K L.ªEt S3 o2b&uY!R#>$dZ.ڡN;cZJ1'~I;[hPNp7c;dTf))Jс6^+}z]`Nju 8F`zfK@-G+fX#- U PHT;Ѣzeű=ކcc[>_'yohOz~k]?Cw;OBNq3zE+QlA2ڴET HT>wB4fX=2O8JY@g"AH&RjА󞦳d7JyƿtGH1gN \+HS@3ȭGOcPa_O U=DҮ^7e䑏wfq3p# #qa|ǩ3+^c"m;֪$=y~>OL&<]u5PpS?xHj;y"4(nN$ьlbTcqDA2,S'K3bQ&}h",BhgWR,SX3x(˗ V\nNU';c7~~F8æa޻#S|9IfJo9CINge)mLQk'eIB:5̮ɤ9nP9}d6W p~n_?^Tل.l-Jn%=_ޖ"cxUV/Y^ѻ=,4> ^.z;I {"kL[dr5pylOSRҭ1 5ɼ6yyyzAE;;;n( lB$ ɪ9 1,u0Dx1{T'9@?k R@̲JM2RrRn,ZAW$^'U4"-2Fa_Cܵ|ڎLƄvP8Z9A6@:Fivo`I|x8H/ݕoۛ$dTnAAqƊ#QC,&,|{ۤ}"+$LJ2!]Ma9Qoqx=?q'Eged,9Y[:d5{L Mr`c{W]b_z#tkScc K'yeCewD鉑6Lp|,J,Xq$ Ow%_х͝@XH$R/pL]+J]= &I)>޲) 6k9;wj3v%z a%{>S43Nį ĢqJ%%cX d'q iBY~>RS].V7/dN*zN9ԫૄlQG"Wʻ 'S}I>R$ -FW<#q͆O [ɷ  cc~o9"=iXT4.Vƃ^wmNixQ:/4/IhM!,`U`auc @=˓ I:` 6 A%_N h$Y"䵐V.b&Lr M59fvZHOHE a;K}3I)[//00 ̌I&U)O#,V./6vQQl}l4% |Mc{@f`[םw:ɦ"OL^>vY $tH՘YS?]X{:7g ugneMFɞ&ZJ.w|;5i.WvE"b8,9ZNw}tS 8wE-]WxNjN&`J|[h je(:K ՚$K1zQ6ݦfj[>UWÌ蹐Ka *'ZfGXD`f8^:N R9֬U!Go:CS@+U{E~ -:4j ̀r*:U>:cAp Xtc)y g9cK3s98r>)22$o9F3$rI/'H, Q2B9l v$%Q;C[qV)+u#,6,=k讘q\`3菣U\S{I_Yb+Dh}T&#mm|񻒋 ֚x/OE.{ α+ҪH |B-$ )IR*!hOTlʳAԚ Kq"EW^8X''S7kĊvˆ Ab~I@ TQAiki62;.Á+(ktUhsxcM\_jX0xyDcgi 8@f ޲5KPx#'$7%ư4RhEF-XJ")jfkc$ lkb=Xƙb!(mK#j=`G/-ɁP괨{ӓq\^ &b41ɁMKn,\m XJ}§3<:Xq+h\,N#RD˵(e_QLI U6fdoijXM5C^ u#u5JmXH o7-H#q0E=% %epwSHkAe9"7 &T(!isLPTg ҈4+|S3PM&77ßaa.N"n(PLq&3v>C|]euU,&vt8g%,׹R[gIpB( r'xxMSTM"+g3;i,)+> :ΜkNMDDPBDIC#DX1|sL2wx8/4!8wT.PI|&VC7 OXV*:YSf6!S[nޥP2+owvhFԐݜךĉ+r'k!>FPyNbwM7 *vofߐ@׭_OjiW GzC`>*/#|ڭn8ZBG Z^υ!8 YZ< ƩZD>ٴ`=1qdDe5Û@b8A{: X'Kﺂ;jkϑ9ТhE"HHP.$ AcYU (>bL'8X :qਭY3?q$ 5-Q%nCl jd ,7PHa7d@+B*" 'h&wA e3CP r9ޡòadlVxg ?1jm!Л?As\!X= eciR 33J݇"sj!Y9fh.8)0Y # u)1Xƛ+YEJfOQ6oMgffsRdόj;p!2288rԬU?mhp֫ILrW$XXymTЄ] y-d* CҪWrY7\D1CLr>-$ Pc=ec EWQuw+ݎ9d~U8op5 ƞM'yڜu?od$2/I#|͡к[]{e˯U#A&/%}/4| ?1 I uHLDv|V5%FVhF R g|qkU@1GJVl%|Sfht y91lJzȇ bbuiYqPl=IYtHЖnI(VWY2f=$BlVm fVbEl4G;,p6.+LZ?AꯖcB Q6v"JG9R3E~#*o4heai~na_U*GW,&S3IpPY,K\`WBCܺgf Ƙ6ZVYBšySGWq:k]/\uzƒʞ=X%J-7\Yuҿ2c6\M<31F<<Y!KOǒCz$f^}, AFJ=1Zgrju 22[WRڤbb7|%Ad"a(z N![ 9py<qxN_f<`XRk-68!9_|pqwZh[wi>vqf23ƍVJjVIh{U8IPLϰGI5iy:j! ka<bp9F4g{P4]Zt^sHiP rpGֹl2Q Y#v_;;8!kb֫R•Y8 lV}F3 SRr3No"u2ɑ&l4Pӊα`vW I7#J04hNda|{h! 8 G菧173["BΝ&|J]r|'ZQt36);Pc>ͅt&BRV.FQ2sAc>l G|JfZl5@`+YVtdV陧!2Nr Z3KR~Qh?}n>>;+- d7oIJ8`\[-G>8}.|UivgRߣxo'`IYFV?Y~` OGD!հR8ܳY(_ ITD=|ws;!o'eE"0o^ rd| >U3/9kXjl\$rt݁ b7ZJ:H+~ ݕ 0 7@5֎in'HLJ4InMxdZ, ]ZhA)$]VzdLZ Kv%6>7AQ(%4gz@P5Pl$DF_;`UŖK]JX/aT? &)puQl_ #ȌRzZ>~s75dk6̝R ڡ%uDZ$~UBKP~7-;ʠhXw@"l`ZZ8!(h3}ֻE( pA5߶@wGJ&XVpa>ѽDV` {w>6P.a#0Y -7 >Ƨ3M"eIoDB8P75l5s3WW:Ji =קo(L,?V#&Tj|KS]"ʷ5 ֹn@55 a {BP\_6,k'pQܺ+$XtrX4UBD.TThoR?fCYc o,YvaNl<kI+{bNj {,f\O& 7[8A*ThT8OyQ )q'~>>M\+ =/%eU`{򺉖W`-He,NAys[ft{cR'YRA#C8 s &q ^Uw{[8Kz(>h%38.oev"DaN @Ss~:-LOa c*mM.OwEX]~Q`HXR_Z hDvbxwu1¦aQͅyC(Ox,(4xdt&O[10z,zCv"jPE1h%mǴX <̤ڒ@)˦NhnTӆ)m^Avδp;XV,iO`q{BW&lqKn2l܊貍qi,zF.Ic ق6jw$ˤWRgd,*j`)3ᬣa3甒T4&R%f \M@q7AjŒ ׶ 4P,\K3.DtZJbH VUEJӅfIa닣Y@$rj;ĸ'[۬$ {0,?|ـf ;|z<_~ JltԟE.wajY͉KC䄨 =m4y @ZUd0 Q JZ3?#mv}mƞCR&6 Wt4#,Vy:Ŧ V4pB a^zK G?5|b}$!~HTHbr?cʰKt+ٷtWI}T>+; #KU\dfncYptf垸:ٗ̒ki~-]ٕYstkϴZl[D чV{]}^Zr{*E5HNe{o9[iޗOh9^Ej-x,;Uֵuڇ9K\9M\ ξ%jWQ721edZEYt9f/rVzJDC N"Z% *LE:3xԑ"Я>E$AEJB>7#؋Nh&b+$,nj C3TuJKs%yw.Ku芍-\n-c6G25m VYsZÆ}Z֬:A")9m;&bU}4Y!Ԝz9.B]hWZY !CvmЉJRlV|\m)떜X2?fF/4<-ZTv{R=}]&Q*KadI, ԧi i6SzI#^[ѕ8XfmI8b1oߖAIhnW\ 7-z^uWIm` *K:d^{ɉܠ9לBJMƧ]e%uaVQǜ8Zbɕ#]#Bӷ W+hWlGf;}'_uz՚|y˧ݧV$kgbSy}lu"v[ʜ3\"Ҧ%_ťUg`(R_¬ -Yd1v@ =nǗl^|0;%r54I}B+_Ōq!h6'Y8`ܵl q._Zng?6Ԓ:R-Qla9;)n!dM.'WNyϏԃ1 MVk$S{z7Hԓ{ EPzF^\yNto\̞<,Eh0 k1ަD=Է8~0Z?\t蓃&7XR2l"«#w%eEԝd76WgfOSް6l[e|8,Cm`\a5 Sre2l#x{S֎%"hF)A[4<Кk VqqHFnrʸF%Djc?,j6zB('*/ 8o|,& Fi)B\GJ'a)ǩ6y'1ZxeHϷLq(zW=w%2ed-_xXlE|C\/ˉGq7'،@Eͱd-J4QyakFݘ0[׻(DI[s&Ԯ.zb]gtvBuu*?1̆U֍ꈢoQcD+ jӱlڋzf( ^7L|[*'Mr2X*AOLp*?ΓczauIbqQW1BJAA#u̐}x^9&X%kÖKp\B85tKH\MYk9xrMI>+>u&A Ik4-Y%Q/lE\b}1 8^l +KYТ;68ܞK8*Ӟ)C̆\9('|7 93RTW\GlQP:gـTҬ iI}Q4ZJ3}ψKJNI"=+Ƿ_f q7*E C?ur 7)qn)3xxY~mBhO=RjjD !xHmOG٣'ge)$6[pPC>C6jECiZBc\7o5*>E=+Ψ}p#RakcLk ]?JpWOed=v&7ȳqzyRwhw: 1[]:F )[Ice(u>gI >Yܱ>Tq6_QJrl92 ]?5<: ?WH(zq?=!2Cz}7edIHDC=&s@ޫakr8J 1בMA G#:7 $^<M`k}k]9jې5rV>"yZBTkl㥲m\4.,2UԬyC ,2@BݵBH짳 ;rjp%@8R>b:޽?h2id֕'4v޺RdG/vk(!A4ۓ]J }.tXmK qR}ܮԘ34]%Bryd= M鸚qtb)# 㣕Es@PląֹY10ܱ@{8Aۢ,M{eROF]ti6䄫!-ȧ2n5 $6v;?޲ DY?1%n܆;EKg+GS>ϰ=5qKR帍i#$In}Fn;:|{xwRv9'4qýg)⒘#v~8ab@Pdrn8$qf29pԷa-q|X3Wb!zϾi3=(<y4ZCiUfRq)i&I82a?ZjB1`qkqWm`6)A m^uy+R\M"]Z}|ŞM5;FxzrGjwo}q+TVlUN^\&lokKz¼YSA[3pŭ[yy ǻ= ߢn;oZJ?Hc/l/aaPR]-8|KH"ڥ}#8WOIy+C˭;~oGU[ζ?)7%zcWykBm@sA8+&U|\ID~ڈi}6aY_bIn\7z]H7~b ^,9]L9z`H!iItkRJ~bYu5e cK-<9a#|p^[jeq+J$,^JDg~c?! 1SqHR٣ be Tu؋, c&ˋ1H'| %6dU*X B'ŷCXWp`oE%e= ܆A[Z 6~;Az_0Ѫ΁ƫEM-ܹ=it!pKu5}d6x4UH듷o*γ2:[}4M0\/wqBIb۲YvXq$~)bD,XwcȊR5 ϗ8zaTLuVq3kVe}{o@Xթ9bm,zpb8iH {٧E?p1(gbE%jhrm9[2k9_}|ϷNR-Afm(}\5"XJYt|;ؐQpذaM2pW9Ϸ4%i`n`\:SCS; o9Hu܎a2@^/ &)$M,1*lw&!$<n}M_gOb&8'i>/K\!Jv2%bjG 5HEݸ5YV3vttsU1~riŕܜ%hݍ5*ݧ0qnKvQ;̓ oR]P1(hӭ]:zYWYj(V{[WAoi҆N/BbWؾ,.+:g9J hi `e97%ƭ;5bme@eCYA>W!^3W3N>4fP]Wt& &}Eǣ* Ҫ]AV*h1jϕnoxpackage zip_test import ( "context" "encoding/json" "net/http/httptest" "sort" "testing" "github.com/zap-proto/zip" ) type tailIn struct { Follow bool `json:"follow"` } // where is the address the handler was asked at. type where struct { Address string `json:"address"` ID string `json:"id"` } // tail is the shape a service takes when it forwards what it was asked for: a // BOUND METHOD registered directly, reading its own address from the context. type tail struct{} // Livetail streams matching records as they arrive. func (tail) Livetail(ctx context.Context, _ *tailIn) (*where, error) { op, ok := zip.OpOf(ctx) if !ok { return &where{Address: "", ID: "no operation"}, nil } return &where{Address: op.Path, ID: op.OperationID}, nil } func addressAt(t *testing.T, app *zip.App, path string) where { t.Helper() resp, err := app.Test(httptest.NewRequest("GET", path, nil)) if err != nil { t.Fatalf("%s: %v", path, err) } defer func() { _ = resp.Body.Close() }() if resp.StatusCode != 200 { t.Fatalf("%s: status %d", path, resp.StatusCode) } var w where if err := json.NewDecoder(resp.Body).Decode(&w); err != nil { t.Fatalf("%s: %v", path, err) } return w } // A HANDLER IS TOLD THE ADDRESS IT WAS ASKED AT, and the registration stays the // bound method — no closure, no factory, nothing between the source and the // projections that read it. // // This is what a registration-time wrapper was for: the address was composed by // hand and threaded in, which made every such op invisible to cmd/zipdoc, // because a registration made inside a helper is not a registration this pass // can see. Reading it from the context leaves the declaration direct. func TestOpOf_IsTheAddressTheHandlerWasAskedAt(t *testing.T) { app := zip.New(zip.Config{AppName: "o11y", DisableStartupMessage: true}) app.Group("/v1/o11y").Get("/logs/livetail", tail{}.Livetail) if got := addressAt(t, app, "/v1/o11y/logs/livetail").Address; got != "/v1/o11y/logs/livetail" { t.Errorf("address = %q, want the composed path", got) } // And the op is in the registry under that address, so what the handler reads // and what the document publishes are the same string. var addrs []string for _, op := range app.Manifest().Ops { addrs = append(addrs, op.Method+" "+op.Path) } sort.Strings(addrs) if len(addrs) != 1 || addrs[0] != "GET /v1/o11y/logs/livetail" { t.Errorf("registry = %v, want the one op at the address the handler reads", addrs) } } // ONE HANDLER, TWO ADDRESSES. A definition composed under two hosts answers at // both, and each call is told where IT was asked — which is the whole reason // this is a property of the call and not something a group could hand out when // it was declared. func TestOpOf_ADefinitionComposedTwiceAnswersAtBoth(t *testing.T) { child := zip.New(zip.Config{AppName: "tail", DisableStartupMessage: true}) child.Get("/livetail", tail{}.Livetail) host := zip.New(zip.Config{AppName: "host", DisableStartupMessage: true}) host.Group("/east").Use(child) host.Group("/west").Use(child) if err := host.Build(); err != nil { t.Fatalf("Build: %v", err) } if got := addressAt(t, host, "/east/livetail").Address; got != "/east/livetail" { t.Errorf("east address = %q", got) } if got := addressAt(t, host, "/west/livetail").Address; got != "/west/livetail" { t.Errorf("west address = %q — one handler, and each call is told its own", got) } } // Called directly rather than through the declaration that registered it, there // is no operation, and saying so beats guessing an address. func TestOpOf_SaysWhenThereIsNoOperation(t *testing.T) { w, err := tail{}.Livetail(context.Background(), &tailIn{}) if err != nil { t.Fatal(err) } if w.Address != "" { t.Errorf("address = %q, want empty outside a registration", w.Address) } } V xYn->tdK:*XNl@@&3\ɍ;۝Y2t"EߡGɓ;3ԒqEܹ{[0] 媱WQf]o [Dz^S_L6˩iU(]æ˻l0 Qqu\F/&ONO?S UY+[TXc+w?[vUδt6uxit5z}'WƷe KiuKJJMmڱ jM7ʂayU9[F:UmGg:fY3 |ZM=klYB\+.йmWڗ͌~ TqLSԨZLM8: A^QRmv_OnLo^+4FXV}iռ ye *D\ѵOUkJoV-V$ƨѓb+xՈf[B0i+D(Hdu,hNL.[["܌,b;2;rZR"vfne3ީ~׿ynՎbzh'D\3(jf/t᫭qM!'2+GHAmx,e5ۉSv#ȡ }Bw0 ouSO+{K\/ [#F~XToܱj`9`FoaH̎0 C1c\4EE  %LR*K nHᅼ /_+nYqpz1\װ XT#,"H̀ 0 ռCi ᾋĒ^! IT%b[gK -ËK3] z= RV.a ])$ H?k)j¨X>;ũo+^3 =Y8ㆽܣ|w2?( FoeS?Zdy ;,nJsj};d=knx݀C*l5ε; CW,(PW >!Hu@NBMTLta Z>&"1dئQ6"SסzH8gԌڂ_]Is2K5#Ds]V? %ͩP%rR^<ER:0=<KUIwIJ\c~Pض5RK"jO. YIXRՏrg_A5.ҠGZa4B@ze|ߵѝj~IOjzț2mEar`%tpv?_-e*f+ TgpL:o%<*^Sx CIG+Prh8SS*t+i35@:2*5O/ʖȑM0 jɪ]7 U`"f:5`W%75,:<$_P?^09LAyxGbWf3|*G YdK|Ǘr۳1w\´+y!k.K] LyAZHmQ$QDLrfNZD[*A%O@.YýՖ BUck՚ص\pݘb Y0N,*5F ݯ 2QPk*)YF,|W?KA42ȡC@60YJ^);SLFA6EaDT#m°tˆaTzʡ9z3D&!aDHE~ n9}уɍl'%z#IԻB3P<003֋HU7;o=z[ ̵!'Z(DaV#1P!ࡺ9bSJi5Yt2 ir# MȐ@zZ7'~FχOUpGm ٧qoM Zi/#`r ѿe@So~ǘ\ GXA$??y[T%^L<Z?B"n%ފ_M 'oAh>GQ  m'2O s~~=,|ڏY>- fi\ : `/"£K;\ ҡF/3w̵}9?BCS4c{s& ~qdǺxa?8l@;\ZaSpEnf G g"PnO xeSn[EV!50"?nW YMU@(/Pϙc$i@7 @HH<71>I|3}ߜo?oTJ* :9<(ͩF&R 29Fk"B B4*']SL@mYȰBlJ1+i* 1bNFyDZ)81GLd&㞕tTx2:Eaoa`pg?nwQ {;B2ҽp>c2ݱL&h]e &JL/8B&NhI nɘ1 fDjg=(JpG\IT BŐ") $=T#*Ǻg$З5IZqޛb1">ކO\O՟Շ7S0b"* j;[W 6ym'x ZOW |s6C}_H'tP 6!n(,+w!"2gü`ID4eFBљ=kGFHaDFrlbGY#!& 4LʋZ'C˧weT̲e^hNPAFhpgOc[c`K~N= y;qм??k1˖l^?mU u|w]ybIw2$L(i3H<2BNhm7ަD팍Ls%:Qr~fCJ@xS=o@-h8!h&.H"@AA)(\ {gr~G5_/af>vg޼ק{RlEx&]eii-J9mO~?S8+` *WϯukP9@,kɄBhZ67E% l:VzhW|PGEz[O*L%Qս^wu RPe;Ja3AGcͷ;̥K +6fQ(tk: a*R׭MȎp݊T/y3AFS$:0ɐ4#I\m{%rUpӪ70 G)7Ю V%ņ< DžclJkzap/U _AOC9V<#2cє"Ǎ`\pgfB%՝!k-G! G+X\n-ѐ\H+f1iB I}Co`gRFы!a@ E"O>}[w3v.d/8Ѓh"KwJ9Z}||Z4091H+Rfg &RwgYk"/}gd_jxYn->d5͐+%9[@@Ʌ3YQ#w{Q$Ι )ŕ .8jw̹~;\rć4?wʺN']pيbrSCʅÅs9=[Wzn9yE9f9 83!Q lɭe1RLO,NiU +å‰f6nHX^N4w_H@*|N/UEOa+l8WWmtf 9vl& H~zuxl{l+fRx^g & /0{.]8ԗ}aM|g;dnZFxѳt[{yF.X{Q R+8Y2E@ǰT%Iqk?p<󱈮ic샿 wNrUH}|eS/녃ĹXL-=q@gJ2ޒ0Y.1+XCAZva=$>$㎔TY238 !5 |E}\_=V/zqMgIާa-GK3^I'{]l[hŸy޺-rTDMu)Ny~]bYZkM-wj>ΪR%d5zc )X?g8@ z((L DMں`a7[uI;D#+:UX*eDaK %8"{E,ld,Ps|4- Q hդK\,#&+6WgcA|SR愶qVo}V ͋LvI[do3*O.SkIl${C,Ykr5`s%/6XVl|2"RE8IQr29| Ubo\ܿ*0ᖤI}I'TfwaIaSct9N@ruqH4,%qEc`ifI ᛲ(N^L 2]-x-H_Niӛ~:<|Q\Q xU!@Dƾ8,%@2<{B]J%VWhw>=^?{G<7K{@ Fm4GtMAw.TUt60MFv <̐Z,;\3(VѰŲ ?2g+fySL8m|$?B: WLbBi?굡 Z{:c Z1V,o҃$=q5QNcE@%I@WZ"5Ե4߽h#=_j#C5j+B6HwQo4'%(ԕ^P7ߥo]p)3p@6@̲)G H|zA%5*بcc;aWGMiD@9QΑh$$α4r82jܰ_.*~#< ڗ!$M c+dG'E-<\:TKdFy_\yŠ8RYBhYݗzǑ:m‚l$l[t m8L (XB-e?NN>[YG3UDz{&c`9ڀO6OU[9)0q$Q=BTU\)tU2Wqz[+b1Ve2e4kJX2'̰HK ,2k.ʼ̀/G6ŌiQ_jҺut 7 }Q_,?fP6QR2+R /j~)޴} ~QšhlQ =P8.VI rSpCQ$+`T`(s蠓n >b1DКl7! *{W4^N(: 9Id80D ~㘿 s<(0C@ZSə=ju Piʏۯ /4Ȫ2#C>,ݸj} RGGCjBn хԡ|-LFV͍\ 9KjI 0;X_xL }h!5Ek0̍MIOUf z2Ur݇%|oK:JdxUcxUϣ3.@3⦹),kw᷷|XI9EQݸbDw~ͻTUGwk:Es}q_lֆfnURyt@,=9Qt 1e׾1l&2@cɧAk &Pw:fAX.uB6eO_ElIH隷mD Mym%lӤpw )mH%i.5f{Y֭W5++>W;zܻx package zip import ( "context" "testing" ) type prefixIn struct{} type prefixOut struct{ OK bool } func prefixHandler(context.Context, *prefixIn) (*prefixOut, error) { return &prefixOut{true}, nil } // TestTypedOpOnGroupIsServedAtTheComposedAddress pins the guarantee that matters // to every consumer: whatever address the router serves, the declaration names. // // The two are computed by DIFFERENT code paths — materialise walks the // composition tree, composeOps recomputes each op's absolute path with o.abs — // and nothing in the type system forces them to agree. This is the assertion that // does. func TestTypedOpOnGroupIsServedAtTheComposedAddress(t *testing.T) { app := New(Config{DisableStartupMessage: true}) billing := app.Group("/v1").Group("/billing") billing.Post("/deposit", prefixHandler) var patterns []string for _, r := range app.Declaration().Routes { if r.Op != "" { patterns = append(patterns, r.Method+" "+r.Pattern) } } want := "POST /v1/billing/deposit" for _, p := range patterns { if p == want { return } } t.Fatalf("typed op routes = %v, want one to be %q", patterns, want) } // TestOpScopePrefixIsNotAnAbsoluteAddress documents WHY a decorator cannot ask a // Router "what is your prefix?" and get a URL back — the question has no answer // at registration time. // // zip's model is composition: the same definition can be included at more than // one site, so a group has no single absolute prefix until a build resolves the // tree. OpScope is a REGISTRATION-time value, so its Prefix is the local join // only; the absolute address is recomputed per occurrence at compose time // (composeOps → o.abs). // // This is the fact that broke hanzoai/commerce's groupPrefix, which read // r.Fiber().(*fiber.Group).Prefix. That worked only because fiber flattened a // group into one prefix at declaration — an approximation that silently becomes // wrong the moment a definition is composed twice. A consumer that needs the // address a route is SERVED at must read it from the declaration, after // composition, not from the router it registered on. func TestOpScopePrefixIsNotAnAbsoluteAddress(t *testing.T) { app := New(Config{DisableStartupMessage: true}) if got := app.opScope().Prefix; got != "" { t.Errorf("root scope prefix = %q, want empty", got) } // A group knows the leaf it was declared with, not where it will be served. billing := app.Group("/v1").Group("/billing") billing.Post("/deposit", prefixHandler) // …and the served address is nonetheless correct, because composition — not // the scope — is what resolves it. found := false for _, r := range app.Declaration().Routes { if r.Pattern == "/v1/billing/deposit" { found = true } } if !found { t.Fatal("the composed route should be served at /v1/billing/deposit") } } /ճx,package zip_test import ( "context" "encoding/json" "strings" "testing" "github.com/zap-proto/zip" ) // The status a successful op answers with is part of its CONTRACT, so it is // declared on the op and projected from the registry like everything else. Before // WithStatus, zip wrote 200 (204 for a nil Out) and had no vocabulary for // anything else, so a service that answers 201 Created had to reach around the // framework and set it per request — a side channel that no projection could // see. The document said 200, every generated SDK said 200, and the wire said // 201. type mkIn struct { Name string `json:"name"` } type mkOut struct { ID string `json:"id"` } func mk(_ context.Context, in *mkIn) (*mkOut, error) { return &mkOut{ID: in.Name}, nil } func nilOut(context.Context, *mkIn) (*mkOut, error) { return nil, nil } // respOf reads the one responses entry an op declares: its code and description. func respOf(t *testing.T, a *zip.App, path, method string) (string, map[string]any) { t.Helper() paths, _ := a.OpenAPISpec()["paths"].(map[string]map[string]any) item, ok := paths[path] if !ok { t.Fatalf("no path %q in the document", path) } op, _ := item[method].(map[string]any) resp, _ := op["responses"].(map[string]any) delete(resp, "default") // the refusal every op publishes; this reads the success if len(resp) != 1 { t.Fatalf("responses = %v, want exactly one declared status", resp) } for code, body := range resp { b, _ := body.(map[string]any) return code, b } return "", nil } // The declared status reaches the WIRE. func TestWithStatus_ReachesTheWire(t *testing.T) { a := zip.New(zip.Config{AppName: "st", DisableStartupMessage: true}) a.Post("/v1/st/things", mk, zip.WithStatus(201)) code, body := call2(t, a, "POST", "/v1/st/things", `{"name":"x"}`) if code != 201 { t.Fatalf("status = %d, want 201", code) } if !strings.Contains(body, `"id":"x"`) { t.Errorf("body = %s, want the handler's result — a status must not cost the body", body) } } // …and the DOCUMENT, which is the whole point. A status that only changed the // wire would be a prettier side channel, not a contract: an SDK generated from a // document that says 200 treats a 201 as unexpected. func TestWithStatus_ReachesTheDocument(t *testing.T) { a := zip.New(zip.Config{AppName: "st", DisableStartupMessage: true}) a.Post("/v1/st/things", mk, zip.WithStatus(201)) code, body := respOf(t, a, "/v1/st/things", "post") if code != "201" { t.Fatalf("responses key = %q, want %q", code, "201") } if body["description"] != "created" { t.Errorf("description = %v, want the reason phrase", body["description"]) } // The schema still rides along: a 201 describes its body like a 200 does. content, _ := body["content"].(map[string]any) media, _ := content["application/json"].(map[string]any) if _, ok := media["schema"]; !ok { t.Errorf("201 carries no schema; content = %v", content) } } // A void op keeps the status it declared rather than falling back to 204: the // declaration is what the caller was promised. func TestWithStatus_NilOutKeepsTheDeclaredStatus(t *testing.T) { a := zip.New(zip.Config{AppName: "st", DisableStartupMessage: true}) a.Post("/v1/st/jobs", nilOut, zip.WithStatus(202)) if code, body := call2(t, a, "POST", "/v1/st/jobs", `{"name":"x"}`); code != 202 || strings.TrimSpace(body) != "" { t.Fatalf("status = %d body = %q, want 202 with no body", code, body) } if code, resp := respOf(t, a, "/v1/st/jobs", "post"); code != "202" || resp["description"] != "accepted" { t.Errorf("document says %q %v, want 202 accepted", code, resp["description"]) } } // Nothing changes for an op that declares no status — the defaults are the // defaults, and a document that never asked for this does not churn. func TestWithStatus_DefaultsAreUnchanged(t *testing.T) { a := zip.New(zip.Config{AppName: "st", DisableStartupMessage: true}) a.Post("/v1/st/plain", mk) a.Post("/v1/st/void", nilOut) if code, _ := call2(t, a, "POST", "/v1/st/plain", `{"name":"x"}`); code != 200 { t.Errorf("status = %d, want the 200 default", code) } if code, _ := call2(t, a, "POST", "/v1/st/void", `{"name":"x"}`); code != 204 { t.Errorf("status = %d, want the 204 a nil Out has always meant", code) } if code, resp := respOf(t, a, "/v1/st/plain", "post"); code != "200" || resp["description"] != "ok" { t.Errorf("document says %q %v, want 200 ok", code, resp["description"]) } } // DOCTRINE CHANGED. WithStatus used to refuse every non-2xx at declaration, on // the grounds that an error status is the error a handler returns and two places // for one fact are free to disagree. // // That held while an op's only way to answer a failure was the standard // {status, code, error} envelope. It stopped holding for an op whose failure // carries a TYPED BODY the envelope cannot express — a 409 with the conflicting // record, a 404 with what was searched for. Refusing those forced a hand-rolled // middleware to write the status, which is the invisible side channel this // package keeps closing. // // So a declared non-2xx is now accepted, and the doctrine survives where it was // actually load-bearing: an error RETURN still renders the envelope, and that is // still the way to answer a failure that has nothing extra to say. What is // refused is only what was never an HTTP status. func TestWithStatus_AcceptsADeclaredNonSuccessCode(t *testing.T) { for _, code := range []int{404, 409, 302} { func() { defer func() { if r := recover(); r != nil { t.Errorf("WithStatus(%d) was refused: %v — an op may answer a failure with its own typed body", code, r) } }() zip.WithStatus(code) }() } // Still refused: not an HTTP status at all. for _, code := range []int{0, 99, 600} { func() { defer func() { if recover() == nil { t.Errorf("WithStatus(%d) was accepted; that is not an HTTP status", code) } }() zip.WithStatus(code) }() } } // The status is an HTTP notion, so the projections that are not HTTP are // untouched: an MCP tools/call still answers with the op's result. func TestWithStatus_MCPIsUnaffected(t *testing.T) { a := zip.New(zip.Config{AppName: "st", DisableStartupMessage: true}) a.Post("/v1/st/things", mk, zip.WithStatus(201), zip.WithOperationID("st_make")) if err := a.Build(); err != nil { t.Fatalf("Build: %v", err) } code, body := call2(t, a, "POST", "/mcp", `{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"st_make","arguments":{"name":"x"}}}`) if code != 200 { t.Fatalf("mcp status = %d, want 200 — JSON-RPC carries its own outcome", code) } var res struct { Result struct { Content []struct{ Text string } `json:"content"` IsError bool `json:"isError"` } `json:"result"` } if err := json.Unmarshal([]byte(body), &res); err != nil { t.Fatalf("mcp body not json: %v — %s", err, body) } if res.Result.IsError || len(res.Result.Content) == 0 || !strings.Contains(res.Result.Content[0].Text, `"id":"x"`) { t.Fatalf("mcp result = %+v, want the op's own output", res.Result) } } n xZRbnHz}?"Ǖ g*gWsaw6f:̩*7ɓ랙ݕw>'(_PJ^*1>Xez>ڊZڪmG24 =%;@t"OKDT k2n)q&S#JwҨ :VPbv*^k>@`NOdm؈| ByNN,kK|{.Rt"VȢ)hE:Uу_*m5*k"n1K32aŏ.ō,JHLrZd` By:Ӹ]g`T+^kc|$k91Ps-z3Ata ‚t<]TNH/67:GHPv&9XI+.R'J~%Lo:޸{=Z(ni =i'caQ-UJJeX]:&;ܣe&2)>:y?s dae4?Ɋ$(/]ȵ'&]';OGLJGǧYv,==8JoxwL@=Cd+M.7>+uTQj;NQu5%3Fk. yDjҚ9j9>l+i hI1F %l`F7(DIȨYiӟfVFO/3`h/Gh6qT?:#?fl\lT <32)"+77-"H&kr|x}rV3$V*4O?1ҥckV f .&)O%+/4fjva-rB-l>#&1_ؚ(In Q]N _ԭq,1898YD~j[TLbDYUm]CѝyiǥKߊ cGf Bۚ U3?9[1%bZ$h#`P^Ak>"?X|!Ũ mMx e 1ކ%- }Y$Zf@L-\Sܪ'nKs V&)ȑ:ظ҈t/Vw.m,P~h_t990 `ut˝'Q~ sjA.mZڋFr@_,{羃L;:4މ+bc22R\ gehLj"CgZҸgIק%u !7n(4#ߑ[xv1:ZuJwB gڀ4_9Kaש2tv~!NJE$^ /r1w "QPn;Eq_MokRo81;|za<1{Jr֓&|TZJgPUobt H FrB͂$C)g i`e .]Bwn2ۯ|7Ύjs\2FDB ;٤N0~W'_~մ#l|XiE rD gJ.'NX]k'3}YgϠjzx?x.sCw_TtY@"9)0yTnؼoqscC/^ٹ6t]C#@=Ry[uZ,_~&DN~uDy͍0Ա"U15oܓ(#*}v\5&Bq1=M'w^NxMv!q. O&BetA{Ki *k/%`m0)ñg%Go g`ڸ÷zR _r1}Bcz`o6Iu ?YoQLM[˅;Ǿ+ MN {P0 s smhB6v~G+z6-mWxoIJx}Vn6}bڭ Ph]EܐAhil Hv#J^'hE gΜ9tg'eTww[1{ ߘ?"gL}u ~HSm(uɁ?@:#8!h5 筄xrq]m QKF(N˟NNNx_V ob 5lW;Rk*Ld/5)7@Dtf E=p+dxZ^rbZne+|y$W8$l]UNgc%I=c2 o5LncyI tB:$X0e9-a'{o-WVE2r5-Ž~*[$uRC$ٛ`C0m@XF")3d0Ï"+Ji$;r)b6ixxB|)W`p-Rt{z 8Rߡ`'txdUڄ֩:7*&1HrcNPUPASGK@DOmŁ$@I r#b)"N1t+I'wPyw]1Щ҄>*(@(Kjfj.Y%2U`yn/Ɗ2 Ym[< >H;9-xLL"X#3c})n[K'R,F8UΌzt5O\y\f[÷xTMoL>ۿbj.驇RQ hK]kwߙu!E|<3tW3 ?Lw:`ywFEժ/j\ İJ,;Z-8;(&WZ{Qu$!Mk @CЁ)4*unLTtv! (>*0Vד5uXӅz;^{7i`G}MUO<3>"M֨CNCl\G̳J\g p4VJ;/&^[xV౤"WF.JR]NE `Mۗ&t'jNaً\2/(sd]fJa3db)e~ \{COcs,j ;"+^EZ3}*/7%_cNr*┑r®i3XչBĤGO/G<1B:KX*Q, 84-1*aw >3NPG<;ohj'-q-i7]4ъق uqw KZY s7reRbòіP3uV??E@qE1unK+KL)yW=PV36QZeY QpL?GL2id8~`QuцU$OK-c%{-6&EaƖ1 ^@~GItp ܌| i Ψ)7Fx) B|wP6m[ ~ȣFmz酄ƽxW]o6}~ŭrP!]6 HSaRZ$"0__sIvk_b["y~ѝ(E-D-:c=e$uުv)\{<ޥ4IC+HTiU7>j'|CVEE/g ܚdJ`/=z8Fz=K kj. {W}tHFܺ;.ɴzMr)-r 8g 9\]7#2X$᱕*Iշw\P>'9}J{%}c: ?hVgfJZc3E&B~<9pbJP OwR4Sgᅮ4:%,b6I2#.!1x(N&dPiR ｘoPʦNZzsgPrvDp?fL(d:Ӑd>1f6W(UnktL43 ,6Ǯ !#|-dc2u]>ةrʼn4 {Hȟ պ,`kN9vTxZ]nhGjc3B`M8Jf!ܜGiVVavZVA|ܨ=mi.z0חn c{ 7<t zO;vMA ,ZImb”rH(lN c`lEsG@ʎA.2Lp.[Fl;Pm$FY1-R!-<$o0-@+ǀ5F9 yʈ_!9C=U4X7q!r+a),0q'C|q:ɪu|hGqi7Ih>0Zx mE#v;A_zxkpackage zip_test // What a plugin costs per request. // // Running a service as its own binary buys independent build, release, restart // and measurement — and charges a hop for it. This benchmark prices that hop by // serving the SAME route two ways through the same host: once by a handler // linked into the host, once by a child process the host reaches over its unix // socket. Everything else is held equal, so the delta IS the hop. // // It exists because the trade is only decidable with the number in hand. A hop // that is small against a real handler's work is a deployment decision; one that // is large is an architecture constraint, and the two look identical in prose. // // Run one round per process and take the minimum across rounds, so A and B // interleave under drifting load instead of A running entirely before B: // // for i in $(seq 8); do // go test -run='^$' -bench=Benchmark_PluginHop -benchmem -count=1 -benchtime=3000x . // done // // Numbers and methodology: BENCHMARKS.md §3. import ( "testing" "github.com/zap-proto/zip" ) // Benchmark_PluginHop compares a linked-in route against the same route served // by a loaded plugin. Both dispatch through app.Fiber().Handler() on a reused // *fasthttp.RequestCtx, the same idiom as Benchmark_ZipTax, so neither side pays // net/http↔fasthttp conversion. func Benchmark_PluginHop(b *testing.B) { bin := buildPlugin(b, "v1") // The linked-in baseline answers byte-for-byte what the plugin answers, so // the only difference under test is where the handler runs. linked := zip.New(benchConfig()) linked.Raw("GET", "/v1/demo/version", func(c *zip.Ctx) error { return c.JSON(200, map[string]string{"version": "v1"}) }) host := zip.New(benchConfig()) host.Use(must(zip.Load(zip.Plugin{Name: "demo", Bin: bin}, "/v1/demo"))) defer func() { _ = host.Shutdown() }() for _, tc := range []struct { name string app *zip.App }{{"linked", linked}, {"plugin", host}} { h := tc.app.Fiber().Handler() b.Run(tc.name, func(b *testing.B) { fctx := getFctx("/v1/demo/version") b.ReportAllocs() b.ResetTimer() for i := 0; i < b.N; i++ { fctx.ResetUserValues() h(fctx) } }) } } D_ExSMo0=Ő &-.RAHU bdؑ?,BX7oeA oxw7bbL6J6+-h5)3VۼjCIga䮻B C,nFT.}PNs\(4/-tѸz4MAo:J\ȋCmp 6Yc?(n]mbGLlCyii'Hu f[n +H߼u8 r=_ vU|"ZJ+5aPp+pYCD:o3Ar)4%`˥MUN w l&`%$<>TG+8Ygs@c`m38̼h'M!i^FE<(H ^$¿)iJB̲*cɮ A^|PyL6~\tOmSE-T9^./P, ZmOxxUQo0~n~a NMn=V`ĦP&jj)sv- և6}}k=VѨYwy$+kywuw\$fivΔ_ נh|-Ǯ=讨nq!R+vix|U.=9,[jذҩϞ}遵jZo&,AE'>*FSgyA];=NSS F(mz"Q5qR)+֑Ց-rE[L)wp ۔=(|]ߚ+nk5 1%Ҩa(w ZeY0u2HuR:OL|GYAawvZѐs^_|Ǔ54T>Ӆ,)ɳfi[)gTqTPE3Il÷6 h86djŽZGw$EVɽdVPx-10{Œ*{j4<؇9-' -F3\å%'Q%9Lϧ#dAqccn$+B2mUaHזlÿ,$'Vٛ>!(C1xUR@=OE22dgtw <I*tdT/٪W@zK~3f6GJ YT}b1K+MoE7PW܍ Zv] L>(0}lPWiN(5-U/tީDi2VgMMͣ[SWGTMK.̣dg0ǥ6-*]U`khU~Ou]J mhfIVu\`< -gӗLxzt~~xCϓ~x9=I?l շOFYQ0Jk5}}T^bOi%fY̥ &Ƞ+6\[_dje2U)!,sںb;ֻbR]U[\+Zx5_[@®|_AL]e6ǒ2oYڬqyWW3ҳUex+e>ܒ56ޘ`7J >UʭHYenp(KSl6]D *JgqCJ'?~7 Y  $^<q YU;5sh5sMu ɴߥ$OOX_jkAJ %ۂCpV0*عt .yFVVb#$ݰN|se>$#\TH6*u4Y{eWu߾f>y*ɱP aL.@/uOgjb=dcvTsy uZkQ*P`ϕHUZqd3零(_VPyuȶBSNӊT=ߐ@r.kB'}6VT$H853G*RKLX9sjjoF^+MUo`ar,CEِo/(*5,V*( 3&5ΟM_.7J-(5i 'Z@cRtlEr4^`6Y۴8:͉"Ш^N* +9#0p A8uګ>̛"U#BJ8h p ӇE{nt)F&9`4~t >5mAII X^"׃VJ>aSdZ\0g[&5~W[L_ԑn#3=x虧~4lwYV۸)֞d1 |6 Jzw/dK"%,rW&VLrg""^vvJJqix%UQ֩kS{En|MyF|T;KrV$g|92!_߅5_a !?d_&o75+`}}$=ų^ti-G<].k둒î.SDd7m]v:yz"9ؚǮ 6!`p"SP1"(\T4{idsFn|~ I`[Ki@|c_[ROWYWvB1@?zCzCjA.4Ja݇G>8? 91>蘷Wx/~MtUjifo{j疚dž#MQ` %3-dUu/t-l$ .Focג7Y26tOPp3oSxX$"T[]P@J0E Rqaw!!Fû]g띝yXnS߆AAwCw qZGNJW8Z! @>Yc:p{5+ݘATQ)$14LjE5DIl@TľZ_,rtY7:+1:<|D5%,1讑^ɘ914JI=0JÚOq8ҙFRЯT X4yeP )9y4N^CKuHAAL3x;xaK&"E7w;Lk:jٖGM'8,hyTK(H?Z{Ìᦽ:pJqDPJLWn Y^[Y4IuCeO!#!Wk])=&cW?w?~.4&EpQΝ&ܽ; ("l6Ga&'Ɖraƌ ZD0o;Q|^DjΡf/[><(y wŷWKm}NsރD80JËacY:4;ȋC /N=SjkÍHSwwY{k_81q0*̍LE$d!h~\e2Q㈑0HX@eE .Na6L!\*&r -w'wd4oޤ'BadJJœ[܅'lRaS6-}J]3S*]t`%]ΗtKye-֠W2.a3p;8qFl⬁CD~~S5:. *;iR3Ҵ*8 oker|~BW{&v7!ǵO%4_//*aJVL[z7"\M=Dqp>Wg5p6Vb? Exwbe%i-8ZPy>,$Z$9f u?rE|"aoxPyw-ǭ{ם$q.M*U3SXere*gF/Sw1>2l@Uծ0cy|tZյ*tY8T+S^+ҏ9%q%? JW)k#k dǵG,<3'ْb\TStnsԝZ}pP߁a(v<1NLvT;Oxf"*Qxg_ު#loʔ:xdk3;7UYb|2ǽa+]+\N ?o ,hZp;-rqEZÓ ܢ005.iT@|idtVF9^hNЭǐAcMJ^'?Wyn($C:&/N;3:KMˀN@ШY&i贫D56rI<ԖT B|Ni[oa ;z`xx씩5?|J\ON*Nzx+/zt[&x 8E^@`-#")kIv$pQƢ Ẁ/ :mGiEb5̂$kZ;%#޶wyeGv '?`cuJ)EyS0Ώ3uꙺ1år ZKѓ%eP&? YIHux pp4tR#/~RMGV|s51࿼jcpGnONgBKz - j@)lOa`W^%u*}oٌɣ4GpyGfƦI7F|f6HYZߓ"zZZIx+ʝNOמn߃U  V(ya_4 vt`kGAgAJzh,kP!0ПML3VpG.abQ$:';[mgrx)y;N1To1 {>WoX$4 DISb^5;3!w|762`\TOΟ7a_~5~%@ݴ_>.[-}E(nUd2gAyE*k+` -sP6qbnih)zgsQT :,Ԅ I p~F` a!Յ `cK2&Pv,R Ϥ CSKs$jҬpuD"H1&`O,li cO [vUK2as|4}h~UmrTa^l+Kq m>/zaއ'+O.?بؖQ\$Isz- O4饅PNtKϷa b=S뚤fo U( aFjٓ%$}&PATrٟiӓTMT)sz'{8q%Mrn?HKpc 3̤C5p1 #2`wXFvfѯŁc.ܱۧb .DRQ3N pJ 6iDl΀̮T LK &F ula)8-S>'85\oPJ|9 )j,U';׻=, !6\ɉL,Ma 9ҾRJ u|qWщ Y쇳U^Inm*oR-6÷j6#:Do?*VwK[xf4d;]w5yB#]dWY&$F3XʤB xޘe}(+Ls텮7mJ+ta2" 4k,+,ZZ.3H0&6i=a&ɒ֒ҫm#]wq+@O=h9i~;{/#Uxo2nN~r-ҋpL4M1k6-\d1?4°DSr >#GK* W'>1 tB8n|mk5 5tyȋwY}ƔL6K47b0Eo$w&!V؜;k}K \M|f]W H eP2|\+Ʌ tյV@}~^4:[۷K0i0'>@4DE |4?b鏍BǛ·DL^r/grC'g,l^̔% =[$#ɦlWhngތJ?=;M >Kq]'2n/8'{jV]?7-^FJ6uI`Yٞ!,`q~ ĊhW% 7`qϕ+Δچ ߩ%Msݴ \)wN<S!p)bzK~QZO@nInKyÖԦwKKG[!yǣ !Q/ߜ~V?'?7Q(^I_HJ6bq(d@K.st/)[zUtz➵x~$0 KMow#y 2TJ% *7w?|$(R{#@),*t| 1S D$oҔJy`ZrwI"V:i^յMu&,=K)2ozK{\su>Odlj*= ϿxMW#FT: iƝ!3ȩ.FT [P0@,m"bc3G`/PXFɳk %?8 S?$*S#A88躞$Xrm>9#Wv|_85/q--[bH?Lbۿ&xMrs  Raw("GET", p^ Raw("PUT", p^Raw("GET", "/panic Raw("GET", "/capped%Eqapp.OAuth() oauth.Raw("POST", Raw(*}3 auth.OAuth() oauth.Raw("POST", +app.OAuth().Group("/v1/oauth").Raw("POST", "Fapp.OAuth().Post(&'app.Post("/v1/things", ok) app.OAuth()i/ Raw("GET", 7Raw(7-79ex\nF-=E1pqA(ˉc[,vY&mWc`bpdsbͶ.6Db]N:u_櫯|*[آOR[2񷏟/W_eUkg'|WInl_y5?4֚ve2˭yuśfY&gڴ^7a,'WVf몬25e1A:`lEY|_1CZ+Wu.ڬ,%)KȖi/MV4tp%kZ$kkrYCf?ų']\Fۋ̛K)QzotImANfYk0fQgqj X5)vc+ŶOs+5%iMnUbp0N/4tY%x똥RorM4mMRUSƔ7m{m,9{ăʂY9͂1d`YݴjmU'_:ŴȐYdA/?.dr;m7up`{am*n|czGp\'N-ű]6Y3o78QbU FXFIqM~aم9ȁٝɮi{y\`7fwaryn!N;I'G'>9D]GwqxEOp&4hHJ-M{v'E9p4"nf̓mI2agp-Pt 3iIa5hX~R$;[ODX| }=U^xm2Xa&)Aϒ׶iÉn˲c{2rLem덍dڢqg{EIĒfc 9+d_~l6S9񨻡~lETDZɧvy E<%KzeJ<#1A=5wyas/0AgJ&<~:@,Zi:ޓ%$bE3V H@$2wFs?oi&(_7A6D8كwQm%P8Y~(#&eoĘw$ZY&aL}g'^!uO?%Ud=_Jρ(V dʉ@C;U,; 7.e\ȸ7Y!#r^,p},R IJ 2P e<%fcQYƘ.g1QpT#M+Ei%߂vx*dKCb׿x:(2@3SAk;9ӹ&v`wWz>RjvJa7ƩR4!6@);@ qǢ,1s5N9U@N}|ҖpJx0csܟ?'i>kYьk57Jw[Ezd>CMyʠ NEnOve39t9uː鱩E$řAkN.MPXo$w5e2d6)h&(ݍi^U;'i;)4Sٕ ERe$GT{e9. וj~FNTaJ/ԹE],1NG?yQ!@~1"aO-U9ʽp B#{Ee7hT4!|Q36yOdX*_3IB9\]yv9/㩫f}vQWԃw2bNA '| 18_*!Fo $ve˛\%(a (=Ks}o}x;=nnNC/طTs@DBO1F=:> |z#*x4p/Ȼ.CDܡP_O#urXwl2b'abKb[3)WF~9'u7AT-VQwfTg* E|'ߟstP,IІ)I$AV(/m^1u4ѵk4+ BE; ØrUrd*+M='u: ȼgUWs9t=1icN$%`2wj?#CX^%WS)qb6u vIf(Ž̙ȄC'=. ԤR~~Na9m8E7`qT "ʧ|BJGgr']0OD9I݄Pg6VΡ&p慖Ya.3IFt(_0;2iMաO|9kLDC/}#Tq%KUkFP_tIO$l \;ylGD̘Xdҏhm 2oX )`ў ߦ7bYKnYj]ӝSk uRA$VLnEʟY"e s3 vYzw}'xˉܨ~1]lHȲ2>.C;iٴ=på\:ݲoKu9-HfQsO][X Qx %hq9:p8ynR.s]":5RJ#{KabH+bt2wq0t:KYuAsUyB96'_g]7!lT_vABDY7pٚpwYIst|!a޸@~k)D+ kÓ&y*垺y̶+GR^JuRݝ=)oYgÅYIMU`.'ϰnlHכ A zjJ._T'sh~MP$n ! SnsN Sbkk.CO鈘Gܱt2h%G7|gKg|\^3Hv I $s:\Vr+]Jru=[R{rUgJsZdy^>:CY3Oji_ 0|fNQ$yY\7Y՟H-?+, <6xFQt3Ӹwu^o/fD}1P_ӈb&geNDQ͊8Mp=KzfJ)ݠ(X+$69O$ #}|nzڡy9'ɘ͗d3 m~ M֜i %cJ.eLil[ 8 >5'+vh"s a<q|j[ܶ ]i,&%]I&QIF7'o11T8@>2H\;@ ]=9^rO˘h&S"3Ȉ^W D׀ق:B8 S:pp7 77Ba],nty}6٠{C,mOhJ}ԤVn<\)%F?Vc" j8Q Ε>㳗eY& \EIJnjgedKN\x/\ƼgRkȅG+5z{aX^v9W I~\}҃|=M*7AAe0s)ÔpݚCyN ǞoK-ItWO!ۺVXXY[fL 9MLZXzJ&)=N5t8o%;(E]#ˎ5Y?g&db:MoS%zAeQTX0}" f]gtPq*+*,Qm79`BCغqԕ4 d/At%Mࡍ_J(^m hZe.,M%E_BFTU/,$k/1hV(*VHGY-,Z-!_xhJ6PY h =ӧTY=1<*ZhD8]//V^bfnÈ/p!}rex?={Cwz NkƻqyHAa8W/&?{UxXr6->RJӉI;:3Y[M=uǛ$(@@FQRCIzHQSw"qq9^\f_\kTzwR(R+78{wddy^%⨪7N/Mg8m?[qZy(FE m}),n<Ҋ,jTZ2rٵ|^/ѕK\Uk GfScDzxT1Ûya^h'e+K*pAB|)J 6Q1WѽRD^dB5mPFxp,Bi륫V۩Jh >4dS>,bA5U*UNW MpZÉfU$TA&fdP/;]s8% @x ?@Ǿc,SC ]syF p~,oG^ȝ VɨP%E5 K ZKfD18ҫh} pOuF4)'%)9|Lњl)މ(ȈufH"Tn8ŧI9Px #C1߯x2xlүÑp5 TRL!)C#$lۤ"q0!7}xSޮ]2i,HUF* *U'¥zkE<tO&:VViG"]C jRYzۧ(>`cʊqy(EB t6ᦽ t$hl4ҕu ǂd(uttu fe@EIBG!>[)Lޏ8 u %1#/y*C&AgZP~65 $Z\Pn@>w`%M4&#P>oVO" 3&zbr%&ˈ|壯=Ϸ4|)t>&؝q{ P03Q 8ΎvoOxXӫ LX+Mrgegxz yAQėW_OT{&\҃y߭FRUa]sO~~ cҎ鰋{vWMx4} Z/ Uo`Tz!:ŋtɘfX<㟧iy SmjTr o_NAtn_Xl;njѷdu"fɗmN%n;|ડn"π9}쇻tZ^PLƯ jݩ4/vjmyۄ >Eԗ'\ar?wA' (vc`bw7%9戼xYmo, 8}>9)Dl 4g#:ޝoF@?%}ff"ID3,_ۉɝy~5HgzI;7$$+1nRْMe&& 3Z8NS5!qtyǙ c3)憍dyZ.BqfL  +çCԇp!JԴ*le`MP y 4%18H!°uS npALԜxQ`#]V+ZsmWzU]!<؁Ϟ}62⁶0_!\LCAkV%<4+\IЕ%|0u'U]uDlMԫ׉ $l{"tV ʻHܩ8C kޤֽFG|__J6 QTk9f\$13"g}';o̍"[C.$9jAӽ8uxYz j0b(YA .An!q(&`_%դZ<͔g'Yd!;_%۔VGGgi2!~%G_>Lge|Vz`'cן_~#e> H]'呹gEBܹ-`q{ `S8( 6?y7]4)[9FRʤH "ٔKw 3CzUFղʐ71< AnxAĥ^eN8DrFXIE=$$t 4>CPߚDBPu6RW+elEI1e'mAbIq% -6lZ;MݳCrCN_T-[C^lQ憄Lvܼ9C>닒X7Rv }⯝$|8Q&򅭧3G)tWs%ً+Cx|C Jx*(;8If׉ ]c[hFs u`Q||&ViSR)yE~/'&aoOMA}/R@Dq4e6WGq3u`z |'V1n ɗ4_GxK[1&Ke:"hqy>h7gcEhLZM61Ee(Ty4zT{1|8%vYQwo!y}:/)]'dGS٤0 ;LdFEeX][4lYJ QMҘoEGlq)&Dw_]t7֫`,NCﵻDAJZsbQOCӓq%KǍџ5ȇ;RޮfEsA6Om6F*89<|<Q9{(= sOW?޺[G4٪GKTڿT=E}:%$-ҹ[uxV\ˢSktB8,*8;puȜ)zj3cn7gŒ'P⮨ NH{h%.{O`i"#pmRPH$i15y$_|aMރ!7 %KXr,Ö2npסg,4 $db~  y''NQYe}cVŢ*fB;P^bXb:[ O^XUq<^O .)#Z"fvL`,,6q(W }Z%`tUxmzCIB+>ħegOg~̗_{.+;t ol˕-'층IQ%}͜0-si>I9f|y޾~sJ O:C034, O} -iA2@2$zcq綋nj^R_bJ6ρ|8t@I IJ l[ُ4Ka*A"X4(VO4:ꔺhd)@>'5!+ڄ2WRtGuJt-vV?)dĕ}`ST>nOOTD=>3Dbjj̵y GzN 7OIB{E?Hyv#+ õmΣ?d4 BzLjp7wvO +7^0 6mBFZvoC͐UT`qG?4Jlzg϶քvCF4~նa!;vڷkےζ֔ήlO ZkjwǶ͖VfG}nܢxVo6l7ƥWGam6$AMKE"Ul7m|%Q̮\']}ʇ~_u~/Q&6?ޚ7#u2~dXfP>8,a ?G#zSgzdPLkspx#!WOY@(٥r$7Z'*J@ ),!M!O0&6+dbuA^dnR('Jʂ^*I`Tć!!' 8 -E h;ԩNA8Yxl \9ER;dSp]9"#6Cn6V?yEdMYX$ d?Jo?٧O j ˆFmԈPeYJY 7e!1>9VOc'Y=š`xK\27܏{ː]5lJ2IsH:T_'tsOB]8VEС8۠xn݈be$@)fwY) YN^~xt6~]ǭG'N{lg3.g9hW*?CU3kT;Os{R#5-̤16/5~lvY$.vKȹ)W=vǎ3Y^ֱ>gA /ji N3h{ܻKXynoo;׸]%Y1F˝ǝ 3i >HL2a fy趿dxNaJb{ u >@u ^DhxPEadBr)v>+9ߥV\"it:Xc&{e^-ݾ| Cάa1ٽ2BlPס&} Xxe?IR΋~XWjݼ7{hB4[tE2I0<"eY5y՜4L}7,ߐi[n5aG9Zߺx 3ݴEPl}|cJAcd@7VRGΙV[`;{,HjթAG*;64-|OxSp3]WsǾ4%`xVmoH9K Lė"T"(p=ڵM]wwJ#/MHS8ƞy噗4"3 I뢨߇3|o= p'GUJQϥ=$)_@H%iUB^J|PY(o0bȆh'EUY,4K[{1RɺBYkKjV jۅ4`o2:bT.v[@׃I)ԵBvz& 8[0FO|Qn2R3\/FIԉs\5rIJ~\($oG<\f\_?Yi}3QnLpk6`issPFZKj //_ǀ/n.6XFc;>sv^ [CB> ,߇T$rV:[?8 l-IGH¬2#8!*#'d.EVWa˃H1ЙڧC!K\y<Ȱ\s<.B 54Ȋ2,+kSb{ѴUJ< ћtlX-`pu.#fooE ؠ| a^aj*mguYT^(!'4i H 9ڍ:Ք~j zu⮇kͷrZMi(4IY-׶=D9mZyXsamL H~D}Wb,C%{B]HǦ 3!^G#]k>F⣽BN$ eWbbdzӐNDvq NhQ/U1+N-Uz=,./g{$%g!7r2MhL مGBIJRo G7] 9ॾ8{%X;p`=$~L7Aos y8g>ձΓM!hbfMAC?g2 (xr_Ijs?P,1շ۱5~3trw4OK>:%-E}\P<'iDA]^O)9Blx0 ڣO  1xZn7z vR*%q8wMR+rQ$͐Zɲ Po)dr.ϔ5+NGS%.*U.ueDfT/BTTe- STy*J%SPsp v,1;R  p#ff ι*yfqPzsZxʱUډIifdJf!ǙNULڕ2qq9mORkS#.3mi<.!DYL1SKLid”Nt;[޻J'&&w~F@fVng\ARK827qbf;AQgvt&N.~*udW&kVULϵPUdc=s S7G`E^YzlsV+#|*W)gT`%2oVjwHKy s8q:X[Զ9%T!T@֪k~fcLgl 3ouv^da,Np2 DHplL@oS*|F&%^+mlLqHYo(P:˼ìf/&*l=rJ+fyF5f <ڰMB9@2;+TQ_%Ssh0D~84evc^Y0/˛`£i#S_0\XISu|V/~xzL(YүLUȵB{$8I)JPxƲvnmkHgY>B|ʑD8E,2\2O>}ͮ{?f<Nye 釻kHoCqp^JD`ooNYDSuAl.{QONZCIhsEG!Y 5xڌxy+|$ND21׌Z$|]̭ LXW<61RIiɅH;&0SRDgdUS,(/!'^ʪ Vx |bS'1[j>G`||; LYE/䷬_!J\&*ݠgiiTĺ2 lc€ rVNEpz݀MȕNkߵYJ ~;}Qys7%idU2#+UQ֟pgZhAs XAS |~Q"Xb_ *7;Mmm />$` 6Qf)λ\^JZéuy59bda ǀYNn*JzIMRͨSTY~.se2S5\<˷/[sNncʺU_zf Y,[q\[ˣ=cnU"+*ؐ[\ 'TQ R}tdc-X }K/گŐj5WOW6HQ?#ОgoOZXGUi)񉙷5%o֒ۏ%(zlq@2nZ^͐o{9EQrW`IA &e6Lf2J~mLhYZ^%95ܗ'ӒeWBO,Owu!bqo:jB|Xs9ZYäݎzѦ ͹ /buנbhD;x$:N)V۔oQt> "1,#OQ*+쉲>i)StIhQ1ʡyZ0bĝ>SKrtZ\ndՉ(N'Rڃ41+S"J_c<ۻ"4e) _׻72I8 7H{yYӄW:G #f ӕg<} 򵭵VVt; Q$XsLLV9F㒆?"*׽<Z"q˳qiA@cG/)+ȱÙzjN'-571ǏER5FO8!(^N߻MIPutcmJ5^YJtkl/( 8l-NS+< vpxZ(jmQZĽ5xv\eUoCs.ښ#-˃d(11F#k.B Z?=|%̘ZTumhه w,_ć0sW:"?,|: ԾM+wh]NtmY$rƻHp4# .QǠ;'j䙄2y&}RGﮯ:sUGy~ge}6/ѭ#މՋk0Jd?9 cL*Y h" e`Wg!ܔ*zǵ>pצ%e^u!NzuϹNmXz{_@ƒyڐ/ ~`mO5w뽩ֲ[`]ͱj7C]?*?xpackage zip import "testing" // A raw route records no registrar — it has a method and a path and nothing // else — so the only way to ask for its prose is by address. cmd/zipdoc files // every entry under the package that declared it, raw routes included, so the // address lookup has to reach a qualified key or a whole service's untyped // half documents as silent. func TestProse_ReachesAQualifiedKey(t *testing.T) { Describe(DocKey("github.com/hanzoai/iam/internal/oidc", "GET", "/v1/iam/whoami"), Doc{Description: "Whoami says which subject the presented credential names."}) summary, description, ok := Prose("GET", "/v1/iam/whoami") if !ok { t.Fatal("a raw route's prose is unreachable by address, so every untyped route documents as undocumented") } if summary != "Whoami says which subject the presented credential names." { t.Fatalf("summary = %q", summary) } if description == "" { t.Fatal("no description") } } // Two packages describing one address is a conflict, not a choice: in one // process one address answers once. Answering with either one would be a guess, // so the address lookup declines and the qualified one still works. func TestProse_DeclinesAnAddressTwoPackagesClaim(t *testing.T) { Describe(DocKey("a/one", "GET", "/v1/contested"), Doc{Description: "One says this."}) Describe(DocKey("b/two", "GET", "/v1/contested"), Doc{Description: "Two says that."}) if _, _, ok := Prose("GET", "/v1/contested"); ok { t.Fatal("answered an address two packages describe differently") } if d, ok := docFor("a/one", "GET", "/v1/contested"); !ok || d.Description != "One says this." { t.Fatalf("the qualified lookup broke: %+v ok=%v", d, ok) } } // An unqualified key still reads, which is what a generated file written // before keys carried a package produces. func TestProse_StillReadsAnUnqualifiedKey(t *testing.T) { Describe("GET /v1/legacy", Doc{Description: "Legacy answers the old way."}) if _, _, ok := Prose("GET", "/v1/legacy"); !ok { t.Fatal("an unqualified key stopped reading") } } ǰw x\rGvM>E/-oeHH"U$֖413)ث֏rB1.~ [_̾ O`w ;wGe1?冿)n?A<>Yz4K㩣H$̍[$,wiխҺp)53h 9[T7fу곦ks'ü*=»IqHy($`Po՗w),A uoy˥<cEe?jBztc}HCs,t^axϥ8/*H6NxV$IdEA4OSᔾo{C-jhH  yvzxnR616+!K3`6X3- ȕ^ŏrL՘@frWʦ/X Y4Kb:8Uo?Q*XUq]jxف~E Oň/ꃯb1vq&s!ҟ@$;±fjʙow]1Y6K$49,y[T# tqFٸa `c\\ZvbȞkKKuv'od1UlvxJO)bMM6ȝrܨ 'Ms[$yv)#E;L'O w&4WnMZaNJXdO5wG 5:}=4.T!230B 쉹<74ZןO}c6M] Ff 4:Żke %?K l<^ /Nɋœ]33 F9R@.E?/towCM(-7K mS9-bb:)b MҫJځuмOm>q!E E)IU^A-//` PQ׺yx=Dzd}`HO|W!߫BsЪK~h1RC"܈\ eJP\bAeZO_`o\~dہ+q dڲL .708 &%S ג3o|AH`1%/,[500Ql.JwQec74a[kZWH|hm7HKPi _4UI7Q䡭vmٳZH>NZ0gUa2j+قoَ7MEoobRYkeC΀׋QZZ7yqb56:6 .T`'Ӡ%{chjH*fgT݃Sppߏ^ˀ75.ۓ(ָ$-eTf 2D2nGzTӓG0H3/j-~%m؁"nJMAccTRmH-r JFd<<-m}yQ߼}wj* ,vd<Ӟy 1ɖ=55܄ d{B6-Bp\oN8a2܋w'Pӷ.Ext&lfO\ Q/}K5`C 4PoekQ4E(ZBi^'K7j%v#,$+]!y)HK𢆷#:c*ZR3ͅX-s 0,ik MjE|%(C^Q*pBv[ >Fh%.$M%Qu\@{ѧnVTn0wc"xӪ?}'p%ZtveLG9M>*ˁ[UzbimlY(6EWU ȨXͅ%%$ɟm*~|v1=n|hzhX4{p|'g B4@3"TG(dyAZ8"K*LNqyyivxrMxV XO1*U-%-i 2hjUh(gZy!o_g:d_ 3e[ZSD:UI|D&%]˺mݬz}"nSԴ@0X>fzϯXuڒ!)[IrORzB X@RtB*C$FZsK \nx8-"RfO{7ƾ7 GꇸZ1UW–kTJ疦83y#b uR6ϒ.8>^Jvd") @Cm¥IτRCwJ*hJ+o^ O#h_G6 D,.@'[Пk{J+Fg.=q-'0%]GEк$#EsaU Z%a(PK3O+ +J 3z+"$cIeIFE~'*4 >p] ɺ:ʷ_&DU6vOcG%p[bКY5eqc#y 1PtS"YC1MY*ھ-#ڰ|)Ǣ >&k(6'n&ubƲHYahD)BBw3 )`Y,زIbDsH#ǭF, >dXW]ɼtc`S祿e\j:ᓓՆN:7~%eUjd{eE3I2JsӒBv h ?H!wv.NW[#Ra9B0*^fB)݄fqh9%YNW!ݨ.kF1"`b+ m-5j( jC >Cr<΃ 4RZ.ֺ͐XKJR->/W(wpb+nݪ v6k$]gXphne,XQL8[k2@2-p\7eVki֤\ o[[΄[ߩβz1v; )9v4PGn-SdB`,U 2TaIG?}R\+V.xk)NMQu&vI )cvvqMt%TK$ >\Ya#'!}"x#9$PM3v5Bx{qMgօG 05L ML։*eΜ}g6fad&8Aӄ@h  ؊@-"-9`P+IKz5ސX Ӧ]+ irNo趬40nv\ԕ6@*HBNŇ0$waׁ4HZ[زr{֤Q@ɛF&n.c9E~"?@QXcq][|c3]\25A%J?+]iTIddKtɒU&M *CZZU.o\z޸ yzVْvJ"A)1lXMig#7NH_|D+)jw`'q39@gx*ƃM#LjӺ-V}/Ph\*Pv[:G^JۭN:Xsk}~㛵w.V>Vmk-CV&<qUstR5Nɋ<)K&p'd!Vd&i0Coo}H)9U)H%!&SҨQ>$a!@L$ֲǍc˭̸N4aY<ܻg3J{ҋN,ui4‘qA(Mަ:v jtVl"ylC ǻ T3IK2?y*ܰ7^y<2Yq)ⲅcoH2<Q;q%~G9 'TYjTU,ٰ*٧4AE, ̯t4T;ɵ]dP_ uxQ9^_]}c_9>::~78ťh9}ւ"Q0vO /STYn'i?c [H=TxbW#M$4Ż>v"iaָ%eP5/,*?ce,//ۘ>٤/V&ةtiNBss<0':rn '"*P$Lo5b *"FuYO$J|x>r ΠfRF쭠Mx=[9[ܼnrlTܾ<݇XÅ9OnI<>-s:6nh`á xZ7,,RJ[B""F z83!kcW$zOQG9~0DŽyi.xf,JfXսX*x(2t6fo1h ӠLS%fB飥B֚!fNU ҜDfٵiiT񙕟=mb!Q+vQy=|W䰘:pHz\x@uM)Xw)dmvcI㹘i,C&Jk/ng@kՇ@2<ں |uigYtY.Kd0Cq?%+Aُ2[ρ5ԁ/sol:k@.Ac6 K[oYo<5OTc9&k@ysF9fh%i 䤨jb)_M=a /+kykI+ _M&؀7\~M j2AkhxZrF[| 1 lœwKҏlչT!0$bں''gf|{J"tuNҨ߲r0֥j ɺ[汦Hl_-b]]yիf'v}BzUא6 ձF9S=dQSZ4VTKi>noULjF-"{0 euf ~ [Ѫ|K땮IRi3%U[`TY8"WZKJUV+WaCN$'NtY"qY<7XlV$yXmVU٦6d?nYA $laXMq-$|"H+`-OOڨdkH\0++&=Um#8̺͌^0|]557cHݨ2KȪͰdaО)ʡdAnHr<_5D&u&[}vvqs L/L#׬# kS*c9LޝvnY]:d, gp"4$/fd9LEײE @I&C0*Kk,͸lYlkī .ei5X/yogڸnH%a՚c`vCZ!h-^(Y@a'a+*m!Y p9&b˦xVe3W2[gƎjbH=vڸۆlȾ=3K Solu8M,&hhMFyA#+ʦY8q=)[Qj{ߐ. Zѡ\dANAFҴՍdR6|!2\I0lB0dÏ:ujh1c! @'lK},k2, MU6T4VUS$l(K2zv~ƒ9JV6;w3ܤKS*5yE%,fEC;|W!|d ,Wr=}jD"h0Ż*92 ENMn `?9-.`$8ayOE<wI.B.KRGS- AA*MSKQd4gݜT?N$.d|eHuJLrA\$5E[zV2T:bY;2K~˗Jv1WNG( suYCGbFnlZ*mƗT+8\:aVwRZI1G.:]e"Zܹ9P"JI~ts]__F6Gڵ)o{Yc._HW=L>\T!-\/=Er}*AQlQ Qd}n)I9.s R :.'8x,U%N1QցVs$y3\Rcƾ&{Gp5ݡKI2I%-[LvRKbQΑdg:x~D#XXkdMFQVv㖤3ar5t >b[B'$I  VBOsYT4"/=jK z h^Q$HvPpúø W+Ϲq}mvl۫xFMYac>[B55#} ԇTzkwrSDԟ-;H+vp48$HQa6l4s+MKB]5i4V}h4tJ`q)?c&_شe-UDRGy mzXD<:{_5qT F8EoʻEn.tGL/J{41,qFJe|^Ei|dm=$SQ>=A1T$>Ow&"Ag.!Qowj\; e iGR/H7d҉񮙕5 m(wQPl(CEFd !jUD̾plK!j ըmnFT=C"&ӎqI+4yʮNXxuA#4 tT|QN&|q|6;PL[QEP,-+3~R2QW@%%w\"q 72 b+b Ko6QU4m0 ,?屟!p'w ig#Lj!348oE7&}y7fJ?nN"H>h}^C>mYv>< P˳%; 랃 p賈HN',ʖ>WnV<{cRiڏfXxP"IO>/Y<=g _N}pջm@;P; Q|[\t܅DndTYeo'2k"5\C}il*8faܿ܈^.^54mM%JC>OHjrn#Hby% O h<:apMBH :)㇆ZrqƏ4 qG.n?Z?4GCb։t|,1y\RX=tZ[o=r6Ճ\ 9 CZOYR xLv!vH_-]4dm ?^8Ĝrxss4K꾖Eӳ96ȈHr)MR95+/Ezl(/lTXcЕF7rLT9y*5Zl9$\bd_NWeQ[Ñ5r {0V1JzD;XY.(. יg,qٷ7ׄɦʧ.Aj{UWуAjJ㾀C[@PvYNnXA/Fd.9p"E[]䲨 ٘KX'ėhԜW,}usMʅҹa[Ny3y`4T4 0jP>ONgD,U%trBFڔV4>ˌQ5u)2HJ/ͥNJeviU~&y=1rGGF`,B\io\d8ts[aH+cq%?R& >wΕBe e"ߞ|OMoL, Z?!;y)v^ ֋?jt*caXhX\j'Xy1-7rrG 1rG_]o*v?!BtE\⃽=ѸB<@"!]71&v#Lj#"\"6+n;A[4%oe]/_,k^q$A tqǗpmU_A,!\5d؜ :-A0A:u!W2f (n^hkLD6e+F,3,1y&;5Ledl /sW"Hn0W+|%(EUfٚ.1⮦fHFpVmwJʀy.Pp6)=Ir(9̲b7]p&#bv<)P J4faA>!yҀ➂G frg?!l>@93f/BB8vToL=JU1~A #B̞3%Ǜ^=,Oʪv~T4λԅL|Q>!l*fu^dJ)*FDRY".1;H+wM:d0c^1iM *Ӻ9B* ? L1ח$җ…^p2[ŭȈ܋tA [ET5x9Qtdk9ayے)gTά^)i]3EnQPkv|e +"i$JѤ%ͺk}K-%?"Bb/B`p~a$ʕ6"rR`5q<}Rn3 Ut$2wV46CU#Q!&wL}mo:%GdC>. [/P]="s[ƚ,`=*F1$%h aƨW?^-:'_m3K|ſ1cH.p(ij^b1n*,PU$e1Ia_dJKT$1xWr`"e -[j'wAt[G SR ~12[eMЍ ܌x%+}ҧ<{o`lӟCAPq֑%# m)I_]e.NCH^(:0+([-v2xo,0d;WkiB^ӘEqq9crl#j [VeRBVPW]_)[)r[WNh@Ր`Kǟ6!?5[8t>yTvV 6XॅOc@IPR:d :gS^n_[B%'>AA [~~UEU&x{U'NDΛ=m8vOX:0Tg8EtH@ֹQu1M^ޯf0T B6% Ĺ;l[M_@&<}UTQXd+(Q_(W&N.# Œr{ݭ`oG7D.A!ijZ$W8I*~~BhO|kk 3uI>s %/ t{NYn##܆శTYz ^)4:HqJ$.YAV6>Em5dId&z~~gKrizQN]dq<Y69qܫ ]Mj~_#U׹2ҊPdUy8!8cFAUxփgxI^6 PTI0ƟnҜ=W rܧBEB.*@<+J\`LZיp DLT'%as&FT`>  3jcʩ#`7P Ș_'qd!`[q,p #fX. 2 ὲe xW6(MU`&B1:WDIrS0NDDqT Ytn;iuUZU2KR-v)Vz A]>b@ivH+iDT(UCox4D" I!Me"@2DH>gϺJO\ىqhSUd,qdHl+Қz? ^@1$,JV8~b;֯#gjbmH_?pݛg[L}3;d1ͳߏt#=ܜXȇTnVS1ITU>؎oEg*kU9f1 V 1dIGO~SH-4) |uXQ,sb.i"xDQzHEXk!פSMbV&1  Kn bmH؈CCr'o+wDrDދo=> *p ,$HkT:_E&x.0r&e8.=+\ۼԷ0Ȗvش8־Zhy uO[-ZIig/wMlw<]C{ 㛈CI-qKg# ?EWAmGi;j!<\z?LbђT>ɟYY/>$Ն/\;!H< M=xؿ7UFT@8쵎/q_#xƬL[TW+ƜJwW|-ev}I6U]ܫ= HP+;lLz<94v :=ccv F[ 17#G4(oylaH_4ߗ֒ ~qtK cg:䬮uqAȢ.r`.Bϛ ְZ&(YPXEi* Ya!p b0(2pL (,JJDH|v_v5>B#Մ4y`ѐ' <0ɧ(EwآFxh5bt;rb.w^ އ So.cZh0){`Am x\_E|BwĊ6{r1GY xw^rJR[48l'\2wrHYYYnbkPgg/:n^>Mm~6aL^VYgOKvKHգ-gyavc=Vzc,lmlo]@>\O)Ca.7:umzi|G]4X˲̒;gM:kAknnlU.mp槿}4]G6^Vc:]xGdޙ J{$-ξ.@<[lxZ҉&1Hvt^Ox- XfH~%8$ wܫ1[ڨ2@Ee_ 28}ܸzt d^}0*-%LY%}$8" _- 8ˮmə.}x=ukRsǴ6 kG@q,;W:e ÈK^Yߔd/d1IOkZUzXp׋XV[Dd+cC+IX.ѹaҰ'ۭw]LjfQ-lU ޙMS-uUn]oٝ51Ć,xTڙUTy$Qx[WUG-,'P{'o}~FCL`X [yvnnYO= ݾrѱ8+MDHdudow:+߹-4lM\+[Xv K@b|@J5OدdTzPLn`?g6l^ry>Y\ 3m:6SLl碔KnI+igc#uqvVڦ fzvojЏUpBik".Thkݿ+('wV_zRj`$pY8:*$Y Ӌ]۵-k)RK-ZD?mcnJwEU.@+ ߯II8L>m}:\ygË:klԽå: wR ɱ>'.D&8|wvo+J]\x7;6cOsodO. W\{HɈvk+YMBt+ |S/^H(/6 >lI6<{tJ( BΊ{6Jğĵg) j`5+8YEE%[P38:I.Tړ 67q Rof@_9?%G)Vza|D, ?j#|$ [~RAҪlyr]ZlO~R3ŗ)*+^Cg"bVj Qgٛ7oM&6\ly)qTJL)E!!gz5= YsnSSj,zK؄àϒKߒ%q{UUbo|4۲mr{;ۺ;0u]ϰӍ/,udEr#V?lt+SYт-d*jW;K~hʀV {-g~oǔf|c t9%]n@p&F6uj`9Ǭ<tdž_?rJ})>}ş*4ABa (ϏrO%b`ł[8!VM 0521G7<Q֔OyB?;Xd;]e[/d&ZK$qrTT.bj}x:~iBh Y %(MŃcgnkК+RUV欚jn.U?z$%"%W uw l Z,SN Ȏ| nr֘ vo>AX+2 5bZz#-͏?R"UOs#Adq5g}hE1H(' A|vZ'd2Ud !Gձ]RKnsUn¤F2W!_h\N#2&'\oW@D(IʒE[lD`)#& ݤ+#u\={& Eg5̲ PJ*yST˅}w˸WASNN#FHšW!︜d*,Wvc$UCqt!`3OQ)z<וH&O9#S]ӼcaޢHd. L:3HpWIKV+ޕ\vkfO%LQʕLn^jpeACd^ w2w>`rڪxaK Cﻕ]8>Y]s &}-6RuE/0yAqHYjK],rg' .%wG]G( lxZAVG;Pb60A8wEU`p!QIoII,ދdВA͎żkt1(k@LȞ$}]!=HvDB`H97p۬Ɲ[)YwE3)}&9W,Fcx59jQ\0Ǘ$ ܧTuf Txy3;׳2.|XiwfI|@Dg![(x@/{xwCI;DzyP|s4k3gGJÓnc%Dw)2sV1F7PJr;v*DeŹb=UězYO9A 4Cfpɂ6sZQP@\ ƾYȪg< jyn' Sbߟ)T-&+#$JW0Y6}5EuGZB+i(:eyw#E/\%H9H ~0K{>g> fWz mίs*0.NBJYC$BBKK;"]%J#*S0S@5팂\9sxm@*: (R7ԢCb 39}-9U 躒>:NJ;2II9@SMmr훔=HU8![Ir+ ntaqAl__ؐ|ĄJiTBJmgVO<2QOLDb%Bi9q@NnA9M+kFtoi`< Ev K&DwxNCr?.U:?4]D,9!r`8=٦dayIIǬzC ڈ7sLوC)hd6՞a4:d{,oo7S"]^1$$8 9*6z:5:LA%*<6%v41"Y^1rGIf8b ځFc|V#|Xo==2Qa)'X? `' ko7*8iK̆mijU&!!@ 6XY*~фէL# -Vr8פJ1u}Im^D[Xr2nm&ue/0Y|e̻~9"Y8OƼz k!\l_r^$0uy3XO9TfQMk+JQ|fTLEa\x|rh:8=4>+WǏ' `aetZ~Qp"oF`yC5kCwN$AWcAéQC׋{GkνwvzO=2}4m\xb3\K|U%"t!^ɯ<7ZHzv}XR wAGUɂ#e+d@!_^Z-`&\ș˳MCdzqpѸ |x#j:G+X 0RH+D]opajǞ|J1unEH@ u$F;y _D`L3# 4MSEۄ\K%"s2F"- 6/8݅ iye+TjQu@_?%i~=;aym~PsNfEpɆVvDi <9ޥ܎;{OqR+=?ye,V -ʆ'Gz~X?6m8iʢDxpI3 V(n<h•?6?ڣ7l]J|Fz;&v@4{8cG7КzNOEMۓW}R=Er6rai0議Mh_VFmGiysw/ŸL1rFc"uʎ?g-a䓳a*/A )#LhaJTK񮽠su$ɒ$|ʫ[9y7KZKMl{7FE4 ǕHOg8FP(_YeL>)+z݌eP$im_`9|G QdYi&8 |uT.{h;qZCi =~6ۺ x͗t7 xdRypoݹ /T_|?YQ^o,0KKğ* (N~YJEVSU>e,/p~a"㹨H)*d>湘*Dd8SZTd(gEVMgZȰD8xv|~!RJ+="fbR*@\^4?-Y9嚷q9eIX^qpDlv `( >Tr+Ba*,ɑGBC,nx.H >}i-gjnazr,DI CL"NK\yTPWl -dGT 5A{0lq-$ "R>MFHS.@\jQ&E6'AhiglBI!Y"gDD WTo촘ӞYA'Doj0l+d`R!-%[p1~\_$WE'ax,kx Y@UX#(ƁK{=/u0$8aij@?30Ux/[O4KU UVE*81WU8Ci/z}'G u(_sR% wQςe sh *[[ crEyj!y2n;AQp?H L&qHRN { 8 k0م|xX .p:O|x[sA 4x Oaai7HB.gbd$}yLN": ֟M\:O_==0{!n) M`V湬!8W@'{,7 ]3-z2 0@89HE:#)FĽg4-6ȤD!:Lk2trzCbđ O܈wC?yҾ DTUXbY]МA{Ӭ4-`ۯѯ'ť_ARxËh͠9#".~(@@ATI骸LN e31G_$K5d)<8> K8U(Wc@C{Dy6Q2WUyd(y=8M%09REψa§0]c1nGJ4\ |oMZ ZPTdI Z@b kI11]LJߞ\ ^:>x^2GQļ1:}WYȹU,r ^U$֔@`Kp̎"ea5Ma cr, *V)/y_fM<\vZF_q{2eԯ0Uf@"PH9pO,T& đh zEL0#%x2PQl@ץR>~.z_b^Y =fBM* .c)0Hҝ_+Ɓ}OC& :r]jEYWO.LV٥Ji d^r ۸sfw"ܤpn**b B_FWC/=򆙤Cκu;|zgzS f35TG7$Qٸ*Yb))+)i$ 8D 4k88) :0QHґLq>LۈäϏc:aE4>y߰tf:(ߜ3-M\ltDxlH l}\+4 ӗKgI練mbYFN h]j{ڥ})V ~p1dZ.ASRqFkUV`#hùdd@,( 'Ϩ>f>nѦCaR/lFX;]W&myZ^U9ˊ`HTwDdH,3]!Os&KJ0J-zdA `]#,OSrit%\x)3TRj}iNX0֠KyXRls Yx9㛃'\O&S0 cyScHњg6gW$[41Cn]4fQXѧljTs kup#TM64UKg 9u.CFA8:><=:>˫)O(bqXي-93aMU38y&UF']Ֆ)T}dR^G4rc#¹[ z˦Xf[aί9&T2CPT=T`yrcuYюu' 3U9'vg3yت^#a0RsW࣮M :5;7F[Ub/֒Aq ":ZvDfcM]v.%4 +ұbر^}+3Q(bSrkn:/󂔭2{]S)>Ǚ";$hBPLXjAB \D1ۄ56Zġ ȕ p_kFTVM*R$bT@\[^zۈ\+Y_n?E[78m% ݺT*Ef(k6t0]٪euYVIENiF)"flf]W@::((UF5ڸv Tܘimݚ3X3gbVK ,G:@_fנO ;ܥ[T>}JJfӍ#LIh59DKTnA|V)%aspzy|'A0F] 3So,孲]Cfnzr,_oG%L0yK8)mͲԐ`Y1\ ْ85 {ID !lP6 /tFn3)SToo!@f=Iä:/9Y(6cO ҁd(*K!D+?z;(Rm\)lCs\e:mRS>tDž7s{@NFⅧ~׵l'}2iMM0Q1R"afsRܤAL)zmTFVi$~Lm6MBjhz2#}*u\,pP# 7cx.>Lz`8X+U9ZL~ha'ߋ""yZӛO etntm,{vϭD%[^5;Q+9ߍhfeܥ/Uq֗PP@,H=tQ L"_(9n\ $g؀Z#fRjDC] 6r+Jlž:BeZ(&֮΃`ldgcFGfI/q1Opl쥈[!a yd?%]UM>5눾9:׍n~<;KC:ƗD1/=¾&[ǓK @/zň~ɰ>mHO2 v׶c?.Cvɳ\!"<$#- v !g -ӄm9Br2J& aM,˴mqdG.|2rJG\b{eym YP}J>,EvPpSh ѫ4 X$ GrXΡL_@TڶQyRE:=\%[fGwv<;;_gxUOڏG7uZK#uo/Ϲfvnq!9ΨH}>{KG{dHz=ϐ[3%wVUzطb*Y]Wgow;,[[P|K<ʭb SsT3tt҉<%b?$czRä6yNۧddQf%Enx\5gpwd[n2]<r` jzJ % 'fԘύX$K k1H2x<86"h*| 0 /wl'ӥ%7tZk$(HhX`-P4mK,.ر/nGt{;#ekLGT8 39F+u(NJ0nŕh74g&R"u~ 1Jvg<&yI3_o_7=BB1h_cxk/y<WARktAss*l  %: !TFOw%}׌ZzR0 p;e] }UI\FXΗŴ}(&hU'+12DPS 1Aa7Q=`Y?bs(l]7HߡMެn´yߧ62w=04_w%ߔ讆\k.E14k-2PM^ 8Y5-nW,(3li:Ny܀f7㴴;]S 'Xr苌:М%{g>2^<>Oҟ 8xr=#}$#ڋݍ{;&5:e6Hj*wxϚL;G5?m'2#el1"|ogc4|S-;i 4a7kFϻ+mz,*BٳUOw2VF͝6:'2/+Ѝ;ФyJ74.uBgѿPOmm7]t <][ws+ڇA$s5)ܼkk9b.eilQd7W孈7Jf {n/rهd=^W7%s;j\ѦcZѨ{̝t6Ο D$;@Gl-Q4"fr5顃m$OCzycSG={54q܊/u՞(tgx}3`^15d m|y<H)9l1g;| Wxs+LH?F溄 "i7$ ur%7h0^$ޑI\r5 Dp֟MKޥ`D(+94qm5'7儽K썯ow/ԔJS7:V.x-~`t 5bɁSCr 6sKN;A)M@d`]yܞ9.2mfm(/ub˞-mw h˦8|]A,{|WŌYqm7xSeK'm1N_}LݑVs{- Fɘ)t5!23JF6~23aGolpK!-I)hƐ5 < E7y[:UC,z~.1c%سgua% u)ݤEJ>flėnd˦@Uz 56i rlEi`F|zZ.(zH(Gqf'p]7$ k![#6-p|B؀= .N9*]8%*$/8~-h} =$}'f TMMQ7,P27]֕r]w"KyHBnt+UZZ2Lf0u!TlVJONT,;i3ڨ7O[ouhFbɫu 9f ͬthF'b3tCcteT&>SCN_%&._'(ǖ@޶bSnv.UhsX(ip 5lY:6~U72|9%/w9c&Q%Y&Dt?MU1G EXɅts1W\J$iTADcf _ *0P)}5" *^) /( ^اUG yY:QUĽLlD%uB>UOKhoЯ"H La G0[q/FH7~&pyQPFk@6xXrF>O1*@mƔLTED.2"bpHUC $u@(! ?3?_`-Be}Q4>U(* uJ\ɕZZ̔J Uy~JhCeQTJZ"WVҘTHԮ6oJX[8 [*Ry[tjґư_u6Kq:4# ɕs4y'cb!J>5FJ l"YIcu]JK`spIB^"LLi+E5xXQ_J睘N*B+H#u""B-Ru*rN^<[!1nrӭҹ~vF k]ZV%]=pQE3r|5EڛG(򫚒鎵p6Q%)fT':o")?Ao&a38Ev![ 0΂Ry@'HD=8+aR:otNFux:MSbR2&#UI?IPqe'*Oq3/J'g:~ "}CQ7AY8ăgALECOWFd?2 ^9ǖ3@=|cT_!lsa +`ɲbXӻ2OɫڔD=\wŤIZq!'R6ټMO9j.~L9צB08bJ)쇦=9‡xjļc(.cEZ.аY:?vS3"Nb{c*']JെSvz5 AZERURqNBTFkiBV sV?ZW@Ifr6t  ˲YQ";S jTe,\6/ٚQde#-{I-dQz.8v-+TY ۩߇~@% \V˰Y8,&lC$~=%p0{䲪┄jiaet ͒ڋf'eM@7Sr9lvtxCiGo;zodCIG= 2u:lUҖ?$]FuaMt',y}󥲼wJNpHw;4 ˥r)^iD*^I7bQYkAj@%^p Kr@l0fc"956OeӠ?rpvie;uܑx9:XщN^1j8fU;&p+`1sSFMA@/| @F),LHt [( 8 ڞ{/>P]nѽPc.V!Ϭw+ٟg"M-Tr=0BV< 7Q}:~l6t2 }t[RJ@RwƶlKcxOCk?iSS5oPKGc$fB7l|Mݪ~{h1ʅolvu%~|k褋o]pbIlokbdn M:y=IpFҥʌ&28Inh\XTۮiz=#6TgpBw#||ݝMiviCT`r A M=NW.xKA֠s#.! /q|Db01<+ M7)xaf:ea8S2tlA I"&kӤ]B5 iS t"?~aJ-iZ^Q5 wq2FQ `b KGۓ<\* 6O5ψJ8-ql t?d&Xg7®wT)J J5i9Xz VTˬ?q!TzқEe|Nɋ. hv9@ōzREj._dl7u6=t!7}kMn\&]L$Jx b 8k% 2osѼ(à&t,Z~39wgA+= ޼{ RjQ4 1R;j⊖}XxM0Zs (aXEpit()9*mOI҂ig: $+:_&~`yBlwV((sqkyR5G}a|-i/v&/eUBW'L=f(u2 a`,)-2E/-qؔ?u p )lXHp\`wC5amA^B9u)pn?efD^`2|ϑZѹ_haH[UR^-r5>ȿq ￾PnVA"YRYz_21LC/r&tDh 3 .#f:F&!7}ٖNxQiz0[dyQ/f\ٵ͉Tj#"~S5{LnEf/.C\$׌GqԼ2qf;/ qǘhKTu# *!(T ԧ)dxqqí*DyK)& H~g[2NMR֠RO/lMyuXҲ'Zɒ7nȥ;PW&;[uG9AF)צ` u_66jX0cH⠢V.x虲 LT)0-jWVI~ՀtMg\3Ex}vEHwKS(œWbț\t+pKY9)apV )c-O*IEf(78SĊeԃ0fo\tP6@ u9A3rÒ׶;m iUOuEo)ؚC ?m ,SZVVASvRM;@(MKZQ (\k}a?!h1>~5x.$zip/internal/addr return addr.Join(prefix, path) 5b// normPath and joinPath are [addr.Norm] and [addr.Join]. The rule lives in one // package because cmd/zipdoc composes the sameF two things to find a route's // prose, and a second copy of it drifte& return addr.Norm(path) ixWQo6~U@[{K,IE[xP-6Hʎ؏//wl)NCHeS;W"SIWXOiF{y|t*=uJy%AG3I^%&R{+(/C3$3_9PyB)d,%?ˉ^ർVλ!*U5 +s3jAđ#m<kj(pb"?yŸT̈́pHǰ` Yҟ: 6rsh{et; ޥ4d :8*K,WU:&",l Մ.T^J-tpa‹2MY%s{>bN $GS`m5[ߋ!Cs97 5H  bER䳀Q|Q7^.YklѸIk7rbHNZ[ߏV󝳼fmM \ IZ穈ڃ#Ҫ;Iu@I8g;P$g4B M:JoRAȎ‚KgQ:r.8s [=W`6l){7["޽ljQ(=FYpTk#F3S![Jif|7.@R*G@pA'P\. 5bYaJpE{b&@Y$l.ozIvC,Ji>l7ffj!C4E`rVL("XxCwḜR6JKvJĔ"RokFxe;\y~*ʍX˳ P#ٻl?ɉ0[Ϝjʳ_BJcu2wBXZN`^(]Bq-ϧO4;. &:H0-s6u~JN7˸g6VUVnZ}TƇQu^օL+oe >n TbhhS rZ*? dХ 3U7ě3602R.ž9!m{ F S•sP7<+jvM=5q(P .P `=J;8]ߚz0TafИGALm¿-iw9J!vvw^6ց6Ry"XH(cMᏛ6r}pTh4SH~1t/>7s҈T3THҰ/bpc (ƫ@]7'ZϦD㋛Rq^0KsT_B =y[ފ&"d ˜`զ+̑(SX$͙Vw7߶.`p,Zŋٛ J agv(EQg"\'~0`o0soTw^3(ux|[]g snOO^z@#/?QCzvit[s&i~u2Cf,i'w}w;J;r3SH^qbj4< Tи^UGpֳ[Pms du}d7.^H!m*pkzVN? C x340031QpN,JOfZ|(˦)w*c$?7QӄFr_J،f}x}y&@Z[ZObYʹa6kߣzj b9A _TȝR ws1|7Oi%FkMVݩ JOxO0QM6'V{{Ʃ]Q>= iZ=4~zls.sp8F wY?ײC@`"qf=2=8ǢTd%u#\OO|{'/4Na{Z=B> x=B!E 2 k/$@ yla 7ǾJ[:O34VAHԸOdrDoj$^|-8LYܭG{Cɣդ4]g6B 2An><}2x40000 infoy"f%a<- - x340031QpN,J+a("uYj#YN.BT&fe28+xsy>Zm<_&43'Eaqݯ9kmꒃkM @!=5\V͒@Z[VM-.JfXU!έ]/^>C{eD$aH2c "bK.6K OR xmQ =xOa҅Twwmy3xL7,KDW^jFAaFg&e kGIdTG`ir2_LTi ve@mګySjUin/C۳z?~,[o>-7QڶY|֭j<0tttS:>&qJ7BM==7E x3flRщj;ΆJly%Tw4?{Xq¼-AcT ,;-r5'~GxUSj@}WdBք;.r1q 8D+۪1#ή/M`̙sΌno@e?P9K4 F &Bw5rU8=p)f S5^E e gE,sDpB.Kxr?@ AT+ph*v݅'fZ4(-x2B,Ki sP5QAm nD╪R%`5pV2ՉTe)w+apwP% w_g69 BW5`)7-ɔޗo:01Z@$Nl[@k[YҺJ-o(u$\4߄KA%@^+T߂AWewN'W*WƑfAӨ\avEQo%:Дˍ0՚57qiq3}z)nkZ/o*"Z%9"Yd]|D+0 NDl%Dy-Idqt7GD[,^ؠ#Fm ,2yS4xihN .Mw~CE;cTVk `X6w*adS/gW#ƴE£+ hxv5ne x340031QH*cʐ-ϽIp}Β5yizU ח=UQ477<5ļ̴a{ܧ(d|Guzn)L.qz6i-t)aڠU_XsI~^zQ \X7wIxXQo8 ~r/=]+nmQ`fb-aHnNƽ)ROo'MY&$ɸPixsrt )p'8e( esGbfYe`g˸e pΠPKsL&FΛq:%~_pѫo߫ϒC8AGL[%«y, dA?| Fϸ6LL/ӌs]wRݝ)>=GL(n09~MN#h3o\S`)r@8pGŤcL!8&ރVə +CN- fd _3> QlM0& >aaJ)a ʿ-\nNQ[)͓JqC{=BUJ";Y UD}aUY"jY2B]=tQ,iDh^caf%:UK`,)en. q9 oD+G^tx؋T'm@>~T+7xu^Z 0laGZk#bg8yQ)N*^<"śIR`iS+->s;$R0b q=w|ЖWz)[sҁ(ɧмa˩lK/QZVUP|$U[7 1-L=!SB +"Ӊ$U,2735ԝ}94tx 9^I4{)o1}5 uc@$4"vw-+d9B!% ~Yw%*ãEE(n@Jjؕ1Lm Z8f36O][Yi)6)Ak*+:d a?^%Pz9/7X;9hO:v2x:LF=Ra#x-zh  q+Ri0Q}CzBA΢4-BpH, 9cnM#,)a [Rbd d>qSGT?80Ѿ6HvZc.0Y*[r-҇%mv(Bx's/I;s/tp5 O`H&O)08P+T$q.>x7=bKhXOxw΅b˨|ŨHITNRo`{Re@^1S'nڑ?8s\@ZxP)J{e٧y@ތ$^f8h >(mF1AO1r"9M|4b:zjvO^D!7 qLii- G8/;le& CU6Bb 8'!HCL~-^I4Y< mV*|76xp.HWrKč t|NWə?~hQHj:4uMeu*e0-cmF(.=w|2!#k)_dXQ?D]._/~z߼e_1od{+l{~pB]Sg栉_:̭( %qL]%* Qcﮰsnu3 ߇bI\2 M$qs/6S[P4 xZ[o8~_! æi'ne4qif ZmŒTlsxkm'(P";wD$^$IS@ʋلz<`1@τr? z?͉&hrkSo9g ~`Zfqij=SdBxO~Z>c :ۃ5'f \M,ᝳ~t"*ld#t'D̡){nNR>n*s` >e4=F d -o҈1ОR2brw%)g!',8,f,Ej/Iqo9XN`6qӁ:R -"#A ؀avmB,9+Acd5n?~~g NDF h7Ȯޗ N_]%9~`-=d~' 1ꀜ{JƓo䁼~c]_O_Oﻧ䁯WS?9:-,Kf)h+:d9no.R\pAWJן'Cupr<:* ppLοiAϯwݢHZa؍eZҞ7^+<:h5vH钤X=*JfT+ʾ<x)|52 '}k=pV(Ŝ8lLB24pWnNG,>C.!>qi+㒽]tEyr/Z8z2_@R0N0D_4I4-B.yP ox`|'8T$r ID lbf('ܴ7NlZT¢ &)jpv@'PBAXPug4&xJ4Is[#^D9R'& &[j/A'zv]<v1Ǒqɲ84@FVca9(%n'-䷮V93a];qT*S,.Ze5HYjC^V\urt0kStQʏ h9s3a~UD%BA w 8O2K(FK2l5˛/l|_i̟w]tA&LÊʧFUHjYHTXdQapʢ10ks[׎ubܰDEr4ˋ+;(])=nYR˞pIkP6KtC/TtFkj4#B)zY,+<ojߕ[ztm,OM-9]y4p_PҖ/HDe֜y۰'!I;$E,y7Pقxs$:Rh$Z5z%™ nP _9fW1%ie탇+Α,ML-ENZkL|d!7^H$f;d‚̾B˲j9̫6F b^aʎ޺v!O*;/-G~_!ӳϟ5״Mn/]cYNjg%_yNvחՐ%u"?&ϵxWn1}WKੀR ZU"9xg"gvMAJ-*9gx]&ȱa(LAhwnZbg?`m5^s؛=N'Ŕ+ [> Y5H," 5[<7f;wfm#c kh a1&׳#[.Gْ2aR*TҊJVmy@>p0#}4ʒ:FŸa 2Aܫ#CT: $ )u:.Y/"̚/%%f^\@5xp:| iKoBY`ۤ1ts)Eӳ4|m,Yk'u+ǵI39qt[KDBCtjոNh hč|L`ޮGYxWGs㺖 ~gl[6T>- }9JirŬ#w&ݢ 8.Q6s() .㒫3%vk՝Bf5[%^enz_&GQ D vZbt"6 }F+KmSqU=ri4A^/lߖ'@U;z;8 'LÖ϶ i0G:lC7"2Nqxɐ!}'Q/Fm[Co9&uO#1+-!qK`qu<: Hh[G>=.%7F|wۇɠ%66eZuY> x\[s~ϯP٪}X/<&qIl'8gK13Hc [% s0dy`$[OݭBƀ.uÙol0!6^?Sawhq=%~厒Cr:hNtG&C ΀ >!h0&|i4 g)vXhߓG= 1iUuM3;VI%5n$"\Jΐ9̝7q|I]蔞S \yGe鬷CDGۣq[ƃķ;EoE͢@3FyӖxuXU:Cb+b º9@?;;4摑xȸBĐ9ÞOKBK#3rb_9Ey;.s'?~[UgTRuH_!]MR+qD=!X M{ 8@_3+m^M?ΩR9{򀟦B1GC9bXIk\5wE:'ic8 .);I+b#H}o;WeT\ACS^@ٯaByJ@str)k9'YꅰкϨ7n 8:ޢG{&*l1=s`6MF2&ڸmr3C $Fc2i ,56[˖t]B< buh-( Zuf pDj20iE!GpFkZ'{[GhHlX"@`&~ƻQxbiLVa-+)&mžOZR2vъ$y6=jUEjHH;%F)s fN:N+h 3E`7{<UFL ` E8kژ.&}Z&o` 'DȜH1b8Ki"Xkۢ߷kqbt.l@%'V(z6#zx0%CM DGuw6teYF>u"@  k6u v W6vp8n=K+J+r 6I"gWnq¬n@#"L4G 9"ꨭ-YTĺ2Vt_}BjYi]nܱՃĥɥa^e)Ѣ~DYŒn:9UFƩ ɼ)9\GjͱeU =74rc Ψo r ++L 3 sD$y8ªXDB_wn4BЭ<dΉc \yZC>8\ . pޑX"4NRFAilYłLȧf&( ເ6SØ Ǧڒ}|y:G'(t۠WqBn J5L&<2a 4{Q!z [lYmʡERrf )otࠈTܯ]__ǁ>Zٍ&*\)DB~rBī`HNϋ/vOl<'EeЭnD?}/g%#s]s(aK&a6e/tSk߂yЦ   BlZ!IyкtA~s߈PpkVaMbN{rƽcLx!F%y<"lK[&i9)-S"WkAoA{G\~T!" X& ز̊QpHn~9]B_2'"$|tcL7D"XU9F~Oh$ߕeϑ,26$fƃ낃%oi|಍HB'$1##[ }Ĕ6L#NN-MȾ|a?A&ieb a'y>4hւ HbTBZV@EQ jg$ 9~K&3;)e>F~}w޽="ݿsǬZW=EF1 aWŸcRF0MS>#W.|w ȟ:_&>i5֭;(ӊee([\0C(w^ |"O="4,$5ޘ/W7_LұP&]^~8pD">qGPaKQauUӫz2TE*W HXɪ;9y#}<X24m2җrP6KFk#Zőm"w&֣Ll]Fm!a%+t KE dvٴj.Kv 6kdJN&*e褤f۵2(2l8t᧍ڧvnv֋5CɃ4`YXf)j.nDLSwNzD}a>Oڊ|ɗо/7'xjwݢ\c~:Tc1[:}yPC-E*:R Cn: JibDx*H$F&▥ `)$oMU-U@W6WQ(]#J5:;EVԽtI*fkQs:dgk5;^hAn lixw;]s=g_#99>x?zMk5+wTʾ-z G D$d=UoD(trB’ѫ$oke"QWTot:|~K|k|J?^z8Uk.w;'|PkF{|rNuv=˫Ţ?G??_wsda.>N4hߍ52/89oȏ?y޿i}:`Kߦn|UQRY VSwްFvQۃ~ GQd=ړfB\֖!uG|R 5=Y H Ǡ?ıa,v(VCvv^+=pY$C%fI|~iq~uqN)N|DVxRe,FD\n!(vBh2P*`Ja%\ c%$zDKE ޅ=S$FP5cZBhav)o IٸIJ贊3nKO kB?=7&p>z;$)IjxT]O0}ﯸaK6 dXUBZ6m MnZĎl Q~в/n{v«O?Z,F5Jk2| ?,*)0E݆ QD=EHYp9~ %4\ >s" OJkJ: ! nHWK?ۑcO#Meji?H0"I1hHpFbF33Gr MŒ)(qɲz:8HC2u#RTzYDguӴQ bK.%MA';㪵 %⁛ɔ9/P깳54i"8cyԻycuE qNVΒvIq<T9FDH>nX$q9ꩠzfJQjTc PEsLk,KyD7j6,8T?̍d tŃ 76-$$(1uAZ. 3T1>7xYsڸ=&wSBB{wgHJG0`[%h'#!io)q４=r9~9=/B^vwF0qf=2t&SI;;d~Nzтv$d0_-.Q `# SFƎHsֿ<#cW]'D~E`CĄt/`#mF/,ub+yg$p4'|:R2D)lravBF/O1LW','X5cH2bSF19p:rB`a-OgW$du'x!`\ɳy`=sɹuzpCQ̣ >Q=-tFKGJ?q_玜*:fBH:00cK@SDbm:TT <＋6oG_}WQѥl&H 50aKzqCny#ZV2A x`AY҉qd` Jj1 A*2r&b6BG"LY(AP0`NPu&M\q&FivQ23&WYcsXAh@G;y#Ȯ[W 1Jdڭf]CO+ ImB%գDTn`ҧKQ| wP&12xZ68<>JjPzf/N+@G. TSסʉ0 RAXڄ|q)8r5i-fCc;^C|oi=]^WDTC) 8]zCvg !;%C&'{;c#jo`J\@ bMfOɠ!'{#N9P3C y6d `͔fw!c^*J&8"X <2(,A~HܓpR D~V_Vhw{ + )1kzCݘǍ@UYIcF$]L*dy nZ+\k<Vkq ġGOGU0쮂c^*ҾtCA/NK3̷^}V\_B,N Zk=z_q&>*2m@Up ="}(79!#-5y)`2*4~R)cf՛>hW; EݻuC1RkkN\l6u|(jc# fzW Nwi:*1V s.NVOܬ_TeMxʼn 2AaAla!^}M>h*7TȚ:V G2zR7(bii $m[%0ćo]lBWH) jX|fЬoa|, huzxPfAM" jTf`k]3$ RfG,'n8W6m A0lLA!Ӵu=NWhJU.\d! eD]AAi "vB^ƌBk|RƖˇL|Xzu&Gǭ(O;Cv~5r9uWGOk>ia.fLㅖ&wb}wpO?gΖe}n7?l/X,[$`Vؚ5Ƌ+2cZe`l5~$U)[~]%nշqS}DˊlW: "ҿn?]AK<B့^,XF~Y=b]G'!tsִ f!h6dhb C9̧JաXe?h)M *>h\=픧`X.r9 mx, E sԡV@ m ;.oE!o£7* HzeTkSܛh'e$_PL),B'HR6 ++,N4Wܼ*WW< o \ &JEbVˁC {&u/alxYn?OS F\8vr։88 ]Jy#!@O'̐j)W.j.?~=NOŗ+ ee!3)̄8yvr^&);±cۧ/YKU4),ya?.c)]6QqJB3n,?EVSq㳩;fR>.e cb--yF>q*}nㄒX._E39Xb%Wυ d!uHD|@?Z63+mXm"nc+qkY]><[&%` VRlib f~Ov92o8 ufɌwovX\VdG-y[~HbAY`[=;E$b ܩ`(XB~u;k2=S "@WB)K%`YL&.ˠnxC֓ɏ҈{TsdO2`7׍Onс?5/^dT0JTDm`gz)_̋О}4)$-s+IcrZ#6h{+ JPqZLЂ10]! 4 ^t b|-%(],8F֨Oh,lao 9;> XKq6)مt5a1ȉ5j<>9DQ藟=h}=$`4Ja@F ߦQ h#(xI#=!`1COh`h7N"04a7.*0zO.6Zbt/novBzйh&֐l:A9i q<{ڱt纪d#d5t8)&-FL?r O0P3bLq\C ]12p2{te V 6wJ"yMJFE{cqd*uMKNjw$ "Jk@^-+;` ٍVX4Vك6knfq9W5prBz7aZw i2(bz__"0PP9QD~p O KA8)鴯)ihpv|}9^PZl $ ˔łbb pXu@›n]XՁ2l0#!@=rH0z@)%n|:+%! ȒC=qm30"N,/"*96԰re#h [4ǡwK}pz)z툍ԍk0Zgf>l5UzR譲jr2T7?&^BVzj)k߮ณ*ֽBȯ>θմ=Fo^Yxty@؞Ydb!d&c*Ա03 Rq[wrmk!`G(НpG['bTz鋻JTw*E"뵖BDܺ6W)RWtFmҍtpvlBB{3~8,C3m@ODVqN3L?ñ/;g,j.Fi8H&``W l8؛Mrvs _ =oj)%I'T("IޥQq٩݉p @յ#buڮ_a^J4n łfn3EyYJGN{ie,Uuxny:xL7L omfF] H ऍ1B2~|sǎY-넅cN [.ڈL":3wz͑.jӥWz 뎫=bǹ/mVmM {됛D38tߙhX9 ܂FK'9wz,H˩ta#^Loj/.i^jR1 e%tp:,&EDswӡ ;79F`ʃy:$?D3[L7#|XLD)dhgCu=v͔H)خgIQ=aA]8Yeu+)WcEӀ1X]C͢,L:6ӗG>alT(ǟ$;Y) Os(8VM(sK,\lvzMi~.s$8^|} x340031QH/*+*f[Rע8<xXao8_!EU.6 W$9@%:EUfP鵸y%Ù7of<O88ө*:8TT*/>8 'S.+}3s"GϏ⬾EV[Wie5q RVUw*hR͔\'_DF8Um}q Q0"3Bv*o\ SZRϢ}ǘ:$VJ3a %fXU5ְ*֊q3R3/%lt"%F my)XȥpFf/\9KTzVoH[RJJt%̢FinM_ֲ8&Ε⟕vjfV(Ǘiypyk.4޴Ƅ}qN틇=Oo6E)nL φы` ~:zqSf}vSOtWƣŢeE*™@OzB~I-M*DfYn7F$]yYeʐi?CMHI@;U.L.`TV툓Ms}}nHJ(9RD=ec]/cUG Dn:>+`|ӪYYmFQ|4jlR1ERfi[)%ҵۭa'|+U8XWiS2d6<;WY#uoE7X$EN]mPDv꾡9E}ML(7j@nL9>Y[ =͕toD5p$QavӪl,F ώ/1:ԮZʒak"4A*g It.GJF IKshs7dsҺfSs;Ỳw8/WTF=^Gx340031QH,))+*fXW"} >ק~_$%?~ݤ[kIMM"(1GԜkN|ۏk~$3n'}σ/(/ݻ=w^mQ()([pJ0[Յu3NŭqTAyfQ*Hg $Sw1{Xܥd<xWn6+2t>(M. iS0 F:EeR#);^a`'ܓ쎒,qo!wc}zU4xtyo QEpʅ2 ޹oy]W#\ʤ2Vh1]Q3Ѡa" ! 󋏣 H)&ܽ=/0 ;?a  ͕#Ľ,`=.L D]KaIb^g*-:ވ"Q n0U%IRh *%Ul"qH)Y* G[{, ڑ^\u $ M1CAd),H:yk!XгƔ\I(Еyn4b6,d}}sXW Z5A< ^е [:&j˚ڌ;`|*뒝vDJɇ`Yb f#B *)N?ݒZkBc7 טԁCZpD|5 blUi$ E›mQ^ [\Ho\v̕N0jEt1"#m&p*ZM&8ꛌ ̯s6-o?%v9ӲX 3>J32lx [3 շ#w >k xhaJ.`7DQRǸ矬XqLjbzDX y~qE;Jvo9LVx\{crSCZ1689f'θ$>r&=#Qȕ7,!߯V{ lS ]^),>sVjÞ;=sʢS"?,\k,XN, =9sgË=#ȂԢr/t$1I[î(c[mŶI_s+Q ڲs)"=fTjU&-_ͥk/*Q$*pp7;ۿ*7\,a3wnk'|O&ֿtoģp[)9)YtU7 vC?ioȢnifa3<" 3)KmB 0R#w0>E+A? ڋ" ۈ&IS@AwWQ[K:VHCrr7PxVnF}WU@*Rtb u"u &G6]fw)Y# |IgvyS(9sa۳O_%j/Wm?-pzDCy0ÅV7<я)h.DG_BY X~4<ɧO,N(ܢh3_aĭٲFR!bCv_ G0::Q1X؀^hN ߮`V %?mKڀa-8Cd"(dFVx,y/@]0#T;k䤈di4aPlSb;wB EItq s!8qKI1`yy'.CDiA~GgMq0vO$N(| ˗jCB͗Oh#t* ҬƉj<9qܱ\q kHYyKW[xy~m[Yx:?nJT>ҧ zg,9<#;`Z:NHGU[S`N|iԇ-A1-9^LPC z(b0VůW]AM+^_xQaBr$(ueRH WTvT6;-C|N>DC ԍRsfV+VC7EW:&0} NG9Qj|NxAS3_yq;DI GVȓ7g|!|a*L&?#Cqo,W.t<GgϮm̛ڛo _q fu6 3z݆YPyurAuJwUl5zgE}clv{EK3iN&祽KEMDlAx$IߧC+~x^MO繂DY*W%|A;HݮLix_Ҽ2%@Gl\LF}HyqM.JW_ `,*:,}#Z9(`K^ D%9#"iD$*[BǷy92Eϖ,] ? A{Rnw _ -b=ktQ 8.8>h8m>aM XXav1XI1VW3c K=nJ_44|{2&7-c^ Gl 2ɽDCF. c:FiePQٮarEӎn6rvX y񢁺tk{37ePxitO^9V4%p rT.tlMhvŰB%x &'W~͠);p" *xVQS6~W,~{8t87P`.̴MrÖ\IpL{W8q(!X~iFwYLaBf)2OEN*ܸ`|li/8>: yR)-Up`q $UT.h3 ))\/nFW %4 eT:XR3a.2- K HE,H wڷf!$Օ0 1{P']iNo }PAWŌ7VoVNO}tbƼ3ӊqwڛ9AA(䁮m֕cz,7_oJ9~.%"%y߷J|Kj> 5e|sY#jx~}Y~ùi-^H?X%rxM1A E#DLL AZe]L4$ HW5 *޷6NX$HltyI<9oSKD6 %)DT BbU,'y*vjh@M`*m|+$GK8)??~<,dŇfHfL\=J={hęh[${!9ȹUp W-5 d{Qw-9])j٭ο8oj>v~p.%[mo 'W<¶rGC<!O<<: BGVa_ xqu£<{J#PeUHNZ#';zp7^[xSQk@ ~Plp&y(X ^l%>b6Ig/ml~9,}O7LgX[r^iNT-f&al-u Gpu g=꼵4Z6ޖ%8 D .f| +CPz^ClpL0+Wg݀ib5|Zw. T*#cA9n81MMcojJX&ۀk#U [ѶJu54{ޤ8obS&WJxo|w8Di0MiQ*3DRbJ?~sH,R$*:'rIEy/.?w!bZ*eBũ,BܮTIkl<2*Oa&uy"ѴR]% l\U"eTM Y&>^hZO.@0lVB LߪRۤZ' ,VB2$3`XsT,L*O3XyBzmUȮ6`Y;oƓ-~XJוaQT.2.I8 ٳ(dZ.U\|IhCsdYʫ5 YT-dh-:W6@`*J@ jNxTU)!U ATrF쪖W) )2GH.U|#cVvʯQv\DQl-2Eq i:TME_K11 )3hO aA"b%N`a /p!^ $"[YTUjrHz.Pw啎CI ֠dEQO_<;:^t`eGA/!FQ!Kh%~ڼP%@qb j.g`%>z/^Oъ4OwGS+e{=d`x߃ʯgy9S)PqEi`d޴C0ݺ PQL|U,|8E]۶>1XVDx ^$F!iGjo}yK\_!duݷxX<((_,A-7]JP tE`FoQzC:+֬˂-EѵREt dM%OLj~:Tt31V21"9qJFDFm74*+Jqޔ8;[n#T]l@)s fdO8$'d s9#W!.Qu.b¸EijRGjT8ye bKvO!o%=[Bm3m[;ಕ2NkD*1GoGInGwI#vgҒ]U~1XQ؃&j,2Aհ4D][|8(f[9SFD)c`<$@Kݦ2Nҧ-wx/-q`!MȘhпP\&ŗ-ш1ɪ;)TvxH ·7 7Sqz&}/SZ.&tȣEZW EgۓUF# zuWo =!LO>p Ϯk`aC.X΀'(l~|wyGg<:@Ȯ,뭜FRuEj.Noc|T`#y#Nb2l+M8,HP,VE].9/5^ YlF X{3aڳy2o?(ڹmRDRRFxIٿ:@ {^S[ PC1k2aH-qp$t c(PDERoSNg@X I{ `Dt(8 ӧw^!~L 8:!S̗b#SL,j6AT% IO΃m$#Ge0dNɍ Y7>BLke7Nx`T_G! Ft-" $ q W`h!B+I?+`K&At[ďCM.Ş&0,4:^a7XDuSEM@{&}ǏɡMoMf(2­l>oE_Եmo"T~{n*LOmG]˦crMl>V݈uGb?"C^(U`B/5t\]`ϵABƘe+.mmS"!PE*V PͨUa 2hU 5X`\Ãahl㌙Zݶ j\Qsjs4v-SmJ\'7Wv ?V~B\xSpY1,jle0]Vmbbt(8ԥ`+ ~{3p$d>fu`'bzjZgJ-.1;tT"ew觭ؠ0i).АL_SʧE >b!w+7":),ke U39l ͛6S%c3@bؚU> pԝP( I(fHU;ۻG'4܅W5<0WM壟|}ה!F5ޘwrx߱8SÒc|_.ڇM b6bnLCVjnNg ,N~.EN|&͎"@dnF黓٧?}L"'+.@>чGgo02ƌkb$;'LV+)E5r=sO*%'Қ%Z6Zifz&"·&6`@8ͩ* =l3Mw4h1xQRoÐ)g O(΀e-<[Z:$HK&PTS2 7 ϖTcW Z anmU_MjOX= ѵH4s f)g#|U.mG; tδ,q):ooMlV5bKRAA7Xת^{ U{ Fqu,]َ? se4Z㿽mT%0]7ċ|@|IlήH q &^95a{\gt;tU'Ƴ9tw N@(CXkcb(A]W} b(p=K{5-Kp%d,"LBf.lgeFtB.Vhه3+l陵hFM1gn'/ńə Çf 2Zѡ8 -Jk Lʛ.bRbԞeə|6NeLb|J}6~{zVgIea˻ҖӖc[ѡF:R~U/ a){ڸ ךo3J/M1@MR"R'%>N6oʔZ8Pc>O7wav:,"ʑ IkcC .(1lX"LKK-ؒ4e:vSL4C"{"'7TreP/Q܀cty:[l "d̰J= 3^sdz_C$c5*'X=v͸{TVFJI墭`T7b-s!:#VjL@b"+L$3_  "a"K)~Vd챲t5yEϼ s M:ijv>o8NCb[UǩL. ͉ s`̬mGpCnP 8 >T]vx;* &Ai\qt/JE8jH^j+ mŽ JiȭB=`O% PbBd! 0(%4zRX5;X00 .a(^ {K$ NSURn rx#|-aʟ= z6"kkWm-//f0swΟ*FWNlzu&aNd% Jkw$7Y1jN %KJ*>㯥4v ~{XX}`W2ŃwY߯_At'qc놋J>gsv48(؞:j=Ą yP!8}|p&l6s(sd2Ȃ8v|{]JL5~11xPB&k؛WIŏ7p#ʎGZ릉5*[WzGE͐D]t\[Aw@Y Ľȁx񷹺/Ks_Ǘd%p!Qz;eNY)vNٶSz;emlVö4z[ޕŨ9Xd[meik5FZJ8 NOi8pjd+8ck=xQF߼њDl+l]qR=%2Y'H?/[^:}ʆEtHq|!LM5LS <7 Ne,gWDaPp!FeNAߘGŹxi۸{~)pMZ, %"Wid@x8mkF:ug GD]sL>>~Խ{* T/CMjaatTb 2ƕrmv2U!)B2S!O6*򑐄*Ss8I5y_fdP&or-.+gEC'lQا~.U^ }Y2X_Gy tD4( Ą!cEo,Ge| @5#.yo+zH?i|z%Y25=CBNs:ɺ`oKA&,C66%MpкDs!fߞwOO*/⑵)/E٩%UA & f :; & ""Hv72cAk}3atm I< >H؝D>, 'wa DRLe؛Sok$*t*X|&n:rZo}O0WSvTOj>}c6Č桃_TF x͠03!|T=A ti~M1Gn7WNktPLpMns4f*H3dPrb%P\M n}HʾC?'D&L\A/x%xJ8~QDh2j=wb!fw/xC-zs QSػ.[>+/4#n)ٰ$lC3 }.im@'5mT`y}R)%Z:A/V ָZ5}0lkyS8M_ :TC?˯uGwGtbf/m&׳4!ss1zU 6̓J+=3e(촴#k>yoBX̜s.v),ԕ{)TQ^՜eʻE JZ4 G P,IcO&H>`XNpZZmWȞoz4'1}%,ԝ)Q{zfj^Cm xe9t˅32/1Vxeo)_8nuQK[>zp"$@dmy==WCψ9w7T$x̣D Z2F[`sjd/X \ h#1M.JU{fi`?=Blȋ2i{kEŌgo^HP c!O*tx I`cHJk>j ?'~u`dIl5(ujdYC,q č+\b43Xg)3V5gIQ]'~?ߏXp'yֆ#UI;ԉ و~I(r8(2ÔO 6E;۳64QS^@442Vj<)=|"rTs:ۀfGKng5uN3e~U&I >D{q1/ iSeTO bꠁvȍ2aQ-xLIqF D%Ja8no 4`6;hT9b4ݑWj;\Ή3FL=oTN8\{o, 5ΜH!ZYC1>O>#Y<@}@zdo⣳+6`QMq2Ҁo-T/]G%?X])RkVj@c AY=Rۨ7F *i/ΞG K  Pk3&N|¶ ѺoS-H. HS ϋ7 B6 ^Ӵ=u{a4T@ݹB1 ć#2BB3 %% 86 VbQ,.WJq$ m: 8%-=ôgZnIR}0Ϲ}}5lZiݷyK 5#ڌ1ȱ21ϛ+GK&f!RsAf|ne]O 9ٹK&BЎE, )hHV8!6^D,SL}L5;"^ESp[~!'{\uN :ˬ6yDlϧLhq}}ocE,"ݤmzꠂ}jw;T)C']}1A3| +Q >X2фb,I\S72t4 NRTS|A.uCgG]T{umW R4o_J l* l2{wyk]LmEGӷ`#z[uEAλI@r2*Y 35S.\) *qÙ*P Qf٧D Ab~#$ ݩ "0kv`SnH}`rut;p!?mOc?m _g6+8j/^,aUoX X+l.>@ikvMXm\ A:,$Vzb/ 3YZ.$x(duta#kv '̆ި6ŤRšy?2O&# )u-Ƹ;Orm1Dh3E3;Y2"nJ |5Uw svo4BßqgDEI~~L,6"I w>}F0sAg0M2OjeuO^v-bw$yR I`{8pҭstӔv"z\f ]ŭ`-W_M"KW>OEf2R]I.z9gV٩ō^JAIQ q4a ɂ|*$- Z.m}kRPcY<<ٸu-i/Pw6X]tU[v<نј#6aFIp8OtyT>&q?funEf$,vpr@ZksDlR G0AQR _{u]_}װDqcmHS*sMo NchnC>fDvP2Y ]Xpm,Va M?L*7.TUrnSAGH6|K۪A`eh>V<1mxvߩN)ZK1%> #Vfߜ6 w96> }ujAA{uCSٲ֥iJ7!` XfUssDsЧ~j|FA!vwj{WY_5 0O&}xˤ#[{ PNc=$Q$o|hr4]0o!F*Usg 2Lj \ͩQY=X6=<j "A;CyfF_ F˶H *5,[A# ,P鎻k h?d]y?cL|xg9KoLK6%G|uiuN `}$k5l&T.!Q TZ`NE#|yɀ"S$kvYtjwj^7ËݎMj]:j/54&`/}j7GՆ47,Dάx340031QpN,J+ah6?i-qnT@pCC̜b#+ U/hƭRKL @(a}eڛY#YJ\2Q$^┇OevSBN-=) yeًqtSk+sd]δK+ڙ3Y;^)ꓢԛU/ $JФ,rIύJ&5) OPY00>ợh=(F){oc*ɦ ߹uAo9>Ճ*S9G urv5=)]!.LxX {io>%[z4iɆËQoEϨ}k,qsb%+.Ja}}ݸKbt Κ wgo?ߩ^bjZpPJmh8rmmot5m;WUc ]#Zs6^?53<  & 7;ܾ_!x/!&w 0|pV>2o3|ˬ6έc_!ݷ?g^Y_{h7 DO&9]= ^(L)}z*i4ݝ=>Ai$ܯ|R6_ vx340031QH,(+*fXܰ1-A 6HI-N) *cOq9&WoV*I-*/]\$tF}-ja()tj;k;亼NjկOu,6TIVq~He1 ܔࡰ5tɿGd^/i1x&e&L=:cKgE:6`ֵߝ a:ZàBU ZHQZ*y m)jh(h6/(D7rZwݶInM]-lbm2nG#0D1LNWC |6d＝eB+wIH@*:/H ۦHA4 ~a>L"^z"qEE_w̫+_m!ܦ][]di![-c(E g^9ʱ,9Q@ BRf-)-bTQ } 9&aث⚐l^%GFt&J‰7SuDh6ц;D&`XQJa -<\Nv5O=d![2 6kNKڵ}N=|6 H2r7aB!80E O\ Ⱥ&77f TBi^@7I}Q6PcR8 kW*̓[pÅTDŽ^l"}x:gRO|'sOX֗ D? KJ~&Dz$NMǯU]ZQ x~t{X:󀽁ʸw4m;F/Q+12-9:~4Zq RE0]LQNFXH$T=kh&nzhXmc;85ػȌP7ۍGmvitUx X<{&~in/n(2) >knx)PKl"|6~:0"QbQIsTn 5%vIsos;&:hf Xpuzdd55xY,*陸rhw8г >~sߖ [B5K3+ZBghfT @ZZWTS7;r&'pNW e-B>@11nL ҅޺E}87f*2aFe5J@\QL7RZ0cV8m&4򊥚$KE ]1BH:M̄.4JCJUS';C< lj>ݛ-6@+9GCo5ނL%UDv} m38)rc}mR73g[M! #ca qeq&4tck',SWpMgQfAO{F0j؆Fiz&t:4.<] 바% ;A;[3BBnJNXGehyR1&ˁ,'f8_걁 iЃq*@ `ϔIG.~؃t&3n< @ #W 01"xTV氋y-(DzFC2!rOADؾVm ¨t^b^o)bv[2<ֳ~8QB6&My]EkBШ`] ]ς6_m˳ o$BȎ2lSg7pLrnvhSq4Sٖ:t 26Y<+/W0wogc'bi=v5NY<+{l6x;<~ f Ǻ%x}WێG}WT4#"²6 !ܞif5NKrb؍:}eKZ|z~Y:nE?KEn'%>|FxSFWgg|A?%9ON{nu`vtuy~quT SPЮ NGo*pl4yu d.#S35[r@߉=U sg`lTmvʕcUn=[al]q΃uֺmM]hG>V ,߿x@FE`HE</Y`~Vyo4Ǫ--[-x,x!Z!!&FڇKAnnj;?#T0ᤔ=jL~n}`c`"$+FUC+]H1xһq /q# u-xgDIn Bm0kB)؎}2aQ;I>DBٳ)V1asПC0{Ue+"2`A-d=6[f3ћ~ ?۽&_"5R4 < ;E޶.gR>x0âq>IJ,у蒏nmqjь5bQ7uI;pѵ\5k,pzo,\jqv }r#+<@܇o7+)j)6b, Ý$ ̵I4<$b|՗[{Ek_jSjXnwdLj1jF27ս!ό͟"숏,`0pF#'X\/K:GéI7>^Toq)s%HdgR`Ty)OwRnw"&: ىOF. E'j̬V{('M-er22~=ls,14N)4ϾF),{W0P` Sh߷O xqo8{(ߜg:"qV^Hw>)_,TeXղ:H[p_ЦJG(+YFLU >'OTlYn[Nݽ1l׈قE϶7@;giW6Lcayz0'$$v_I c+8e]b%tm[&Cw Q~-OIfMX86n~ț(6Fgaqж5%cfsg#㉪q%1nOYgy3jv9lPG~k:n@G+ ɝ~ӋG#6Db2Бe^dS=h9ˬ.#o~j5QOoj>UH$3?BEjWJr M%)r fePLω\x}ydp5{:Ktx(82?Y㯲@ʧ8s?_^෤mIzyuOTK5xUn6h@+uI1]qP6` Z:E\hR!F`'ܓHJ w}i:ע@eq|Urh7IƼt 3ld<;}<#\o1WRB`ТrjJH*m@B݀COך; tCv¦FA΃W`w8Xҁ rݖx3p(ae*jU>Ѓx~!BZB^$MVl˷.wM Mn2`p2'%c]x_07(Nūr j;*d|{Fc6Zaj[nr~nGҴ+J4-Y'.{<˗踐AkѺNbo~|J7jԆJoz+觮(ӗiS Q"T~ܼS`Aͬnd$b#_|c 5PZ+3CW%C+X/ȪC4~Of!d 4^ry-Kz3ݶ#E}Ƽ;0zi-l^4I|ӊ选o OP?H}ۮb7C[?ǧg.6h6F$#iݣ {z?kHK+J-M0h|7b>ّɞXE$:X4mX3z4\,]s 2']X6F8@*{M:<ڛ4Ct/xKEE7qگ.} 5̶5rm-S=\.#Q]Ӌ] H Sp~TC  )YsGoO?F RlyQzcKiAݏ.WƆ7۴LxWo6??\ P4kNSY˚~` Izi}}}#)[ҭ D"ǻw}ΫBH#ޖBjV ѫ˯; OgYzn):yBz+X] "Ӻ&ggH #(S^)ٹYU :{k)M d^t֏ __]}GR%+OIܶf .E*yu}#.⮏j(pey }-UEÐGhXBj{0>OBGcVBFd".$+.7HigӊX{ ~}9BFbXs=Zի>Oål` Ǐ; M^qš'"1ٹ3X("WBx"y}q꒹A|",42z}m<k&G̋69cЃlB "^!p, \X&b>A$bx/xn~wB w)b 'c%,c/ ,^4/YĽ1[( C p t XI>j8f{E$ xDqNT&Bg/"lsG0D ,$h>/0i$ǖ@E&?1*o}7Ǎq}J}aqpńL - ~z}ejpzZ<#o(6~ "<Ӄ@ ?Q}~3Hrv/T(1 \,4X[`ͤiȋ+qщi:5={P'ZZϔ΄ >hYHNDU3>#O[H$WG$phPQ"6O W|4uiM׹\*~T(?>Ai2"CHHJZƎx1hwz!3C?!| 1X(wy[S*9r׆pʍ< @qYnDNP mv`ɣjKߧ xn @W}Dެ)⹈p٦/ѫ(.qʚZ@]HD踢#|@DAg $EH&9˜[B0"%e1 <Ɉtr/o̶>6oabz~KhҲR}x3*G)z14Yz&=c0xCY+8~W( |M]ez7 j" @i$|# ݆.*Ϧa:ʝŖQH**]!jy-ܢ%>cM*K#,v\M펝_7>w0]MoIK0+-Ԋˮ)#-KEJlKHZ}ZeɷĽ)qK6_ՀY z;'m pTru N;P~mhT5â+ $'ӸQˬaFkG1GSp M%nQOS?U.!}4k!8!aP9 mYH T<]OFYa#,OXUJ`5S7vS,g^*j 0 WkhGOnY.6†q6nMZL'}Є$D<ֳt9{ ؈yJg_F΄|(XJ`[[aԼ 9j @c{ʆ#Va zhkA}iJa8 :`` z&lYcё^}ZZ-VWSKIizkȑ< C]dc''l^0 8iEݓ'M׵hG.Ј, (yq`8=3 |R p]w a׌U96۱ʧJٵi_[Ѡ)Q!7Mݧ]6d?j.b%m…aۣ,<`P.}W{lIG11I#64CR`uo`u@ztMbyWWz!5kjj{!x5MgN˧Q9c`&麹43jvֶJ0- l,tGfܩ^xgD ${JGCFaXKc31 {4>l󡅛v]lUqM+[ -xxވHA5 s2Ke-kƨnC~R!fnȤfe3#OuHcV\kOk.۰}CsE+icj]EQ%}f }X> ѥ.jtQ)T+wgoFuyi6kg@鐾>.TKVeF'uMB){Ue|N) sES]+8=;uT((n)~h&4uB{LIlf/Nh^Vͅ s[J9V-$PaePd ѭi XZ}Oe Zq}(srsB,!xzC:vszy!Jv..Sf)tR+`94h=x+S*aXL,_0=U @czfW_6>)@mvu@|[ik.GKiJFǬ²g)IΝ;\?&;{B`"<\6\ؘ b;``]ٲVs]ΙuXmX([_N j%pĭVYG˺CVRF?XbU ~UJU2G*4P Og秗'W?DE۟xG p98}ap*Di'xX#VUuKYق0s6zTǑLq67bRO_};`8=雓ږG[Dz(uLE~9O+܀S>0+:0Jswv;j4.b("&Q1%]'[j맶<-Rڶ"be؆q7œ' MFmPc2: (vK2LQNƘb&k.ȤͻVˀH|c0( B2$df/f0Y?0DUK Q<%AKìY1_D_"D<[Z͕ak=4鰷J_R9h t_sȽXRSyUܻx Fz+ i.g""WVXʵlSKTPv[j*v-1 [r]RBWqPB!54qݷ$;<Tymr2ӗӗΎ2UsTǓX08|L 0|YWS-mqFE,~&}JRZFz*$N|u +WBb-~!K\DYV[%QJ+ XV"NA$ -hyYY*[Up%}@茗ZDWz꒶)u\N&i$RfHBĚJAj! # RdǿPiD3HH:(fU챊1yEKh8F%ZkT(%E$,}$2:2T'p$fHNrR%*Ӳ/ZFID8r? wǛIL+/vwͥQ$+)oP0Ʃ&#9O@GGk͘ !RyB0e_#,zyٔ׭ChԦR1VBڥʙuoٷq#|aZ?>AS`,9[+v*\FaMbdጮ!fbmg ]R Lӟ.(S 7=4%/זxRPtϡjHfٲ,@%3(yhy0Ici<,q}CnlѽK{r3vY]3G=ГҪ%)y5 vLjl\(;G8v0*09!`oSɻQ)4{t eTRyQv#dFv28Dy JCܱUS 8Q=(7H37j`O +L$-{Y)ybҨUE^'aQӵꀶqh̭L1qWtrO7467-偆bfͬ+j&7NkhFުBƸm?tUC\)$C3isffc3\ڍeʾyo7@2BӨRlu NY ;!ư+67oW44b51~;8Z7<]6, L6A8>\o|%65|$q}gi4. 8q̵b:{^A›_zOg'daް2bsvurչߤV־kV1*ӃU3xMn0 >Yt"(MM)0Ϊ;XBd8IQ {>4'VԊN~!s'ܳ|D86k tJ)ͩ4,jU&3qSz~dԙ4fo'vJG_K)t`.p㨣d%w:`s]jʊjlfVd6i:HA>R-<۳-=Je-)NArO SXPؚ'=rz07,RK׷wB^Ʃcn i+C^uD]j$ 5xMU\?p+eUhwp><Y[gq;m^.SƪtsqUDzy1fƊ^U?P%ίk'/c ޸xVnF}bQ)Ud7 Mo/ɡ dvVTA@?_/,)Qݸ qw~:z84rFÁBV%YcT30B ]#:_ta1E[,tj iOgQk05 ]N T77^2!e?$ T߿*$U`mq׆.*S8t]+uODy M#`_ݫx }*0tLG|QɔG69ED(8[HJȿ10~F$2ՃA>Gȟk>ѵnj 쉒iZe,){\$%)YSMee deV!}X;M8aI,t2 Jh\F@Ǻq'%P\/&UxSpKܤ۲_=35'C]PJn@}(Ti%NɁ;L_@@PP~:aH fL2eS7j_n.ˢ*xaM74wCQ5%Bng=n, \ u "mtjWȳ? unLhE3/B]z 9TW\ER-QOˑL`Ыh}ѾYgTb .䚪d.Cq]q;NVkSFL C6ѽ>ry9JqCv{9kBqt?P7tՂ+oKv(c MSKJHMp8r;g,: 덒Y0޹{/o9D]#p[e3fYNo8 F.}#LŝaA̢'8wSuCa!v X 2(xYr7}֤}XKrYJ健A P4*߰/"&*ۜn>NoJVsWKF+Jc|(nbۃ3s֖Ũ7v_t,/\DZjUnT9ӥ"f^қt~J03;)Δ+.V4N]AooNUHfLO| F̵*̭%R-WS]#&.×L-FIн);uիu|qr u&1Xș6=2ǫF$ӞfHPㄇi{W3cw !¥q .rw+lzuݾQ!aQO:U(\QrQdշ?ȵ+ȀAK4>5iX^1Me:S{C)*IW[G$\glDMP$8_@s[c6dTArd\+*?Ӹ`7NrC~Gas5Z;"4E^yPq.ӫ'). *4E?L%kEI)CXSZHzB(漮CkOɻM'#=H6" 2Bǟg3.ۘ7#3٩ h$G`N`>P i:YþƯe~_쥢[܅a"$ƲŰZ܌Hc6bNX F J:*O^^'`~H=K{;ǂy(n:l9&~UgayC"5Y{!Cas$p}pGS2tBRo*8j_L?11Ä@rkxn5@We2lj645Ż>pb XI(59ai3$Wińzk4]vϻDL!z#?Py;)g2a4qǰGOē70I!~ 4L^,#A.̇D29&~cCЁ`ϲ8T!dlMH.(͐qzkik`j'2l\ovʀtlQ`DC>-~9VyAW/EX֍ D[}Xh=֭9,ROY0MVq"pkvKa]٣#-7{5T1j졚 Y.#?\@[b} H} oXДZT8ߧ,&@JxJR$,3΂.6ijW%a@ev(OHZf/b{#A)DBa!fAl< Ѝx <#7p nXRF #P" dj'8%iJ5x } X޻'~9YLT˙ҵW) 0E $p /e/ c)Ú}LA"8F:GǷhT?T;m+{i<:I$vF@8'': N>vto0*~^OD\UWFYZbϤYUo s' YQ+d CKt%Yeo #N#З8ۈ^jpBɣ~~D9u>W_h//aIҡVD`Rk1Hӏ} Vr~rr|ײ Fzd3HT8w?f chӿ5Mu)}%jRBNV `GS_;'7H<^"W Yo?OX*aH!HP[_9-ŔΔX_AO_EftHKvˇJ q"cˡ$2LWu *]U; #XE*7ʤI$iV%LB6j˾\+="&Vqxݕ#0jX[}Q]u՟uPͺW]-] Q$JǨqPZ5~O܇ZUJMR6kQ#-Bro#0GK]@A6~(S}D[:?6`ݺn It+VYFIK%` ,k;q3BF4ÂLk4l#DD̘:Z:Z߉`U" $"8~vJhuGXt[d2] S=T.i1YZ/=)?fDžp!ɻ@D8Į5Rx<\i[ϩ9pdjnKvHsZްP̲zVU>.M}lm=.b#Ip*^#W588M9>!IW.C2ӿ2GZ@2 x}rǵo)8% q*6*ZeȤu6ͲEUyS $g}3e%q&f|UoM^ş?s-=Gmż-jjj}O)!o]靯wͼpzQd4 5Ūms/hn^xťk][ 8S MQ][kmթOz*&WoMc8|+}[ WOyϛ^,ܶh0\MsNzwZ1w[u { 0yԺX/szv{V)gj5eASMg%`-!ЦU|1ӣn4^U;_kzE[ 5K4-rIWv|UQa4Mv\ݴW4 _NVvc&f[7ף};I`l W8}dmwuo {W) vh<kv벺r^`-$MoQSRS&_<*+^ BEQ ȘJwZ+c 3€rlhU톖@a|mW\"F+;OQ)k_OM'ϛrD_gX¶ƥ_qJ/k^orJ9MU2Mfk0aħ9 "+TR 5׆H4,b*:/mT.g#<򺉢;y^DKARf~B3!=0Р3R][ztx &m mj2!Oꮩ =-o譯}"Bȡ1Wt/`p(2+JlOfkYGnswsH6-*D]’oKRuNw""hm?a,A@0~bN8ߎDDyFu82DCv&{D@GĽyfpO=#Uy=vJ_h@_'?Y?Nd S{92B 4\eW_=2}f>"SV(  j&#\0JGwCY.#4өiYgp K %f|&;u^{ji@X[x5><N6(OP~m" vUQ, 4$JrS3 ~қH?|G:v'ns"G b55!K7.H m"N)7I\q,:7Z$:Y z !=/[^ Kn}m@'\OHOo +W 2uP'^8vsqҳ1`%~FG\Q Jê}NA3PEȺU=p j;4ʖ"DdXg@$J g3|k(sȀ4k%4“ud确=Gx/F:԰!桠͊^,1QRlTP(@KYR55Yg _|`R?Yu =f a.PP%BW%L L8%%üز9(KDg<bK^Hf N[ѦY6ܒ6 $!|'/=0QxCzjZUY<]&'>Eh"1ceO_QI|SNfts}aU&:ݳ`K*tf~7l ;UW#FL'ef a=f;vAqelBt@YL D? }^߮Pe?C 7Ħ>钾vC5\GM]2T6W={N._\bdB49hrJ:Xi|ʰLoTG~H g,yBg}AMNJUCT+`b}"4'2I`갌–x7W#O@$!eN z.>- dwsAi62& NH/Ҽ) cKD*<{ L@kg_Z9Hwm` fx׳݆ZP?ҁб/+lj9-ayшgš &#%1OmMTlP0F/l䝪,#a oTt4x8yh<]bx/M<ђb>觨5/z"N_&jhScQ+Owuv ${VUL,Np"Wp-R8aa~^kSq"&9!Ds&'P*TfzNΞ8y3J2X.H2TiCC9GuᮞpM g-Q& ޳QVqheO̠d6QԌvGu{qan[$JsЈJa]f&YxA0a}ts~[ZX"(y(:GT }vI DYoBƐҬ9̊O~8sܬ[ @BӠrײՎFOc7S~{Ի<~{#CyxOR,,ts]dDwb籜&2^IgIRj%(c$  EPp`{zW(vFPوAڎ(wxu,W!"._tNM-he3meED-sL\([zB*c o hFxC3!I28z7n5$x=Jz`GVj1.ˠ6Q[0ۆX1F0)xKSxeq7#Hb)hSY| Þ{x% pLޘNDTҾȠd3""yWuuw>!G!욄AAT<#I\ITGfqc% Akܱt,"b>csr pAkћ^b9N͑ ," qw 8<Ai_;= 6Cphlx#WXW|i6|^sˆ6A~9/?0`Si&a 3] .Ƕ!H0d@gae?Cԃ~ƃ<*nxbBh!gsc@դw;x!H)͛E%[ٙLx'jNΎ:`_#L'3G:PUOUNfr3['"e^w@;:SC|T %#Ru6{BU&05|$IV;D!x7D$*^`{^Ć}vȀmAչ cd8"gg* .תf*Q=/ c {bU iTD k_O.E`v(q$,$hg[CλaA܅Fe{hk@dY ^dAR5}u HHz7QŅ"ݨҾ:ͷ2_ ^9521LSA_6;Y{O.ju]jEo̤]WۂPH< 󺡫d%KBPUeyF r$1՞u#*BnuUUOZ2xrn3Y @b7+} -ڍՈDK߫٠VR\Fl#YJc0رe|9&p@%qV^W_- 49;m뜺"eFvc=QB*L&Ӱeί徜[0ۮO2؉lUn!GA}"5lDa'<;- 'L`Y9(+DUXb[P nrIX:x!էsHw5/vzo5,#sJ&"A;D_ [::sȵy\X;eMhad4iMi kGN+k2ʲ/&QW+FaN0̘r7ǐ8\kT?K2/{;֍i"8 G4KK,hH)zۻ ⃷ |]C럏߼dRcTH?x.u7z PbIQK9OB I|v"fʺ1z~kA ´n /"S9OR~? #W 25R~ο80kl8՗X #α-:9&3%9/UiP#Ny)ڡ1JϪG-0 Kzm ׉Ў ΫCfd&7L, SU3 izѐ^ubV $!;\p#E'L5k.[L9ijXfl^{|Plyypkݚ=-G$%pҗtF 6ys{ E|xw!xaSX^GE9J̯iIUw=hZ2~AK *;PoTk?t+R_HKfļ+p\瘜QM#nݱZ~j,Lxd^.zf.*$@c7Y$]H HYKE4'Vҗt'il u m~?K#2gܧ"?502G0ՄcxM5Xxk; +܎-F$ɖ' Бw v_1&1L `W`ҧYj1f+Mb{RiAxZZ.K+SgJըx{G& ͢)4z]W]M19{hWDRBMp?.z{y2C WVG[-!iވ֛C4Bega:c|o>4Yڷw0"WZ'Q!*O'TA' dz L)jNx-ݷ8Xf^BrQX/ɐ8a9RcnCƈx#}yȾU6-coHK*>Iؐ8 sY{!k/CܮwCvfp5ԡJYǡ.})$?de|H`@wCj%av"$6šЉpJ,I5CиtbwX(Ҵ|T=o_%1Ƥ{vN/Hj˂V9HXCjn-āA-«]jtEHCSd.T8|2($><{I |WwIǃyń wK+c"m=qGO,.6*PsFʸzm_dĉ5Xjؓ7xP-aiE { eeeE%e-xB TbƑl;fw#?#g#ýȰ5z*HᎄGDvט tG_ ok(;=AY$ gj0Uw?}qjZ3J CAB$_mbIΓ+h>H}Cux߀r]0{]r})Zv*ydr3Z̟H.tʊ&)RJ8oP*+Hur]F|X85䈕6-ܱ%fUewir70c4$p&]mDx@1 ٲx%n8coh4%|=k Vp##ص̧%@8k~Uά!U1T$ )Oh-nFXirۓݛ>B< 7 ~r軯eqSp>pu|SG՜r9(ɮDoMӷ3bԺe _Z'F]s!{Ta4 <$A*gJر[ D8A008^.r# yeQuުR,BЈ? dV@1W)gJ^Wt«ÌS߄t4W)=Y,1.+%b.:]6u\ag=)@~CjNVp-*dZ#Η72\tf! "K&9k]~ N-dZkΒ]}po=rmhYJArY5'مU^klGwr`󹿃žsO)e68WLݍmn{<~xK] O#kAX(\AŘ%BqOߟ;F\FO.llE1x`'QnC! ~s_ $@'8XƸ1sIVcu|Shp) N qYT6jzv:w^KšASt6'ōm+kav9pJ`W7R ^MWKUΤ/+:Dr&+)/|ۻnB2drQn930Tk%5D9 D7`eF%iI&H+Cof[%%t+tivͿ=[݋)߅$~;K,~kZcöKN^Qkְ Zo} ,=mdH~mp'y"8y1wYLRlC/&>BmOı֪7$/& <~[6y*o$D-6: #d@3˂lDR531rFXԋ"UKe֡z!. m2L\< ~C#?c x\vHr-=E/r<&- x78p,ɫmXnd$V HG!yWAR&Eշ<Vϕ.xgE:;^W}J?Ɖ<("NG 賷KGq50MS ED߽ᎃ*HLA^vIۈ^I4< `ZdC*s1o;:INߜ;RF^c^@@a-2NL,6 iNÅA>{ES:0 r x'Y f m3TU-ڎb?ד0.:}r;oM`?(;w6j?![^TFٛdKBNV C]S 'O40JƘYUGud2ݞ>85cP/0w21tϋxrFR}$WP%F4Hq%{vxN8^9imHVaNd5~2a fCK;I5Bi>q%8 ,:% 'x6Y< Q~^x4j%cGu+=&C|}z>qKz_\Pdp0tZY & !ee D/a>GVłd_)0N#2De3Γ:Ңp*"%)'mn2E{ u)VLT?;c{M6OE55)l]9)NpOOς39.Lh sD >y_d c(-eRjx[֗Hۍ츯RyfSr7o&߾c-F'oۋny׷z/z[/ZmpuAtfQR ^7ӻjpVEnj[zPs2v@ U@^h3{ ?|t8ta.DzH mW~zGtG-g91UCzltw|h[-m %ZOGr5q pvd (۷FOˀiVsVF~!0b@"7Y淌~9 \="_;a0D֒2Nuc8P;{Xg%>ËɿnI>`LLכ[vd<ˣy_\N Yl3{l'a'%O150ٺs/[±<캍5]7΃.BWS"BrL%&ȰۚjLqMgԾ=,I;-R| Ayψt0.O+cIX,"$aV3d#H ~˾M[d#P]Țe6BG= Kcz QcGpM&TN"GƌZtCNMy,r~dH@fE.!oD*kۜ!Oirkj\ͨ [Qy*w ,K]AZ!s1]i"O9^}CjU/[ِte#5'j3QigS*}ً=#XMY|%5(]+CZ|ZNJf=)Iê 4 xb)VdJ1dGK<ՔZ5.b%7Tٖ 9.H[bbov/Ůd"B׋xǶa 58X9zĘCelVJjDÉt0p=Ia+x).xo՜p<9y/*p)[RLc\x )>1-aO >-C goOHql}sZj޸!qu C^x5p  l^QRT[5ֱ0=hl|>.)QRJ x#2N*sTr#z 7鑞 tI%W* <\tQd/gKj2 XkornF[$à  ^MK~/fz&^{l럒"l sv={IcdNkrK@ s8FD- @TNhP TOպFHMU5Bh Hv9)񐜭v%c6H(s9J8 8+7 N YEbsR6iGiBqŨ,Ge}ujMĽ5#dW4s )ɪd*I@oB@5r`(dM9& 5bij<ˊR mh ";-@lHٌt3ksM3+,X[ P7CoĐ/A6)& \Wͫ"@~clg*ͷ+oдmVdA3pa*[ hOB+x0An8ځ3>1~0M;Uh<p "[vh$:9dZx[m p Ns]eW)TAi]gYjmds-xlYGA2$l5BAGrlL' ./M?8 0(cfyZJK&3 TϪ8I^@Hfz6i6`i&1LFdP6&[^J0(9c dKm^ɝAMHQ*u- s1[}r%!'.|O=3]54jEy|m(~~8pe񥾭';1T+|9|l9,ȭοN27WRCq$IrȘ8|dz~`̀}ƫgOᶓ]ƄO͓D%L>uJa)rI·?8ۯm_"8/τcKj`hZfLW Վ%Ss..4E=_n7{|ClJH-,`S&6_}m-8U WxtؒNs2ѥTP<}8:~s/GNb6T&O-1)i=6Ap] Ht\'p*0rmtxr)wX6p 5 R[Y;`-zDIYd yOv|urȅKNWhIrZRcP̙6Lrom%J c:rk;2}c S2p.RD{1 Bɯ&YͻYA~89h\/MmS\$0!p=5twqQ3DT=4mPcĊZX=="!n׈?ܿiYFw5?AfFmU[)evW Έem5`IE}{֊hVMWcf,M9lH3U BTs2tܓ`wύk_d m^[ seex{ V5 X4> Vwj"XjaWrt:bezd T+F0.~!Ki>1׸,mſk\]-m&1&8f1q3o܅ 1H#ܟ = 2#bsL\nnE)]/FDyk"l`IN`!+X#'&iL41[9z^Sݼx\rF[zYV-wVdG2ee C 0(Rj^=}_ RMY$0ӿyhxZS2y[ٲZ_OƓL\QyVyŏ6qn/Fcy>"b~Kw'|;JR|PQj c2u|8M ͟IW&w77_?;>f̫iaMufK JSE 0D8|b{f`iraKrbM%YD6f*350Ӏ .iU1E>fpI HgYI|A|=3;Kg&)яSlawQO"Ky$0&n"!Ypʡjl"YIp8_M"_[">e&'?zC] 1o!c9GÊ /t'qbPX-/u`l4z n@n3eF$kͳo]9Ӹ|m,H{'YCx@q rEV0)s3wNy7jaWX e?FEq= bXM4\P,*y'/BDx@/b$4ÉbێuabErMPmXG!NiY ։iVUa)zX< v0)cQ5K:҂{7"yUo<'F5oa; K|<쟓Q0:&|Z ay{iNhCeV%/76;axtNөX"Z1AI;_f9wYڊ\1SP[lr>eb31ˋs_1ungEԝTX-]Ej,yߝU0J B(֣8F ?VPRڒ`a %8WGLn׃2\vw`٥v<%&bIg2_EE5<mbj&|UټެA%ʿ=P oآ PpV,IUOhzr4sjEַV 8zbAN2X8Z>(1.:kײJc(8ނm]F-P{O/#66*0۞j3(FƍLWljK. )n# }q]$w.!7]Ԉ8(q g.!Ѣ70uM^?a)ΞiwWd–VJzf8E]ƆϤJ0U缼:$gn5O[Fʊr=7T3xJ_1oQ$"7',@`s`bl-)A0B)l;QD(^AX O *y#_4_g5ݯ$g 707޿q(u{\$L2ٳFÜQ^«#swpq}3N)Z{E4>2n-;` Rf*D*TXR1t̸ KO?<++ t~$Q\[CŒ#KdBSsx-1IɬP(Y{RG@񪽣z]1-v_ wH侴q~<%:iَ ^-'!viϯoT1i4)%Zcx}X/݈M4 j%B7qnN dh.)&U'oч+vmJֹWK :eq BlDoP1#(K':K댧60#WYCR( }"Y;X`!95IV;pm9M! x4#amdOs߇ь`9&n?qL|L2#u pio=]-٥l8RLie:@7  .(ϓI Qj{3Ne"ߥ ߂GO,H/S{5З̡˥6kxqGɖsR@%5*%h8n9MYNPꏴ_W05qG^/-ҵaDnlC*me":oýAtpP^oj]eMק$W^A^5^UcdALNnݯ)Z"4-"OpoW_|q' |j% !ݑ}t|##EpYBdᣯ/^l[:kI''iR%u-%A*[vO / Q&˞˚VFdv JxQG}3~9Ӽ̓7D_k!5B$QӺ>+SfT7` fg2:%JpYWa;27=AժCuAXMMTBd VOmJ>K7..=ot1>4oH%`xAz'+0IaVCd7+% xPRQ8',ˀ!&zQr0'|O< O|UًGn>"b[m̎R`-,ԂOEd ׿޶Qo|y+gLF6.F=:%/P^@f tgtVX .~&'7^q8j{̫×OUѬuݨa$fkwiÚf[,AYz;[$ⱥpTH-y'q-ldTSEuK*4ک~ÎE`hWoj.e͙ώ.ڍ6UO3PlXA]'%6 -ihFޏ qUkhbaGpOuȆHȐ1i@X2Xho/zmPN !BIӇۚ p%х):B~ -KBwԡ;^z)Q)Nyt=!zخ|CsqD !m%?ה҆s`Ӛޚ"s6t.?jrՃ^aT2jr׼k+9?> {}z^w^aX\q°= kuYj^"c|b{El6Hlo`hZX}m:qi57WM*׻yk؜M]k/a7A^]PhQn,3ڪ䓇u.cw_r`+yo2e^(bĢo_ӘMgkr}lܼ]yG}JII'Qlf3JmKO K{^j)8j<|i9 dnDݢCv۵ׇs' "ެEI;su,kz$"?`޴öV n|Y #@YETΤz/V=3CX|X#bgտݺu|P+9\,i;%kmK掺AjAz a zV L.0V֌ߞ}k'u_c|E4Wo-:yo a0=ȰFC"(?ι]9'Y7͂VJuHJ94pBh\BC^I{]A1컼SOo>ʶϻ^D>4sˠR`5p^ ^o|ћ7qW_F&kk=-cuO߫EYWbկ-^_es2,ދCeO j[kAr1ĀԈ.\!!f =с̘`/2yh66|mރA nl@}VOay`$Mm9f,sIGzF&}l/#7ygɄjHw¸6Y8 nr{d* v yty r^#*%;2A9a`dw{{⁐-4EhQҔD/ p'n7G`m4%DQ%Iu;.#S#_M5 Ýsss8F zRti,&Xjuai~Xer;EXk$ Zܦ{Ӽ*>Gtslv}fD;"2iPa㎌53ЛM3;g5hTj1aw p/,u5+U= C$<{qVgAw?V\Q'ev=wrg#s6K[6'٢Yt֣_EYeO>˹!S~;E[ɥ;O fh8 \{uxq?Sy43~tr-;UO < eYbuJN<[}a(Ju~"(G^$`XJn^B~yg95fj >XroH=+R>Jtn ޲w:V7|dIyW fnVŊsW|SxVn6=~ԗJW.`$)A ;EADiYkIq~aoμyAշKT,GQGw>-ugB>PkIRj1R3zc;N8ͫSE6&F!Ds'Y2 MG 0'սVvHEںFfIw[d#͛1R<^k*>$+hƺFnWV\~BAj@ƊoQZ?M{2!C8deM!B xfy)M*r.U4T}FEˊ^s0޲5>2=16<r֩esR!1p())Zm$Jaf<(% vB7^ǠB^L HnLV> MT9 %$8EI tS܁٧,(mvf ]s]h^SvWϕFo ;G栊4g D-&&I@]FLp)[UCظ8~rH2b$tFxĽe!!Oz8htZ؄0z\r3l"m(koLLj"\&7ڃSe)I=:K1GTi1Vr고nb2Iә/8i`*§䨗T8ȻOkq}z ]sS , O;6{#糰(w~'l"XL~@\-H zIqo؈XCRYY\b |g},MĻPD#TSk} Q1?SWՁ9宗ɾ lۿN% T0qaK/./) 7mә~8Es?.,ÕyWt=W+Öb|ײAl*fNbUU@˽x=package zip_test import ( "context" "errors" "sync" "sync/atomic" "testing" "time" "github.com/zap-proto/zip" ) // TestOnShutdown_LIFO proves hooks drain in reverse registration order // (reverse mount order) — the natural teardown of dependencies. Hooks run // sequentially in Shutdown's goroutine, so a plain slice needs no lock. func TestOnShutdown_LIFO(t *testing.T) { app := zip.New(zip.Config{DisableStartupMessage: true}) var order []int for i := 1; i <= 3; i++ { i := i app.OnShutdown(func(context.Context) error { order = append(order, i) return nil }) } if err := app.Shutdown(); err != nil { t.Fatalf("Shutdown: %v", err) } want := []int{3, 2, 1} if len(order) != len(want) { t.Fatalf("order=%v, want %v", order, want) } for i := range want { if order[i] != want[i] { t.Fatalf("order=%v, want %v (LIFO teardown)", order, want) } } } // TestOnShutdown_JoinErrors proves every hook runs even when an earlier one // fails, and that all failures surface via errors.Join. func TestOnShutdown_JoinErrors(t *testing.T) { app := zip.New(zip.Config{DisableStartupMessage: true}) errBoom := errors.New("boom") errBang := errors.New("bang") var ran int app.OnShutdown(func(context.Context) error { ran++; return errBoom }) app.OnShutdown(func(context.Context) error { ran++; return nil }) app.OnShutdown(func(context.Context) error { ran++; return errBang }) err := app.Shutdown() if ran != 3 { t.Fatalf("ran=%d, want 3 (a failing hook must not stop the others)", ran) } if !errors.Is(err, errBoom) || !errors.Is(err, errBang) { t.Fatalf("err=%v, want both boom and bang joined", err) } } // TestShutdown_Idempotent proves the once-guard: a second call — even through // the other entry point — does not re-run hooks and returns nil. func TestShutdown_Idempotent(t *testing.T) { app := zip.New(zip.Config{DisableStartupMessage: true}) var ran int app.OnShutdown(func(context.Context) error { ran++; return nil }) if err := app.Shutdown(); err != nil { t.Fatalf("Shutdown #1: %v", err) } if err := app.ShutdownWithContext(context.Background()); err != nil { t.Fatalf("Shutdown #2: %v", err) } if ran != 1 { t.Fatalf("ran=%d, want 1 (hooks run once across both entry points)", ran) } } // TestShutdownWithContext_PropagatesCtx proves ShutdownWithContext passes its // context — both values and deadline — through to every hook. func TestShutdownWithContext_PropagatesCtx(t *testing.T) { app := zip.New(zip.Config{DisableStartupMessage: true}) type ctxKey string const key ctxKey = "k" deadline := time.Now().Add(30 * time.Second) ctx, cancel := context.WithDeadline( context.WithValue(context.Background(), key, "v"), deadline) defer cancel() var gotVal any var gotDeadline time.Time var gotOK bool app.OnShutdown(func(hctx context.Context) error { gotVal = hctx.Value(key) gotDeadline, gotOK = hctx.Deadline() return nil }) if err := app.ShutdownWithContext(ctx); err != nil { t.Fatalf("ShutdownWithContext: %v", err) } if gotVal != "v" { t.Fatalf("hook ctx value=%v, want %q", gotVal, "v") } if !gotOK || !gotDeadline.Equal(deadline) { t.Fatalf("hook ctx deadline=%v ok=%v, want %v", gotDeadline, gotOK, deadline) } } // TestOnShutdown_AfterShutdownDropped proves registering after Shutdown has // begun is a no-op: the hook never runs and nothing panics. func TestOnShutdown_AfterShutdownDropped(t *testing.T) { app := zip.New(zip.Config{DisableStartupMessage: true}) if err := app.Shutdown(); err != nil { t.Fatalf("Shutdown: %v", err) } var ran bool app.OnShutdown(func(context.Context) error { ran = true; return nil }) // must not panic // A subsequent Shutdown must not resurrect the late hook either. if err := app.Shutdown(); err != nil { t.Fatalf("Shutdown #2: %v", err) } if ran { t.Fatal("late-registered hook ran; want dropped") } } // TestOnShutdown_NilIgnored proves a nil hook is ignored at registration and // never panics the drain loop. func TestOnShutdown_NilIgnored(t *testing.T) { app := zip.New(zip.Config{DisableStartupMessage: true}) app.OnShutdown(nil) if err := app.Shutdown(); err != nil { t.Fatalf("Shutdown: %v", err) } } // TestOnShutdown_ConcurrentRegistration proves registration is safe under // concurrency (meaningful under -race): every hook registered before Shutdown // runs exactly once. func TestOnShutdown_ConcurrentRegistration(t *testing.T) { app := zip.New(zip.Config{DisableStartupMessage: true}) const n = 50 var count int64 var wg sync.WaitGroup wg.Add(n) for i := 0; i < n; i++ { go func() { defer wg.Done() app.OnShutdown(func(context.Context) error { atomic.AddInt64(&count, 1) return nil }) }() } wg.Wait() if err := app.Shutdown(); err != nil { t.Fatalf("Shutdown: %v", err) } if count != n { t.Fatalf("count=%d, want %d (all concurrently-registered hooks run)", count, n) } } dJx^package zip import ( "os" "path/filepath" "strings" "testing" ) // TestALongSocketNamesTheLimitRatherThanTheErrno is the failure this cost an // afternoon to read once already: the sibling's address is DERIVED, so a caller // that picked a fine socket path can still be over the limit by the five bytes // the suffix adds — and the bind reported "invalid argument", which names neither // the limit nor the length. func TestALongSocketNamesTheLimitRatherThanTheErrno(t *testing.T) { dir, err := os.MkdirTemp("", "z") if err != nil { t.Fatal(err) } t.Cleanup(func() { _ = os.RemoveAll(dir) }) // Long enough that the derived ".http" sibling cannot fit. long := filepath.Join(dir, strings.Repeat("n", 120)+".sock") app := New(Config{DisableStartupMessage: true}) got := app.listenOn([]string{long}) if got == nil { t.Fatal("a socket past the limit must be refused") } msg := got.Error() for _, want := range []string{"limit", "sibling"} { if !strings.Contains(msg, want) { t.Errorf("error = %q, want it to mention %q", msg, want) } } if strings.Contains(msg, "invalid argument") { t.Errorf("error = %q — that is the errno this replaces", msg) } } =.xmRn0 }nM64 (JZqnJ6J||}4Eg;gY0&QRK3>cJml/f@Mn N&V2yRk܄Ss86=j}nQ]=i-b IG6^ER5 -NpEi%&!2U58HFYAkVӪ@pO x 5DIR6Y@s1W9.!qGBn rDˢle&2exNz4?BM6,L)@pTQ>k֤ҙXmj) hVܽe'w\99Ƥ#NゆNW-.. 5=[OQ\Ԋ~0v),Xsڂ)A *=.n/{rdr$S[<5zgʥN쎐Y7T,Ȥm6[G|GrC*LOQd 3Ra7CUј#f( aL#6;N4d F4iq'Ei) "SdỦ#P`o$O'X$LP<&\Qzer?:gm <CIl,?=_<*B勬(<@@LZHV(v2]"PBXSd(go#_VS(><61j4ptޕ[}zc)ߢ-д9ҽICOy} xOj˓ w G}R(wC9_'.6_.S'ѹRp ,x 'Hr3>KØ-IV5k|*䶐yK7)i`uG52Ɯhq@ǝ?w } *KƾH 7%9%4LoJV_c?nį,{a%儁QC-.eRؙ,r m`vLXWH(^Fq[Wcae -;z¿%yHH˪Y);,5X-zdQq< c  ;*H;3y삛> Nbt>..O5D:*VabzlV?i-ܜ1>|S&AbFD?rc 5\zq3+ТO\_?_f0*Rv-)c" {"jWȐ߆7v.c {vC.5q5/VϽɎ|X59of&5?GN*3kXSrc- vO? nW!K``w,^#vIӂ#b%zLj D1Xz#Dhr{:z^^Tg^r7ZW\||M)ǜ%FJeq+,^r3`\p l c,nVr_(ʑc{^&e54Fq­ڻ^o̗NjĈ[_qW$+Log0TH>|QK C,W|WI 3ߨ>ua6遲jn(("8IbAFxXNGOq)` R hAJ 2DQ!4G^lvfm AUIYc$JEJٝ9wΡH䒮Uyurn$&ig:O~t=WnX;o]r3[Z-C8P)Ks.%~iHiu,\-YBM%$ {w ap9] TKG;?QsPHVZ鏿Yܢ=:46֑0,F5L3S݀Z,&6T`l1d_2dU!+f4Jrl FCUeYRr`*X'5Ǻ:臘YWݴV\HD[+ɪ=2zN JmjO<# '6.- /uf$/'f"E+JSֺR!g14H9'\VJ&fHe%?J D-9Ȕ+iN%"k c_V434 }mA!T*tf7*bb*kCZ9gtb=xȵ(Kv.9X12cb5CM|+ F@F⣾z`x֓Y/_ZBjΡB2{PH(Ji?[']J8eE^g]ւAvZr=0t {)+,8vf((H}.Pmz$k]Q#NmMvڋ'{N6dmV'rgΆ`yPѻ`mCu/:Z3p* 1qsG%BP4.+ǀ E`"]\O}ǘ>S]FX&Qܷ7j5X 'h . 11^ҘEb F &/և!P1. (2PP5@V2c@L r$A tvzr0k@Uֽ)&൩ЁYX4LNG.A q"d4ma~IQ5`WNSzsP| .;F8XRmĜ_4?=KA03z)~05v4~VjyÄL40)R[F`0))C+#|%R fϿh{)pγK'@ײ弑Zi HaBق'Fˍ7Zz>$F6 n0鼐ePM1%Pub$m<ń ~JM1Bs)d5hX 7?Ř9ѱӺ_=S7AL"JV4v64~ڔ2 5n0wR?S[ Qxۥ@uB2gq~rKfF6g0fĂT <yu7*\-跹͌qY-he/Yx>%!#4PTockqUpockqockqR ockq/)xXmo6 V#.m"Y$YC[liI줻G/_r )Yv]>D 933e~'J^r~0(^$7ګ{U;/$"=(}^E3r.o8& X,( }D]IB:a|om󲖕"UEtɥ"imP Y[[e\BW7$ԅ&xhmCAT52zr!#՝^ټ *Zғ1JeI9s *> .\H0=I'X^adZO7  t))[khGdRj ɉ|Idoa6D2s'W0ݬ9S/^Ơn%+LתM yv)=XLFǰ6{cO1QGNLs/bFnz;=;͑P;$cI!VjeCK:gxD4}ב #3zh;;(2,H/#&o~?Z=$(W"?.=>KXWNd.SQva4_Jc.3򜑴Á+,I,Cۨ֩l` {umHsM`[zJ-Dv`OQ+m+#ŭ-xjW"u+NzX+ FwtSSsAReB_(,\\Zn@'rAګK1߅$[- [\*# "ü =g )CK=wN'q+Y.)uI|F.nNNOD >£zMq\V9фb GcT &VؼQEUmWKfsxrn,Sc&VHB[E* ivY:G!1΢ǢMRUE^o^*( yN=; *P~ˮ:M~z%a&76= mEt}q@n[Lfʳ//ҿ~H@ 45i_ڽN[&X&K}X0].VoOӭ][M6yef>nڮOPu|+[_,gʧd̀:V]gF?{Kǃi(tmsM;wLt-hJ&tsh鑿ӦmZB^sC 4<.EM-khIurJ4m 5,PmIn,K3~Aq+5jou'w~X}fsY}.7g&lӎԛzvyOsyN2ӿ0xZ#E]~h4mAHE=ШؕP83T:3'#mw-}վþ> O2vA*nsύp;}kO캩N%y菵]e݊6VE_[ۭ64t3kںT4|x4suf/֕nZTݴSδ[ wv3Qwߘ}ŦʒzE:e33F'%=]sZq7:۬Mϙ6Ucu98, 4=!9ͷ)H7#Fv5а7QṁN?L7ܔ޲~`'9U9ڭL%ei–GªS捅^ܘfVNJ g^5. O!yneJ:Wu>WM7Rui.g抜hwږXv&OG=k6S9O5OL'Yei ȡWfQ&^*3@[KvJG/T"%(pJmb?$27=bui֧\8hu2rwgq&ɧq$IAYY"qBPZr$H^X岨ԦĮ5fqhn2ۏZ7NE鏎2Z"Ki"@HS"ȧJ %r4-9VAKQw`T]SjMA]׭dpB[<`52eɚ:Z}zzگ} og&{4\Sana&FΡú7S_>_*f׶ 'te-c(e-=R i>>]zrcVUaVhBS^Vu)oy1Kj `e֔LϹ6)"+A9DbΘ;J;})i p)]ͥDs&ZMk_/!CAqK@ VRȔI}B:Fa` *.Uה @oN-"uBH-Ma(1CXny)SNiGHV*+n(  _Ņ(O?@Ûgł{xv0Q8N6]@R\ͶcIM{ 󾗼4 ](6峸hr( ȟMXv$ꦭo[Ntcڵt"~{3Qmk <jr |ub ^7{tA$>.|tMk׾{zI݊@E N Tw"y #Kz-ydLVПhL |ªL.0gȡFQ "z{6Iuc*)BO_˸=ʚF7~a2?ѱB#IЉ0c Bx5B$CTχ _kB'Ҧxܣ>pL##RԿ@܂1SVF29!i!ךrMsT ۺeuYD./W`Lz}<^"9uUޫ[SmОzm@$V4#S{Fώ|@N%o;4rf)ӢoKm+`;*~1˺.'IbK fwZ_>o5yث Vc=sD!(]¯NbƄY,*&Z ,9Uf6$!\ΉE܋oQS9%=ȳP`SN$zKM*dʏm%"< ̯a띨{B ߛlO']1rYP@;01u~IKZn^qu`b-IDCd"| 0w-<>x5z^%/jڎgC̣*CxA߈Y CYϪ@^X0NGPCc_̠I(/qO'v\S48JSe?$x4%25VBw!4h Jpr4( `c/xWhF2\aI(΢WdX|0HN'0I3QpQY]R~?#Q`'މtk)օfm{3oQE Xx<?yٙ}ۋ^*0)~]s^Xt NAh1a.VE_ pmnƤpK'-qSbLx]M9& +tz4.vֵ3=}Qц7νzY k{&~mDJHs`LƟтWP[f4]g}02 9pe}BPQq%7x>($λbMPэ0aQJbp# zJO H">z#Q+(p31s>̆CvtCi\0dWt4S14$(LK&:[27OtHo3Dٙ5C{a}֛W\Hޣ\nN9"٤Ko\XҘ 6.n?-zY>VW0YOg s ${UFHTQ9z)u` e˗RM ˿_ N?Ǐ;,3tſ*mUCG, `ҌHTJd0ԟ?U߲ W|-R/[]ߛe_I1 A? HVC]dzaXU b=ʘTZEnZ؇\=n %&5gf3 DT>?i.V+a8bIJF?^ (-ȅbX]]d^zB^Fӏ<-UԳGt'}{vHU;ҊҝWXv"xrj9* iO$sz\tav=`6/Xo߁H!^zzE12TR8,@`"Xt>'?Rvn'x ؓKeb-q*ZiglȚ*m x2YyakǣGxtSj+\mFǬnѹռGqRѤR=G;-A[GdJUt̉N3Fݿ~wKBHθyARQ(R :ecqԂBP5=V?ɩŮqGjӏ>׽iLȚ/ )_mnq'poa9Q/`QF? ܅yvj -3w:R͂`Oa{3V;==8Ea]'i4C349Ĕ{j}%25 7ikofNsE7fH6l<{m`+Ǯiq%e72Mӳ7/#vF,UO,HNdZ.SyS!ncҿQWJ]V̈́\hRݖT]G[jϠf1{u{O**R ֘~d{c8 | 0%ثż+M0x[v꾶]->>`"HmN;.}1M”˜^m3QIKUL.`0wq1B_) DQ8OҊy3x_4_НQ^z 0U6'3FMmf1sZ{+Gr/zýYˍK˘ga08SqZ9uDkI݊OVcV"ʩ/? Qfskb L.l~ɜ-lRc D5ߖgz Y Ls8ЂKW:9H6|/ZI Ug~z/ҽϭsnxeYǩ5\ Oz_|EG04fS$NnZ $/~t s=+|vEr^?LM7ns}u޺uH;6x_cQdtH?h4ߑ /[<1{:[3+hBX= _Nh^wW#wZSAx)UU=jl{@B= ;'~Y:ؽxYnFbJ@iHttoOq[hƈJRff([I!${G$[bșsΜi+1)E.&~c)=x=I>dL̵Y7JHdKȳyy1 #8Da.' ̙bw(  4<brIxXH«;9i ^p d=2q`@$E@KdRє$(}$c"zH*h^2{"|59v& 'Sޑ߰t#ULIIƧ஘ {'f7$)W$M|3taw$.dFYo䌹tRVeN|],ZhFx6\0j#w9*393 Ued +Ešo*bYJmoP`z.@q?05(ٓi :R~h Va& C56٬Ma>,ĠLHQwxǴ KӫT^)' kKHG.\2i|>r;Š{rJ9V:+U? zhSMYX:2`лUPCDKVsXse?I9Y-oF K%EE{\ }Tb3luM<~ 6K?GYuߙpMlNGs`i:,\iʀE)r `x&r'\h99usA0\wt@3"  P2݄X ųX:,z(JQs3˗ Pfx"ŵjR'h4kGϞnЊ˹@L'yk,7T,~MFy'F]mjAo(ڐ$+5fzB{xz·ZP?eUN1FbHՊ(+\]H6%l-rr82wBaaybGDƠ,v@ru@VWPj|"LXe>es䢐x7FQ7?N/P̡~[SC!==!yä)(BVx6jy;+s-;j\?X{=B&SX05̄G0soվ(nvcb)n:~?{wuŒZn0 'W&"}qydFRCևºk[f|g3VWgao=*X|F-MW[w" wf1=^.,,=6b@Üe7wcq/g:^Fڙنlwfkάbkf]wc| apx=(dD:6eϭ4E*Ih$R"s"Bc&P)S@ UM0s*9^( %6%ѺՔX\AB́jdr%F۰s͎  }5ܠS ÓZYޠi=dGULR_ ērs:~+M~|?1jtO>@[".tO^}l)pT7{X,f1{lvܼET,0ߠA(̆o3݆Ԉ\&Vd=U*%Ϸ-U-g4"l;Gs!e7Ht_-n<<J]AN9|١7wܺ]g6O EeS՟-mϠxH/{j+\ޱb1a&^I݌""WhXhƘ%Hu娎oaHxل)Ɵzv:T3iMpvEjk&.ݸ-W%VCF g" :"z{! p%ŻoZUY;s9I5UzX2wXp-fϲ ~v3NAp =ri5v(\Xe2 ƶa2xp#UhO=t=gmRzz*1j۫XZ~^T)^UsQ{PQ^75e{?rNs6xmX-=6'F-`g7XG 4jrfe90ЇIz%96!^NG1S||:E|᳷;3^L|սjclTapκM^ukL+gLwF[<ߨr0,(JGhQ]QBsm1BayL;,bAym۪ԭ m:jLθ^ޭ톒{Kj:7]]_}}VU\^lzmq5;T h|m|['7:4U^C*F<Fu zh մ?t}^6;ßѻait:`CvM^aӺ;NZ R댈XZ,׈'<){/IH5--^6jp LFZG~z"ԃjgTX惍}Ӱ)GI@N ~>v,f;? p@Sr:`!T3[0-ԬChș󽙩YY$lB%)PdFY,#`5*QՋ?~]´M5%:`B-`R&صkuM\)HC! jnZkFW 2S>Ν.<,;&磯$hSbHb̛7WEdrR,$Ť%M"VeJnShۈԭANMDSZGXΣMmuL^A>zCAAt*?!AE%m=?!ϕ>$Bj5R3_|[yߖ dP@+`RT0wxu]szVwE1hH&UJטN r,lWZziǭ=00)8]py>D֒̓)NjQ$X!MpCSf]'0G]hknvFǁmj/P!$Q=Mz`)'R1("7/`UT6l`6G vٞ:vunI`?evv4-`V/a)'Y&a3S/$qQl#]xbq/|OH08^c5z r I"8gqÊ01ԶԦMc0;"icOߓi4S\ V,e"8k E^:kME~R|G'84S?k-K7 &>ȨQ'Fm&DIdē8 z\~ lvIRwzm?^kW )*-WV_꺋bW|tPog_'{f UK@ҡt%V$Lw}ނOX'㉴1 \kԧSYC4t\Ayd^] A :,r%ݼ/%]P/nKYLѓeri;ۂ8fܛBc<=ת=~wp] _ʽ!{+Zfbb;5EW_&Sug{lj/!-'FV5e.{"~~r\ɫȯ'H;n4g(ک\|@ HI{[1Gd4Il -VrxoJ6)5mzys|r.Cs"F"=*r|yf6xVnF}bB 1i˔ˋbpjRX%2ҪcS?KzfTnis?sfV(.ĹϪ=sҺ(Rmc%(λjb3J[>.ep\Y\NE}#j1 *hw[ӸfINQ4)QI/g3gkiUBNg,-%:y+Vdgs#.1S\3sRᨳpXd3QNJfVKQT$v9Z%G’r4"J/Y k {{X A51wZiv+zwM)3:P DSFܨ.EkB"Qfé_h[7HENNmMNSFE#M}42J L v]I#9f"=W緇mR@&ӑ  N.S-;$~y| xaq"}[JT-hۓ= шQ3|Nw1Ep0ĥpbJ2 #NdkokG)nOۿ`$f.x1,KépqN$M Mh`)-!ra$yLhT9YչY["*l? 4`1k@,9rvDĮh{LsX$Fu`ǽ;{$;,:PD^u Hnh+{+vN^'T*į$&Ű[骦 b)PQ@uL%'C^P,S՜IUQh;lVK&?6oU %ƯdVD7-d׊ҹ_&bg^)\$>j?`4=4[g I|ĺVj/~{AX@/k>=N|l=u-ڝO^c7ְYC5 ˅~cK=GK i}PP,WA*$x*mX˔8U^ 5%PNCq;U#Z־/VZύϧ_[_zCg8UdGkͳkX ᘼH 'z?FsxwX78-ݢ޽&L*~nmbISh`Loθv׋VS*پ'N(hrfqxL~g\!-[vC,z+!KY[_(̂2ꡐ%Qp4VҪUDzKFՒvF01uC5Yh[:ĽJkHnQG7:!T£ r6:f5G[@_6yUĆꬠ PG RJHrI^U4At%2R3]O=PZ)\آ\E:2Dgu=Pld(|2 Im|ξG^T +"b>H o o|s0؛nzHuz?'8ܯU7Z0ێ $[L! D+H4k)YttlulMc eB2P(*O+ns]4#_?ЉjQyR!5%Lj a,X| γgO/hT[O:)o{I VUzT6), = 46pwU>>y}ߗU %Ϟ#!R]~WYnͶil|to4oЏg{훇m^/͢WnۦWOyPs/7^P5l*r6o6Ҳ|(WܭBCh/3>ض^}B|@u^=l?M>΋'nLm5ˬյ cM/E",nn_ueM=u!H6d.8k p"M![w.`檲.lɳm.q\5f.z2xm>/2[a?%GPdf ۭqWIeT#GJk|;aZ/dwq`tթdQiiqunTN-FǑG.ͱƞwr; IUk>U#ӷ'alQ$pWNr+4t>5%߿l>` yqJ)&IVE]y55KST LXP 4'HFt;~J1h$#Mm6Du7^BJ{hӉѐ! bm~%t_InD~ɥ_dRP:eACF,e@M$}av$s~l |t/L]OE2DjNfټTuY`ш|SCn|>vƒWE8 i+b 5o8355$RĨN, ;B[?(*G nΖu2~\aû^䜬5/b=WkiMҹ T'R/8rBVw/동#+ˇz2ͶqŴ15ש þݷ& Ͳ; CְHoN۔实B\͞':KG@+U_-k{,d A@qX@gn-zerr,-̠nފnmٲzXOǢ/]CkQҘ1)@ίH|d6CWJW510f)Vw=WW[&'IW  3]]YI:UC6ub%[=\ E]aE:(˂BP9#DLy}<')cޥl-xXŗ3h||WSGd)lj_^߃oK:qm9S""jWp;e11pfH[!j` 6:igHMlhao [fNh{ܳ 6NBajvn]+!#j1cWMxn@#`H ʅb3A|ƩLx.\w \7`C8}fXO+Vd7ͺMiqS;< ($SOm<e:Q$Z!ň 59h?UH%3eTG<tY&3( XW2WLY0QjvaHөy*pB]:ADK;Sri6H$[G8#ȸ28sM 3/F_|؟0C7dG&َW8Th+Kƅ<h.:3f>35tM^;z,&=.Oۋ0C-( v4dv>'ˡg0OU(/zC&v0~:}j  "|U[+`!ޠ% ,Mwػ:js+qt as8rsl\hƥGn@:"{f/Ҏƾ?CN֊1`T͗Kю9gd`^(8\d -"&UZiqMwmzŰ|#lٵ^+N?_e-8CIXbH԰`UsGܾf.Ka$YcFt62`n]ј7 Ő>)@ВggB85BMf0!d֋F"a #!}6)m, ¶T[1tM;7 SrcHQnWb}-R2i?C];-k,7̥ۚ DlMŰS>6G"Bέ1Zs Aj6` RgmbĹ8/y3X S( $*WŶedZimifIka"o}aZ3JҤbZh_^+H> e,i+ncMJGYƌҖT ӄR*&M"N9ҝ֣faa}}OH 4Ӂi9$Sq.L Yn 9 h˥06sϤ &ɫ7/dZĽz9A^4dBjo*dN|Bpy'SM^7k5VHQpd˼-V)R9# OJ5p,f_OMu\QhF-IpuZc)oR' ` TywҡhC-ѧh%ۋ_z5:w+_E߆Kš;"R:Q.~wcIz i;45yqCOWD=guiqA >TH ˶Ks!)O?ll>Gڰ]^?~BU\}EO/~惡kw*}$/X}}8H4z U752𷰤 K|:(8i=J[}zﯽ`z;CO{R2͞v0Bw[}/4~<@0~,Ey6YsG_lOđe3STE=\xpиFo00#kǜ/4O w!lM Ŵ9 pap9'_ ѧ@c~C/zooHreq] Mh1 TSv[tr+6!kpYt/U1m햑˪C˕xjbC5OxVCzꨭŦ2{X&[Τڥ]@?,y0h Ax8@,NTOtՄ}ܻ?lhOffd*RzKuewDa7UrO|?ZfϊQ-(H eJ ݲBV8s苃Y5OǍ&ux)LTwbl7쒿?ӷeQ̗Ś5*MeQ{.eMarafYJNw5$bYҧ{y\ K<%9uGﾱaMxgtz o# X0ak2uYMOThȣx!rr|kFx(;,:Q,l:SSuWW-*vCY݄{`,S,51>Hu hR֦||VޱJPZ] -s2A}HX1}PV6L,e^+@[ 87 دȧf\v;1:n8{ 쫧%\x=CzE0Z̄I{Դ<36$-8wZ4l*Twz%8l(سc]3P.E`b198rZJٝn|dl3w["a1̈́X6r4O|ɳdt<6p [R~V t4UDV>y&-ȰTyalo@32q)!A)F vHg9 ĬO&HI:cd,M[B4m c7@[@LZjޣ!u߹U!: .i &wLOM US~p38~ "6 =.][͔`P̄VWJ #6ܾ@B`r% eZdoi ܋aH֤ &_p ʹ!l* b"Z@3Wp1i-Lga-Kg1O CHJkf\_(޷hqNt֍dgff@Tr"^bi.^c3.g!}_cN^?LҖicӇeRRUo1+snlt< LlܖE~>̚v坤Sяu'iLモZ{NM>xҰquf"?%z=+VCL^MS0wmStLSk2S15ؽnBW'2 b0d8 A#5-FxB+i{]f"{ɅhgF%lZxa0ȓRmjiyƂuL{rZ,:WY9bApǁZx@02׆9 VtpQ^07$tQ^bs@8ehχ I{j!C3׾<nV7psߖ]n/FOƵd1A'"j HyhMq;nE$"+|k r.~JCNh,DFԀ~c%u3:~;,cxO> ֡#ʇnG9|u7U<*wg'xz|Ktt0 :(80b;x&4:ͤǺY1M3B51IJ4Zf`ĒF%IF6gF.R_ "a) ŸRE9dYeQ2IG% ewE35I?*l%˭[1¹xųesML+EV6ViS MG"C¦)gD<0ˋj+tKlDXZ ҋz٤rfq[;[Nt6P&z.~8] V[ے[n67>ߙ%ԹdEHjD{<10v OKc[^t~CЃh0 ߮fĊ/@s@W:hpů".*>UB2 g\HK%JaZ7{B! ;Ly4$TUJQ_jCLQekKjeutIh612S<mj8 C:y؇GTMlΌai+Ձ؀E'!~(̰h f/Jf\npRǪwVlo^ۦTSaɻ&V6`߱.Td?ba/CrLVjGgϟ~oB ːN$ T^_P; \7k{>4vW)voM$"Z%_1BֹZ>xaSW0O98Jmpe]AHDkɢP $^.#+Pg[9JM}I07:ݜDTWV-#;2Mzdeke7[|W=@3.cLhz3n>g}`ӊ'7Sr(B] )k<^^&֧øw\P٨mo.ܷ]j.maX议^wnzG /x89a͇RV +n{S;Bƶ88![2ؚ!YMAw# Vq㖸`K1 O}C*֚{€w@4)eYt {-r{VC_;ܞd Ѣzozf䱡 .vQ́;Owc-);<,qSOXe`aໟyS,^ D"fVwo'2d4}I]Uc{CZnTf_Rd}+txY& 7uzCD=^P6 #8{gz(J@1^I^4͢XJ¤㟳A ]g"^簠NUlۨo;Ur\Q-=hKIltJ,e#ثn X*XٺPqǙ[&YII$ƭ֒JH3_1KӏjH|J Tb$ ~~ @$+ܡYI]\HMW Lˢzo՟ 2/'6@ 6'"Q/Ob!a7t8$ƶw$GL& |d9#)ɣVю!W( Ɠ~i'J=>`U]q!4i9'z`q  cf(oLFu1WÃ:T˦_UYS2 vE%K~BP_x< ; c= zsl %Nx<0gYIk&ޏm* Muߤ1AKgckLuVc[haHxòE!]-.`d- HF1)ledξvO% iIwN3o%D o4(?=_`שּSc_}@\|\M=/>˟rѣĒ礵m/6o7Ryl \l1`f xjvu'B9]y9:Btg0^30q{DAyf#Nq|,92)M}pYY\fQ9iVAEӭl֏rr uרLdb<)ysvpWheև CPη= BNcJROeaecB'_C O:Ɖ9gD?Y[$bňvyt7Wkjđ0q[r]>J Z{"nKmxr#WZpגSiIWky >7cT>UV&zOjWԹ Evcr by>{E4lAGGʱ쭕&;^ =:]ؽ8iŽ^TOXa[y6IeK3Z͵1? ˙bUI/Z>E ,-/hFxw&nV;{}rkNV㬴q;e<'2,"&K9&}iZrxAlX7;|s?*SeevҝMMA掭݇s%3qd797Jl~\.~ǝ&DC~=Av]J3QD f[;XF<6qn%-M$ ^Y䀄Lt/LLN[J™|`S2esD> \'yF!nP.9O+ mb@vQ~K޳_wE:otJJN:`f鹢IQ;=ʗ 'B ^T2 [a_0P8* mOͩP@mJ-*>J#, "eZ?ԩZݻH[PI$uh^`RD}e;9d,Mz]W{uֻ^k,gSg驔A֏#ʼ~3 I)1v@nMŅS젮Q.\b)SICLnwI{mƻ/qWОie/yvJR!=`lSB ;"}LTctC#\Gb% `EgI qx *+9x!MAY;{OrWSO;Ӿ ZBD\ j=Jz%my@ g& tCfLjg>[ rj6IwQ-1/8/aՃd&QoZE8(j MjVVa^&XcD^Qv:v1Wֳ6OG \18ieJ\R x_\gSજ4 E8MBT$6g2kcPe~=::-Y5B- 5 d'&4'@m AvsKt3CR7CzP$+ n=]n@ 9RsZ&"+I4ˣɝҳpIf16 E!H[er=2yː3yzÇZd^Z$ixzUL`7*e&jH"͊–C-r LR&EdћUuN&̊j~%Z1%!`$OmFJCOm8%칊xWn7}b"(rHFEcRE@r%+rMr~D_3$WZ](رg̜Dv+PU敱NK畞NY*͔zSgd1 u^wLs+#-fCr$VHXHNLhIw5c3)7ұ:?QU$?EC:H"uKhogtzspt2e Y˪4,CNz73 W VY3bN33J /؜Rz ch +5n0O&dp+_8@RV Ex96+%QeuZg{:qt3n8ƧdFy[g /-c΃ԋ wyr_.?{w[ 3]qw\Ba8s-Qe#AN%?zoE'7QGwa?|ȯNugCu#Knޏi:76jYS3J"[\[qQTI)mLQ!ƕ@ha`V%2.kqs4)grb{$\pJ[&0{ֻTin4=b2vQp3+38E&.[9U7\>025rx% hI#A0`,a2 EmRֵьK5{aTqaenV2υ\6sVU<> Q.]Sid/eW!S X]Wp0XHRJJG G|M*b= (\=SԳ2A :1:Ȭ9Rɔsˋxŀ'n'ͳ<|5u1̢n0xi/hʩ1~qp XsA60m|',p}O{l$t~dj )lt;C׈يg!r+xWbJkC`H.ʝj[ۓeQ,e&.E0hREx(Ktf1^ 0Lfn*H%ҋba(mۅ.F-K>*Xj0wL?Yk\gfIw[1ބw&ܩ)7.3Faka*7q~vȊie-C5␌5v3ظ~#er[\ Ng:Q2ͬŭiej {\3OЩ2ּ+Zo$ GwGGπ /.nw BfL t xnpZhH! ƇL? v޾-;-/G,R="YW@2}KjLYeA(:`U(WlK;ioqD uUY"5Ng@ק'Frl' RqV\R㒀#d~˻:JJ[1Inc- Ԏ.@^(^c^Ŀ~lF7 Q$NJ3-KG)+0}\iBx %E9h`Xf RLYfw$1uԢ;1&J  pufx+8pT.GW}1@&AdRbHG;}R ZͼYr0PO͎j,s4v{*d>~X=LqjV]Z z =bdt{a*t:HNԳUj;y@ pi/8 ^\RjeM3*Ec9Ua5cvUiFAGT1 a՚XҺ|DW8 Q[V?@&ѿi;YmoeO$^|ps!3{C|) El$O|:% tq#B&pVy <̥m-*iz[+$5&qw8ZISh]yhfyC "0u[Glmx(<V'`0b0N!k7n+N6ܝ$d\ģ>[aAc[[0>?  >% dK0zŀnXjq<'&gI6(@DwOx{. 9{xƛ] c̝YSsދԁjȶ(u!86@ xX63l}A,O Kg%ә%IWVtfسPhcE0^ Xu%~": Q&.B~ h+R\$ m:TmѵIG9̎Þĭ \jeaC/\ʍrФy1\BvCA:1+{q88P/N7y{Ͳ+`jioZxhX 5 Q͈I'"r@{TB{Ze>e.i?ERmFn* 1agӰC."6)%j@vw~Fw=\5{\g2k mE 4*,o ?}v4` VVbxK;?7;odTP?1<Γ20n)`a!ϪZT%.(@Uj/cS\08#XfZ 0 `dvҙ?5~ɾVCcSxU7- t45>i? [yu=XmFrܴD?C..f̈4A"=;)i]jF-S qR{E6rƲ<[L75.- 0f Hue00Y4A7$޹#,ljHĽVAueϳ(N^:EESF Z8>5j4˅ z |3p8!g=53&-JUÃ-@,](2$Db2\ B[c:*jIβ . ?~<|0֏pxl< \w m=zPuS_F %0s u('s0e,WիWvAd.FmXc>B jg"\#rtNJ+9ީђ2?3: r;{H ) oFd,(ICuIA>ςe'm_f\xlCP8w~Uh!8$%/zPɅ5]RaR{ .!lExbtFyԓ1ҷC3r헄AoYq-n 鎅-y {rMfDp*(M roL̅)e K]MwG{ nhP#Fh4ޫ[D ՀŬ"催gϑ9;qr4t~B*Y9'm@pdC,ޡ <ܔrJ snRtjVpxaޛz#]e qw@#ؒզ l@"Ƅ@ pHN^87RVl!{ ;Ç,ig])Q}]}ֽvUyqg~b; mLG}@9DكI6ʃ$AɃA'y>]w)z4zQK^z 49ݗk*{kKkiPG'okAb $e386jH{,rbYIxuiPG"OnB-nmD'4#e-j'G#PPJXO[ 葆x@q;[$EEgr,9Y rtqㆆJ;5"_ b$C֒g30\j Ϩ:k\~QF< (lA9>)YS qƉDp'Ę+/>5/\ڠ+̼W{9уE;DSR ̹1=_Uj4j[)%-B誮C$kcaT7FĪa xYe܊+,pB+= ޜ"}** bV0P9EgxRE*qiM&#,l<6+zעB&؅Gy^Sh~h7Vnz ^%k%Ę.welFzV;W.uQjB"=4^jw B=+zn^uQ]75x\'2&REL7½Z]EwF _x9rrgW{G~*Kc|bþ(4 NB5zQti!h<6R\Ԏ+Q4q}ui`h <{ c}q nvaX$'MM-[ŝi :ָҬ|*'vd$p*߀?\6W)'vRl,Ւ ˧ӺjbVQ$6LRrHu "8.M,d@; eqrW6h0MQjL1-ZO.]>KqhtksP&^p(ZAxR;=ٙ[KBj&Ney^ ;/e'*ƛDqɧ\JI_̲u)BcI;gsQ'NAWW ":kNEQ[;[Fϟ%{8\=F޸22t,wwt]3 (Pou(~lxPPVo#@97Upw:גheZtyͅ-Px2~Kz;*&{4+rIBb:!aiTdﺰxJ 4n3Pѝb/31:VnJ9Z;m7a`'yF^1u.T-ɉ^-p!tO;%W+WiIF8) % Tz ddPCby)2&p?۲[F;&='Hw lmh P;99z n_Ft ѲNZVrGaH9YlIVr-oY|6(\\jN~{/Zd5WHfHr)](WڥX'՞*$R y~<`ޛ\J!O[1o}}Ĥ>!ME ;}I!,k̝N0 uyk펫}3Z_0B<)HwGKjEm cS Ptj?7`$˿y c &]+Ocʐ W]kFzk~H}  p[V^ᾕ׺ozѶR9LGzlmS9ˠOBT$[.nP4 +1%6Y2˜@$h8Ve.ތVBB7^ZB5/rgDX- _%͚iY)Ld;<>{HOxA~-s ;hPYoվ-_ qN> ;U ڶ'&Qsг툺^׆\y!N؜fs"1#\"`}SRN'RsGP;`Y,\ᨇՙinh(QJF"ͤ KfQ>~aq5Ŵ) 2́~99ڞ^"֕UkTVXnzN~ UK"~b ]r!էkk_Ki-NryDM %4 ŕwV@m}?/o.QͲ2p4$o"fĔeRWWhH$QSRYg1$/x 鳉>ǻx)v. UgҟSɲ|l"M%_ܒ|ЎJL S#պ`4޺dhP 5ERPmԾE f:g|rN AbEs__zg1е] }{^t-i?_styF'X.|nMJfg+p%7Xz?ʓ <=e,9b"nj$8<, x z ) YF}#"ptʠcllj^@ 3 86mv]AzW_m ӠOImiy-ƽjL8Ts>wl? ޯIݾu#c9)p=^oѵ3r{`eK(xuV]n7~N1ыBR( .(IkMJqgV=D{(=I!weH\r83ϰSFm~3db·DT{>MkLmNӧt0%vVՂӼ[;JA(V/Gke-z|u䔸nJ&kJ7 R"zN6_wLw ni[dOAa_dnHͼ_uy^L]$]ZFNImpG8*$+íL ?˖1q@3-~c$G&FEr>юmYoJrpw#B/qk6AVYS=Ah*FM+ 4-9 F_$pEX^kQ/mnYBN8)Sg6 aEV 0#|锥Bn9?84g/ !Y=ĆB7 &fT/WaBZ Ki'%ˊ-oU2*IER>h-pׯr\6 ilz(Jxe cɩT" 0,̀|- Xe]{0'/,\' =4pۨM[ȩN#~]$6lܮ4z'!h,k!@,p {ʄrb*WT˱SW X>r]*F l$*ܩe?G1B$Nw&59>Ы%XSӑ~]jII~{hn&]"Gq=Y%81G?)-3nlfcró/b=0@^_<> )؇ 42-N8,j ҳ6ZEH2HϡzxT5WR7*2l6s86qozx/Li`Bc\`܌L;>\:>lFQeNIh"=7eew-Gs׾^~d{T yɧAI2liuNl9>9trJ&ԃZ:4+NOi:Geڋqryr$ @/JpS|AfX<~ p>s6W-\7xl3q0z8X;&P8D1<"EǣlwV^$0Pv8~fB0lp吒6P*8$$)x[B=cK>(MkJitVaJSo YS=Npƒ!/`@G,~nqZ 4!U<V ܘ* OyaCqxHZ8bFliB9h+k *%@ve&]y_F<]L8+2Vyl=zb#^qHޙ~[Q?E(xz<w*T\>A}Kx˽TfPs_۬%1xVnF}bC4sly( cE]fw)q#Yl7]=Qܙ33g̲ŕKOGjZcHQ\ic<:o;~d3</Y^l[k9VQtp Z% $=; m>5Ñ,坠,|}-ذ%I9:]xe4L7R9  V,eJ8bFN$稒iCڇ0k5Frf:yGu{0%qEyę)ڟʟ.,Gy&Ώݩg/~OSqP̄/PXQ|<!._!QH<m&FRx& Vru9ETo{R`uSxu/w\fWf{Bt#XsjI$[~@mL:[|DI=l &dn9lr"8Lo|fJ/*ܸ7)PԌr|M?$ T4TfBW.E,ONAacPk!-1g Rܠ&d]Եlbvy/|8CYbfI^=2}(#=p)YGܙ8%aQCSI'яL-Z[IeS%nIIBiZk ^ɷ3Zsc17^n+UjC_xԺ0黰2Lx' [jРẔ?E x%yY,pRYWK: Wa :_m‡ Q aN ,./::#,j˸۰1*d~.uaJg?Ӆ5ݍeg2E.jfwJ{=ҽgJu%ǡsܢM> oW/UΕ*%+PvuASRN+跗m)n< cU.@|کt){* rUR|_Z6R>( (Wuƭr8t^q]*\B.;΃E&oEZ6/Ϗ!p5lB|A}.~6l8Wґ(,{$ݪIG`!߰/vNQ}8sxp0'E23K)Zz7Cu6NFjS1-4}k{YtjA^5a5.>i,WZaUi+ )*pU U*BDDDO uqq|JZW 6Є59ы[VbUTZ35&_!,Ȗ" xaBMA%;|Vr[(IRЎfcȕ:^<f,1Z|;Ǜ"~%~SGV}UL`Wu n}*{ї2$`K)x]Rn0A4hR}xگ%z{:PQg>$AUmc)8c%Cihr1g%5miJN~Ij{-,sIHȭ '/ݔJΑ-|>V 9YJY_'b E*X/}w+7Ҥy^:2@Q5_ΚѾ=?6E{O vsgf)L^od3R=uSD.x:uC GQ~iIjL&Frx31Ԓb)K^.a}|fs(&T0ܞW8y w=Gu$ xh100644 index.html_ ,<71T100644 main.cssb3>b!b[+mC40000 sub! :J2HܔYѝ_'(&x0home

home

jxbody{color:red} 8eEx%100644 page.htmlw 0i+t s:x

sub page

.r;x TOP-SECRET xWn7}~d4XYA c; _F áviܐ\]jG %J+ ROZ39J=?UEjR!:qfsԙɕ;iyCG^:qԍ]>N>7-&ҁU?p*$Vxe4_q7r0 BF=쟜|aKV(\ql,{ . _岔:F3*\S$)&>;>LrMPXSR,=LT^,WBݝsE3ڥ]3%fFE]y.yzمǨ냠Vᅃ?/Jc2JgET&Ө3TEH@~Y&]bL{r:;<:8ٿ8:s-36JI4a:}oMU&t/WN&uOD݁m"$+߅#WAҲ#9/Dņ~1DE54|A)k<\$Y|Z`J)*=1C94J fMGCjSFFaɧǘl~v\nEp;|KWXjz}@s/c5ZJG$Tc) ?O:$~ޥBBj^J;`X1)?͔4O^M)231hJN(V鉤#\]2KM%I!sZr'@ XT,HX"m*{ f4x l%6rzF6l]harV0U؏5 M҈O饬fyќwnC7HmqNJOq]9*H-\TDS TQMJH%6哔lp5'Vohm drQ\O6A2P銩 L&o'mC.x$S 8h;|n7;Iqvh>LGḗq҅,7gp@W- n;MЗ?]L61wth=4?FRa]S^RMgE5G;ܟhJtAd@ X/41=ٸ:gf%˭~jd66xWҗb=b!Ѻ6:D >S`oW4M^ֿ1+PL:T!o/] אN-dҵ0{e昼!C)| {I9pAt@ :2L iů ^؜7 b+F?36%l0޶p-pDiqKG (7q"*az&e ^ q!! OalAB2v? pf>1݌ܴvr+\3:Zmzδ,pzF`T˨A5SZ&xWn7}bEU/Ca'(u N; 0]J""7$WkG %=CV+9q}Ҋ3Ù3gJb,/UzjZ)m$J ~t^qz.'Sa[Ƚ2Z eyEZ`K9 R]M[,{af 5xB L|BZwGo>deANZ줡+Lia里Q.}a7x$l!Gs53JyK-&&bXި9#*ݳ_N輬 zzD1;uoRʊvZI&7썘y2d3 M9=:$d<;==Nw%b cNHکU[콬-^ocblNۀ'9V%jg u&`'7\Gvye)'Qл'ӱ7xb,Dvl݉W~ƐiN547se%@n=m8.\!( zUK牷~Ȋ5doZ 1A5>57ABk9EKFQz&JU,R(4Hq^(pB[@dMT@ Ŕ5l[9 +5)c3CGf[L Td@.ʂ./ ֗W`cѐ2[8byI9̔`1)(J9Vҿ)t`ǐvVqlv4-Eyܮ  k< U<Co\ Gag œ&G%:o3𞽂%$T ˥^61ݐH,z@E8j5dQj: >Ҁ;E4 rsq:ϥdb:2> & rG;8z+b_zx t+p*Vam>-F)26ZƁZm~=6aS -:0W̆REٲT3a<$Uإ?>Vs򸁋M $Lh8Hs(Ќp3[mXGz+g-3~ML*Sp9iZTp!!>|j h D]r*n ]pvtƦot(<^+呇12vņޯt3{w67B9l(YF<6Wdk󽓛LiKFUvr:lZ3eBA. 4Q8DY.2Anbd\*x;ZtC]`nk֩%xE <55Νo[gm lT~j?]x=ƅh[I w*M6EN;7\A{?Wu4zXӭ/v2_[f*.e(k@߲BsP=>q9gE G6CMyFW3CڻI 6^{-NU8sӱu:mњW{tA/!~`ѐ"d8q(/ HXI_b>㭪m\eE\6u3LV[X3I;Bx=nYwݗuGTP㺜\˻:-xЬ+tyM07tH^C8ͯrBPb:beƂKٸǛ2#>#Lp+{/Nw/O{U^YY0;&<ɋc摜S"jHD4EhHE5RALĉtԭkFl ' ksJ3+䁭s3}?.D\He mN,ovØ[jNi[Jy>2uݔ˰d[YRR,S#9b_";^_y/Lj, nljId#Y0iCFjc#*֤>f ~;)Ӽj{̔CJKlrD]9Yi9Ѭg!^>5Dl\Lf{T9YR@Hie~L;4,+>-I*iS˜/mbg71~fn’ b$6"l]LhIdտm63 k3z&I-=dI&IDxvkǤy@aUi |h+]eG a+b ʓtfdJ+`Yʶ}E(K,6·Fb`rᬕaAHx>$3V>gTmxfm?K]ZőF3RcfJ[4d*q*чPTaYe93/E7[xβM+jJ#:}(sQelǡlU#)ԍ-SȦ4Ep c`yZwƦ-)U0%UMBIcBhI 1tk|1@[𥝥9;ӹ }Ie6j#T!%i\ eTY %p얈&\1٤s7^_u;<'[)zpLGr:__בOcO'H$>8CziLE]Ƚ "Dcp@9ó bn M#Őrv}Z"P`g;uݠ]0޶bG&JZe!yH0j[7}#H:Wߗ#vӒrrݧ؍zջ"/Ǘ2p}<+V1[٬e|E"FX9bQy^!r[vOymK0/A}rIۂb@Q@͔A^ś3'蘂P &Ixh@}³xʯ ۏ#agf3lߋt[S !1Y- EsHٻC>ƊqC*I< C4SOg_LlDz"@NTЅFqKbur#7YO3t:ˉ8WlBM'J>] +o^L}-,Eđ5S~֨Ij[Yi}ZY- m|n$qQTx5Mf&h׼40Apx} 6wT~'&yh矓"3;3Tm*+Ayų2fl[լ#1 R@ez鋟Mdݰp$Y'"ϊ\\XMf#k75U n i_-N 9bJW95S}@v5,p?|VIf&vji3O'40Q6"iTr+I#"IF C|= TХLՇgwpc%0WBy^ވw >1͚TP%QUظcrQsfA rt4I֒m[eR0ٛK+f*dçٌX\gUT9i# jfFL kI%c%N0ҥN9,9MRqݩxBbD|_eU@ȉ"XS2kJ_4 qErJAD䟝qfpW vS T\ݻ]y VFC62PwB^95xe잔Fh)uq耣9f\Z6<0E+.ʭV$IYeH$فϟlfKX.XND>N :f^bTzJO:k8a®.&ҾU9C<%~]EgK *1 w Uywx~!\nNC,SZe[[|" &uj.7ɞ9w< $8;O|2ZOq20C xȃa`}]sҺJ]Em<Ը,גYDjZ7*(i],7:p5H 2kt0sBR/M8q㡼r*<xrJ!*wBBѺžm>x0_ p;t]/vlSZ뇨Ft+6\4042s^foxsL_]f ;]ל2 NI5kkX5{*kl D~]} Ӳtb~TcvI Jhw$tV|c9mτp?)7/UuxDHo~Jx-Ͼ0]4i5'O1SNAFebuQa|Ÿ`bJ*d8<)\224WtreȌ/]TYJ]Q'QY;Oa6w$a31ʒ 퐋˧lVH ӵ^Z`{eK~Gr$84G)K5hE}C L "RWДm.E]?`ԁ'(iaZ7:NC)[V?247!S6q*l&yyxv×CYg M9t5OXPѬՄ;g=sTՖQl<#f|L$ō`"$ՠui+⫓M/+ާyZ='{ ْ+L 5o3Ϯ+S .`hvSyI8cVp4bsҐ2Ch'l(M9 5 4j['%Y C'R̈qD)X-‰2\(qc:dJa+xsy[gmiW )'4 |,Gv' gU$rU{0k91J xWIH+ 2hFk'qs5ðX߿>+ҁiI?)xu"1= rqҤGX=@‡~]Cx/`K 7r0iN3&bw@$% 7H! IZ1)!qYNɼ1yGsȖKp.-a'V\j!# &;6Fy'h?W$ዓ/"^MAsN;Wa齉̀HyY"3cjrPWkQ|4<wܨ-DxXю%RJg-Q)5OK|k}ャ7/ŗW.9'|EH$rCsInb/TWeMK@N_quUzSЩ`zyl9D@)[}:Ey)3,%] ٗw[qVGk57`qTe7l6cj@_s[=e"9RO&4qyd'b}W(s cCčߑea6B˜h!O3 fЂG7Sߤ+}ߚv|\{lUZB?XOn\-Wet*F̼2y|6irq:5l 8e,G?a^#6Z Ϫ?i,"crx5u}Eԋezf#^d\7g+>t:@ϗ!_Y>ĥ[b/H+|viTMIRAnTk8Cy?Ⱥv%ΕfhLIf@85p-y>~>99l}\먏{{p͈$|QÙ.nh߫P/^$o)H*5 ў]֔cdFg\iDr;N$H`aQ+3VmcX˵[媹ʗrRYqB5;u/zЍY(_mqC-'F&V+8$%VjpLxY6Z, B(%vxH[ݛNlj%TinL'H;7\F4iK݆ݷ_ Qse`QNJ$蘐Fx>su{`_iԊaMvj1f` 3YZOK@z”(UwvP 垡Ę;9u㌆; }I!Nu9lV#}M@Q>sgۆ_c ;;Ja9PZI=~Q%t)OyQDhOѾx|榷'jQ3|0>MP < "ISMjl&ũZ&jdIwrmRkj C|6*s"E-4,TWiס@nspI ;%KŃ0+δ&U*t0d+;>USidE*Z~JZH1/NNIkpQ ,}"57v7X*!M(MJMi,JF!hHOp] Asij3H'ai)0Ч'J;0d!TƕzFxF8al]ֆ̑/Y*Eּ#DS9É̲ 2"Ok7*(J2? 9V!g'R."Rx(T@t^YF`ՀLuwĵm\Ns<(.# ͿD>ZӺAp"-)#Ԁ^J q>U{G J|cK{j=woS~m*m.Fß`,f &cWأ^AQ%I+n2܎6TdFev<Ru,O&Fj7zK2b_XeFsG3#0BMgQ6rECB17Z,wV%|a.r]Ƭ{{_kYw/JwN` !1 .يcv!;hi (_ Jq܁VB$dw4BR#reQN}(Aib ^]kd|3m0n43wzwo/0`n3dN}M(FjE6[kfF~E tq/5-nN|tFMlxs7=Q>ۈ Ľw7>R OB#zu>mQvŭ]2Y=D w2RtWu{:.hڃM?5B:c*=$ѝE ԋ,],#,*$zmpV7P$,J&KR-$T {! _^x)jl'cQxS"nuRsuڳIE*gبV|4™GE\u{_Ah22>Sa|̪9D'!lW0q!23j!MKRhk][e܂>[;.;Š ӟXj.䇶UIO{ue8*vhI[]AAY$[upDQn.RU_`O=" ׶*l@)kAG1" /z$jR jO^؅v) 5Y+,@-~|tf*BF}QǨvv=**֘6w?311۲9;E,},Ä}0B[z '|Z^|.a>acvkcT}rV:/dD|m^;|]-Mٛ{}^:t׻W|boBhF%߼V7bU,dwrѷ;C)ጯ%k|_TK(SE\$VvM8URO¸.j\|y=( %?ЗȐ>k3oYm9z?s( YhcjG,r vڝGn(Hsuo<`_-o]!R0KGP\S9䀏qILhNv%؎M,* Asv0Ȏzt/|c+7$qS4ɝ(PFW[_|ouzp:F-%8<:'&Z <FD{?JҰXoo{'.l3T1k7ahNT_*,/oCK!6p[XvZC#>7nK"yZSQRPUPbI. ka|fB== HBoNYgm{ .qEsPAD/E;J_stqE,j5rOs퍙a0OCw(nJv=f+K--y歽h˔^$PD]/bIs֙ЊSQwENZ0O`/Z.‎5#yH>s麢h-7(.oxb/package zip_test import ( "bufio" "fmt" "io" "net" "strings" "testing" "time" "github.com/valyala/fasthttp" "github.com/zap-proto/http" "github.com/zap-proto/zip" ) // TestListen_ZAP proves a bare address (DefaultScheme) serves over the real ZAP // transport: a route on the App answers a request over ZAP with the same // handler/JSON path as HTTP. func TestListen_ZAP(t *testing.T) { app := zip.New(zip.Config{AppName: "zaptest", DisableStartupMessage: true}) app.Raw("GET", "/v1/health", func(c *zip.Ctx) error { return c.JSON(200, map[string]string{"status": "ok", "transport": "zap"}) }) addr := freeAddr(t) go func() { _ = app.Listen(addr) }() // bare addr = ZAP (DefaultScheme) defer func() { _ = app.Shutdown() }() // Wait for the ZAP listener to accept (bounded). waitReachable(t, addr) req := fasthttp.AcquireRequest() resp := fasthttp.AcquireResponse() defer fasthttp.ReleaseRequest(req) defer fasthttp.ReleaseResponse(resp) req.SetRequestURI("/v1/health") req.Header.SetMethod(fasthttp.MethodGet) tr := http.Dial("tcp", addr) defer tr.CloseIdleConnections() if err := tr.Do(req, resp); err != nil { t.Fatalf("ZAP round-trip failed: %v", err) } if resp.StatusCode() != 200 { t.Fatalf("status = %d, want 200", resp.StatusCode()) } body := string(resp.Body()) if !strings.Contains(body, `"status":"ok"`) || !strings.Contains(body, `"transport":"zap"`) { t.Fatalf("body over ZAP = %q, want the handler's JSON", body) } } // TestListen_DualTransport proves the decomplected design: ONE Listen call with // two addresses serves the SAME handler over BOTH transports (ZAP + HTTP), the // scheme selecting each. This is the headline of "one verb, transport is a value". func TestListen_DualTransport(t *testing.T) { app := zip.New(zip.Config{AppName: "dual", DisableStartupMessage: true}) app.Raw("GET", "/v1/health", func(c *zip.Ctx) error { return c.JSON(200, map[string]string{"status": "ok"}) }) zapAddr := freeAddr(t) httpAddr := freeAddr(t) go func() { _ = app.Listen(zapAddr, "http://"+httpAddr) }() // ONE call, both transports defer func() { _ = app.Shutdown() }() waitReachable(t, zapAddr) // ZAP side. ztr := http.Dial("tcp", zapAddr) defer ztr.CloseIdleConnections() zreq, zresp := fasthttp.AcquireRequest(), fasthttp.AcquireResponse() defer fasthttp.ReleaseRequest(zreq) defer fasthttp.ReleaseResponse(zresp) zreq.SetRequestURI("/v1/health") if err := ztr.Do(zreq, zresp); err != nil || zresp.StatusCode() != 200 { t.Fatalf("ZAP transport: err=%v status=%d", err, zresp.StatusCode()) } // HTTP side — same app, same route, other transport (plain fasthttp client). var httpErr error for i := 0; i < 50; i++ { code, body, err := fasthttp.Get(nil, "http://"+httpAddr+"/v1/health") if err == nil && code == 200 && strings.Contains(string(body), `"status":"ok"`) { httpErr = nil break } httpErr = err time.Sleep(40 * time.Millisecond) } if httpErr != nil { t.Fatalf("HTTP transport never served: %v", httpErr) } } // TestHTTPTransport_ReadBufferSize_Raises431Ceiling is the regression test for // the bug where zip's HTTP transport built a bare fasthttp.Server and dropped // zip.Config.ReadBufferSize — capping request headers at fasthttp's 4 KiB // default and returning 431 (Request Header Fields Too Large) once a browser's // multi-domain SSO cookies crossed ~4 KiB. It proves both halves: the default // still 431s a 9 KiB header (fail-visible if the transport ever stops honoring // fasthttp defaults), and ReadBufferSize:32768 now lets the SAME header through. func TestHTTPTransport_ReadBufferSize_Raises431Ceiling(t *testing.T) { // A ~9 KiB header — well past fasthttp's 4 KiB default, well under 32 KiB. req := "GET /v1/health HTTP/1.1\r\nHost: x\r\nX-Big: " + strings.Repeat("A", 9000) + "\r\nConnection: close\r\n\r\n" // Control: no ReadBufferSize -> fasthttp's 4 KiB default -> 431. ctrl := zip.New(zip.Config{AppName: "ctrl", DisableStartupMessage: true}) ctrl.Raw("GET", "/v1/health", func(c *zip.Ctx) error { return c.JSON(200, map[string]string{"ok": "1"}) }) ctrlAddr := freeAddr(t) go func() { _ = ctrl.Listen("http://" + ctrlAddr) }() defer func() { _ = ctrl.Shutdown() }() waitDialable(t, ctrlAddr) if code := rawHTTPStatus(t, ctrlAddr, req); code != 431 { t.Fatalf("control (default 4 KiB buffer): 9 KiB header -> %d, want 431 (the default cap this fix raises)", code) } // Fixed: ReadBufferSize 32 KiB -> the SAME 9 KiB header is accepted. fixed := zip.New(zip.Config{AppName: "fixed", DisableStartupMessage: true, ReadBufferSize: 32768}) fixed.Raw("GET", "/v1/health", func(c *zip.Ctx) error { return c.JSON(200, map[string]string{"ok": "1"}) }) fixedAddr := freeAddr(t) go func() { _ = fixed.Listen("http://" + fixedAddr) }() defer func() { _ = fixed.Shutdown() }() waitDialable(t, fixedAddr) if code := rawHTTPStatus(t, fixedAddr, req); code != 200 { t.Fatalf("fixed (ReadBufferSize 32 KiB): 9 KiB header -> %d, want 200 (431 means the knob is still dropped at the wire)", code) } } // TestHTTPTransport_BodyLimitReachesTheSocket asserts zip.Config.BodyLimit binds // the socket in both directions: raised, a body past fasthttp's 4 MiB default is // served; lowered, a body past the App's own ceiling is refused. It drives a real // listener, because fiber's config and this transport's server are separate // objects and only the second one answers the wire. func TestHTTPTransport_BodyLimitReachesTheSocket(t *testing.T) { post := func(n int) string { return fmt.Sprintf("POST /v1/echo HTTP/1.1\r\nHost: x\r\nContent-Type: application/octet-stream\r\n"+ "Content-Length: %d\r\nConnection: close\r\n\r\n%s", n, strings.Repeat("a", n)) } serve := func(name string, limit int) string { app := zip.New(zip.Config{AppName: name, DisableStartupMessage: true, BodyLimit: limit}) app.Raw("POST", "/v1/echo", func(c *zip.Ctx) error { return c.JSON(200, map[string]int{"n": len(c.Body())}) }) addr := freeAddr(t) go func() { _ = app.Listen("http://" + addr) }() t.Cleanup(func() { _ = app.Shutdown() }) waitDialable(t, addr) return addr } // Raised: 5 MiB is past fasthttp's 4 MiB default and inside an 8 MiB App. if !answered200(t, serve("raised", 8<<20), post(5<<20)) { t.Errorf("BodyLimit 8 MiB: 5 MiB body was refused, want 200") } // Lowered: 2 MiB is past a 1 MiB App and inside fasthttp's default, so a 200 // here means the socket is on the default rather than on Config. if answered200(t, serve("lowered", 1<<20), post(2<<20)) { t.Errorf("BodyLimit 1 MiB: 2 MiB body was served, want a refusal") } } // answered200 reports whether the handler answered 200. A write or read failure is a // refusal, not a test failure: fasthttp drops the connection mid-body when the // limit is crossed, so the peer never gets a status line to parse. func answered200(t *testing.T, addr, rawRequest string) bool { t.Helper() c, err := net.DialTimeout("tcp", addr, 2*time.Second) if err != nil { t.Fatalf("dial %s: %v", addr, err) } defer func() { _ = c.Close() }() _ = c.SetDeadline(time.Now().Add(5 * time.Second)) if _, err := io.WriteString(c, rawRequest); err != nil { return false } line, err := bufio.NewReader(c).ReadString('\n') return err == nil && strings.HasPrefix(line, "HTTP/1.1 200") } // TestHTTPTransport_ServerHeaderCoversPreRoutingErrors proves fasthttp's OWN // pre-routing error responses (431 on header overflow) carry the App's // ServerHeader and NEVER the framework default "fasthttp"/"zip". Those bytes are // written before any fiber middleware runs, so ProductionHeaders cannot brand // them — the transport must. A REAL socket; Fiber().Test() cannot observe this // path (which is exactly how the leak hid from the in-memory suite). func TestHTTPTransport_ServerHeaderCoversPreRoutingErrors(t *testing.T) { // 9 KiB header overflows fasthttp's default 4 KiB read buffer -> 431, emitted // before routing. req := "GET /v1/health HTTP/1.1\r\nHost: api.lux.network\r\nX-Big: " + strings.Repeat("A", 9000) + "\r\nConnection: close\r\n\r\n" // Branded: the pre-routing 431 carries Server: , never the framework. brand := zip.New(zip.Config{AppName: "brand", DisableStartupMessage: true, ServerHeader: "hanzo"}) brand.Raw("GET", "/v1/health", func(c *zip.Ctx) error { return c.JSON(200, map[string]string{"ok": "1"}) }) brandAddr := freeAddr(t) go func() { _ = brand.Listen("http://" + brandAddr) }() defer func() { _ = brand.Shutdown() }() waitDialable(t, brandAddr) resp := rawHTTPResponse(t, brandAddr, req) if !strings.HasPrefix(resp, "HTTP/1.1 431") { t.Fatalf("want a 431 pre-routing error, got:\n%s", resp) } low := strings.ToLower(resp) for _, bad := range []string{"server: fasthttp", "server: zip", "server: fiber"} { if strings.Contains(low, bad) { t.Errorf("pre-routing 431 leaked framework name %q:\n%s", bad, resp) } } if !strings.Contains(low, "server: hanzo") { t.Errorf("pre-routing 431 missing Server: hanzo:\n%s", resp) } // Suppressed: ServerHeader "-" emits NO Server header on the pre-routing error. quiet := zip.New(zip.Config{AppName: "quiet", DisableStartupMessage: true, ServerHeader: "-"}) quiet.Raw("GET", "/v1/health", func(c *zip.Ctx) error { return c.JSON(200, map[string]string{"ok": "1"}) }) quietAddr := freeAddr(t) go func() { _ = quiet.Listen("http://" + quietAddr) }() defer func() { _ = quiet.Shutdown() }() waitDialable(t, quietAddr) if low := strings.ToLower(rawHTTPResponse(t, quietAddr, req)); strings.Contains(low, "server:") { t.Errorf(`ServerHeader "-" still emitted a Server header on the pre-routing error:\n%s`, low) } } // rawHTTPResponse writes rawRequest verbatim and returns the FULL raw response // (status line + headers + body) so a test can inspect response headers the // status code alone hides. Relies on Connection: close so the read ends at EOF. func rawHTTPResponse(t *testing.T, addr, rawRequest string) string { t.Helper() c, err := net.DialTimeout("tcp", addr, 2*time.Second) if err != nil { t.Fatalf("dial %s: %v", addr, err) } defer func() { _ = c.Close() }() _ = c.SetDeadline(time.Now().Add(3 * time.Second)) if _, err := io.WriteString(c, rawRequest); err != nil { t.Fatalf("write: %v", err) } b, _ := io.ReadAll(c) return string(b) } // rawHTTPStatus opens a raw TCP conn, writes rawRequest verbatim (so the test // controls exact header bytes, unlike a buffered client), and returns the // response status code from the status line. func rawHTTPStatus(t *testing.T, addr, rawRequest string) int { t.Helper() c, err := net.DialTimeout("tcp", addr, 2*time.Second) if err != nil { t.Fatalf("dial %s: %v", addr, err) } defer func() { _ = c.Close() }() _ = c.SetDeadline(time.Now().Add(3 * time.Second)) if _, err := io.WriteString(c, rawRequest); err != nil { t.Fatalf("write: %v", err) } line, err := bufio.NewReader(c).ReadString('\n') if err != nil { t.Fatalf("read status line: %v", err) } var proto string var code int if _, err := fmt.Sscanf(line, "%s %d", &proto, &code); err != nil { t.Fatalf("parse status line %q: %v", line, err) } return code } // waitDialable blocks until a plain TCP dial to addr succeeds (the HTTP // transport is up) or the bound is hit. func waitDialable(t *testing.T, addr string) { t.Helper() for i := 0; i < 100; i++ { if c, err := net.DialTimeout("tcp", addr, 200*time.Millisecond); err == nil { _ = c.Close() return } time.Sleep(40 * time.Millisecond) } t.Fatalf("http listener %s never became dialable", addr) } func waitReachable(t *testing.T, addr string) { t.Helper() tr := http.Dial("tcp", addr) tr.SetDialTimeout(200 * time.Millisecond) defer tr.CloseIdleConnections() for i := 0; i < 50; i++ { req := fasthttp.AcquireRequest() resp := fasthttp.AcquireResponse() req.SetRequestURI("/v1/health") req.Header.SetMethod(fasthttp.MethodGet) err := tr.Do(req, resp) fasthttp.ReleaseRequest(req) fasthttp.ReleaseResponse(resp) if err == nil { return } time.Sleep(40 * time.Millisecond) } t.Fatalf("ZAP listener at %s never became reachable", addr) } 2ybx͝}su>E 8&EqF\KBRuX$,Pz2U+`k?~0=9ARۻTݷ=<ޞogu|XU6 g6]߯z:3—?/Eχw/W y'C,p>ƫ˓pvOb=<ԋxPp u`7o޿aut=GOѤ^Te:zZ/,ʤ\NMhIsT5=l5.k8<^N/p}߉uުf2z?/<=޾9kjt`"i{iح &&TdhxY/TEWѧ!E~`e{ZzqO|^V.m͊[hYMgsyE4s} US^=[_I:Sgx ?.\ y3\xD!aGƇWcQ|d$K>^ Ip*G'l{/\r ] $\{OkH )AA*SjBk.ۤKal]WFL!UcyU/cdc2Xԣ~՜`3dh$c j1^j)t%ƚ //骚_Lsbrq:X,j P`U"U:8漃L/^߻Ɋ'c5-\b2W,gy]u& "UOF[zVy;2kկ% ͰPRr5u4ZK9Yͪx9afaP&a߂w,L.$M7{+R$%fy9%q+2+݋c]⩍}[OL:OdqHe,=aU M;H^_Kfnǯ ΖVF$MlzH^_/ߞ'*9O@;vhclW{(2%Kn6[_uZ-ǢUxp5R7Hh\kdm0ceR|1Y+(6YsfgWS 8GKyh|21 C.껧Bz`Mc 4  bvwqL/b' V2T˷7\r^Á*t~`Ԉ,I\cA8ofD'${&f|R#lԿYWLo-҃`qVֆ1%jޙy缤x  ӎD[Otڀ}1Gyr~HK3II},w;''3E\^ߙW&_ l<虿"“zR㙺 d=!gV] Mp^y  uT |Lt]yN01Ru NFꕼEiQlR?.W>6)!B -[-']"yv~{T?ʈƷ߉b{ՏUĬH=خkK ^(xA\c $:T_Wce9Q᫝o^=ST-PrOWR$E^Zc-X(˺J,#Wz l OD"^Ֆ4O(vI$^#lY„~ tZO Ȫ v+^фI!(IkL9M!eZKYPٌNۖ?j:(LfUz$gە D,g[T[xX1dԴ^Ņ5g{hwriiQcfy+dz݃xJ3vd&ՙ\FFr5@ի?He~ ?$u1@bЁ |Xi!RdDI7.YOn͑lPt pB>uYjj+`Q^`3ɮtg ܔ4"se*Y|(Y,Zm(`#a+ kyƂrroamHl,bb4܅׈^LHy'WTPwQ{ @%lC~z ISUPc!x^Q%},"9 :AYdg #ԢJATY+.'Ia &^(aZ0mY'ISM2-*?1$w>}9=zGˊYbT?j#dP㊍OF(evG#G...B+.p{)WCCvGK'-?lDiHf/ $rʝߎ?%jj])ѕ6qT5^j;ξ4jj͢V&ۙǃ5&ZRP$Nx#UQ:3Ҳېi!.G"k4*HʚeGU+YRfCl 5,{˦6Bo`(9} ݄neRwMl\[{`/{[e '_o ژΨ}at.JbXbZh.5ĽRVK S'Jw`fDXN ^4P}YbRԫ6%eGQvU+ݞ,+"iѬK9zтG%#]%c[Fo2"8-* ?8xCEgL QL05D2adD}7 0fS]t;icWQnWEh\'),E*jol*w يR2<$iA \3 fq(6P" jY6<8X ;5 FaY lC8Mղv΀35&ft65 C[/`,ppt#3gKKH|xӮ+fH&,&E6}q4YSvS#i"ۮ#"zӲoWrڼ`vvz+|ZqLw?rƫBcuy}ǿwtsc`;8bAŏWF!!'H^:TNfu`$1R-LpB!($2if_s?u~TRV }?h Y,CsHD(^BUqdN0e$2LX1q$sx_*akhJxΓĭݼLjrNoэjKamJ)lآF@|omIi|H~%l"ݖs5dze .}„X*hWUY՝J Q]ܤL׃'DgPNʕ/ 悔 >1@]oa5\թtjjDkKH "v< \ancGĬqc1mx r4]5-%2rLĵ"@cw.[,qbk6)' )Je5C B3B jR]mcjyt!4e־/PÓ%u^<i돽PQdWo* `hSmX!}g\\h"-O^`Q`F)X'(_m%- UiV-#˲rwX6boTm5h{aeDjĵZ#h8_6= T ܫGP4k}'Ţ LBX6$4Wp-"R N J0YS?,o.Ev;^`s7jA_gUhT5 1%IZoiߙM5J fs8Ʒ$eO׎$A^z HHg>ׯ,VrMT]Ń&+9=FL|čտwea(& BF!nױ˂-V8;,k쨂aӰ/.ցz]N 33Xoi6m լ )D,Ru_l  !ɋ@5SiNO$!}9AȰiD#I&mkRZVv&Hݴ[Po_tŹ,ޡ ӑI?qx6UQA>8 Yasߒ@fq1ھ$22DJ) Zl'vJ W/x|{>6\|g, {-/#a܆Q@ |1pOz".m8?Y;a49Kǧm(!d[fָNP9 R66JTE]G»||wscj1刷`vO/n+̳`1,zX3BAN&No5Mԭʾ=ߗWS-I%|N$% ng%S9!.:@Q\ cShF 7|w&Mvsƣ!v^A,d1 .}eD`շOe^1],jiKX(<{j y7{#]Z8 _!ܠ8PHGI;9]c'PlF y͙Z+RɹIVGLۂO4EIW6X]M%؈ t};:7:) h3I?1,m^\dwpɩ˘+Utδz,+-bِ %'ۙStY"2 8kO& c)w9wxCE. h˝]fVDCQq7e] $J}=(T* ⎴J+JmUޱljV (g(Q$/53 k$h8]0Щ <&F^a|K>  dovcn|`>q;2nXA|ަ(C HƆumP7IZybŝN g p)o,Yt }u:Lє"gdE8] V#;#*[KLLK0Ӎy(٫B,5-FWB7-[5Kx`5{w 7`U".GšYͳ:\n/'K~sp<ѽrfQkXWǨ󛸀ԟΙt,C\bHhġGw!Z,6_`_ 8؎(=Q=xDFhL. |K?24=15{gS 16}jfjQc_}BZs);.ȼ/nN8kYjCC6鿲YoS\Q鸑KO[l/~h/ZX %CoTm?.dnYApHc!1 R5^׵K\[40c.[hhfR$ A'fP$+O0p#(!K:(Ko&S&eƫل5[1VQ\Sʙ:Y`ՀNΓ(xИR%R[D1OwL[j:)hvA U^'IX:VSG/b&;oNԑ_w>9QW zAj~$I!f;qL:B*pwT>y~}3o桺>KtYĐE3Of;\D*eV ;VcsXJfOSTGdP,E$seYSh1CL{7 n.!vyD{W;i7O@_q֩C#PQ?1'!˞!ۃX  ^)\w^Qp2ѷ#j!hػu $zplvmGۀ<=B^\'/ ,s&J';=W*~PՇ"5jbӥ)}ԝ"in%`N2rvuDQB NAR$z8Y_X%MN />cNā.Tܥ&)1*#_uРE#_sVF)聧. Ohs0 Թ,jU?efv3S+vpז" FG\ )͛0EE䒠2<%TTc1tZb HJ}Cg|} ꞯ8ǧWfPF,{\GrTED?u4_RZDGqَ~Ehl4Auτ73ˤ,t}v*+KZiF`ODŽS?`GH]='=Y{=;L5h|yUYַ,~3x](Eteɵ5<})I8 ; ` O 9ɶޛzA>{7n(ǏӽcYbX/e;AsK!=om&GӊtxbebB[KܖMo-Af >r$iT|Oѥ#8Q^3eyn"V5P.9!9LI#Bqt4TLJzoRSs W>\ 3o!c+,zwlv2VQ %>[EL^׌\3ι *! Do,lrFh_wy2^0毬4^zm~osħ*9z[Z'?ńjp&0!5 prA`<7;Il!lA64Ui(|EDu兮ȒZx"s&)e :IfKwx_W'Ic̚KOs%tОs<7A61%$; 7^U TFGUt.%\<6w#WS|5_odSvYG7oIt6Rq>3I|".glrc 5e*^NoR'MghCO|ǧrUo]aQisK\ DeOGy.8]E^|iK8(Ч836U4& V, SnQ 4E]},We&Q{P@D'1{ZȖ;&}hUϦ䦷*(v]*8\;RHHrr;r$暷6if,(/YhTHP:NGv>>|PkoV 0j<9OmqDvGAchh$7>q7q ?L"N2ΉH'DN*AFHˋkfa=eqѦ=>ڃ"W^?ߙzsׯ^ۚ~l.TIۜF:O#(2azCt8:k䞍HjS΢NԢ2#sAK* Jskq7Ԕl=!Ze Fll&|S}FWEӤ3'R[@a=SP[8[@|]̓P/vxl E/,}5?̲˶h1c,ө QvSzFєJGP .+2O CI) +jt׬pY10w2S9 UcuR;SGVS|sI _HQ2S>DzZR,A[ko@Ot^lF[)K(fMNTWm=?SQHG9yA9 AKݥ%4HO]YVn>SA˃~L/U)UGS4^vCvY&F(`!;C+`ayGaUIQuRy/y}VϸJY8?T`ڲs6e }sU=^,oH c\AE+,*PLB5DBLFlڎ$TRdE@YNNI 1 x,_HHIM@ vz2AbK!ؓ,ouJ&_IЩ Z41թ*\msMRl2;٬#ZC%c\(jrp[`SPLm;|Q2jY\0ne^ZټjUwЖY(KUSmc؇D0ƮLJ56W`nhX>h{0Ry'.vn)g XVC@ 7`MvGGOmdI<,e+ܾu}7[/yIL+HџɮJsy(m([[7>T**sWӽCKW*2 h֘ f?PT-כbA1Jh!'e1zMVs6o0gnlTh.i,Pf'hONiUV ?W Acu,WO^a8>AclqMI.Q c˓a)py $InPL'!x($ݎrK!!/Ë줺P˩*;]|0 ;t_A؜ +O[zD Be+w1Sy|Aӌ۔z:{an4}8LwX6xX0*7kU/Jq- v5vrx0{ W9Ο􂒬jult[(t[`HHI}B1-~x %s(s4Fm =t|C̔'~YQ) v&A'm)mn0.E F*#I5bA!)Ďm8 .3:`S&l' 9q#;wR+]5-軯"7kgiI9 ^"D rCXR-b_\lhB"Z0 g' b @@F7I / 2".bАHpoȖfd$GeNY!-®!6gDXp@Hu4QaoJ%#׺Q+R0dɚOI:+ʼnidR?/:S^~Y|(1,ζH^E*cZ2TriM;m#,T"Z_qdISV4!A 2|Z rG##GzZ;Cp)\8ZpV lpJlwzIh[aM5:WIh:'9/uL_zŔe.dh2:5rc>e: I.4Bphr9{;N dz$0Iߵ"Y?x5Cd&_<ۖpq4y ՙ6`@ cLZ?ftNB" +|vo`{M_}M&8 3Om"8BD u2$t4% }y7hT=5KN?ρ,?:u$x <}ҹ9)v>D!hA idOdhAıɋ ؤёB$V0ԃ qBQ(SA0u;VlR$ňi|=غGqmo]Hox4:xр24o9iC7q҉Xx|<{JJYl29x2TR,w7Nl,nnqVy!v}-xvAĚКۨ{o*!=\W9J +{Y"TCQwd<>JNQF4\LeeT39I_8xxMSj1!Pcm]6=Cb V#Zi ΡB}>@/=mn|I߿swx-?Iwt[Wh+;RRGA_C63쩚(.?Ga2eΣC0QD崵Mm"JB!ZLVtxZgy:zmk2qR[W} JDt Mg$y2rp 5Ջzy<h+l)돬 *o, VF@'U64)\WY#G=C{ p sߒa@A$̲M?]2iauƃhʆPH$eT 6T5Ę}`*ʼ5%c͐Ra;8 裗(m2m' \/rn 2c8Ee` Ge8$M' ^M AgrGǐOQNsI:ٹ$޲\{ަ^duwr?V@O\l']?oÿm6};XxCהh // AS SERVED, not as declared. A rule keyed on the path has to see the // address the caller reached, and a recorder has to name the operation // the way the route table and the registry name it. Both used to be // handed the registration — the bare leaf for anything declared on a // group — so a path-keyed rule silently governed an address nobody // serves, and one definition mounted twice reported one name for two // operations. served := meta if c, ok := ctx.Value(opKey{}).(*in$vocation); ok { served = c.op }hservedl(servedn5// // The id follows the same rule the registry uses (see occurrenceID): a // DECLARED id is the op's own name and composition does not get a vote; // an underived one is computed from the address it is actually served at. served := Op{Method: me .gop.OperationID} if served.OperationID == "" { served.OperationID = ID(meta.Method, served.Path) Ko=@~xU6=K_1!@ZZ ۤ`%64+IYG %${ۦhO7oVrE4U5.@&4:c4қ;o4oh3-dCk]67V'U` ܆Ǡ L{D-&Yaw1'@9͛Cvvt9"h0tN-uxVMe%4aے;oY'l|6dŏNMwؙk&f葭t| X/)_*ƼxTbP(?1l =<&e{&&qp;GrRӄb/B]eqIɦtsTO3F y|ȋ՗JH! V3c˭IɳXq917g"vpu]/.rlGqN {fq&/pz±·8:ݚ]]. 'i7WI!gbEGN,γۋ-ђx<m ꌁN?7X~<ҕM%7 0à,xWmol, u?pyC`łhXYԑTl? %'vEVəy晇CV'a84ں@p,1ҁT+y5 2a,n&K:zꅷhlgUP;67i]2 |zBWg7?r>L]:t:锎ΦlY]6+S})b\9g]ҩ ^49[G]˔ ^9Ur[U:Vdqf<0Pb M:Ѕ0ɲCWժ6%5Rjא $1Vw8 r  #V}cXqUb6lz5l>=G dKGAapb\0ɘNWRXM}8\eתMsO& _hxM,p91Fs, cxIgרFs R&*(fC*gPN$llnojG[=K4}y=tbP6^cʫ`X% Uƒ/cB_7=}Rp%LT֙ϺH {B"'#F>lt5H G=BF<ʄ>0a2d|0M| 4 p GʷNjU {:ÐvBG#bNKQ \ 9n<ӈB\-\.zV\уp[!{ {8g4.KeZ@tIN4eG=qлg{Hdi0X};ilVj]o 9ZGzqI6/o2|.:G<8Jbܣ}oOTKJ6s[mPm3Ij2[ފ3{jewߐGk79ovS%./7$ňߎt6y~}Ӹ-TvOBfs>2?>w[+_)]NX^4]8u',mJW/v?a"99x6ߣE1VpʸYI[ ]I>h׉n3s# SK' M.c:fAn;\%؁*1d>}879؉'%af+Q'NCh}YYчvVW.Q! |#h*c'鎜t߈(r6[;G;7'6P0 g]kP\1{j3wt*QF7*Fxi7iͫtZJ.PU Ke%X!POu{Ny6=:Yq#]cr㲼u72mDX?vA s.$q: Q6,6^H%8}!zįBN]BՀQ-"z•2RH;*=[ƈyͰЦiY #m.{Q=2/^n19a31+K_*kY'd 5ļ(BV%H^]tRH'*͎;4i+UuR EP ˔V+U'&xj8>IcP2X"l`BfYjAIaY>| L$Dk2۬zXZK.m1HьyX+O>YLs_M1do#78(]4S_@#%љ\x؟PX(aR!av9%RV[m:8^2}H:gҼNm7=G#%Hm OYLFk4)JF! 8k8F#}.JWm`Z#Ii?"U|"HN8>au8DNZF-l 112#icD}c5@NUQgP'۱iLxdUKG|'"oY嬮_SJ|#ļ! MCSBSSQ2ܝ A1xr`o"=?֔ʾd"?:z sd?7Bcꦶ˳Y7rp[xȿ#E2=$gW`ވ#m0໴H9q=>Jå5;BBчhFZr 7&_x[-PrC 3[{jtc0w1#d xXr8}'R<*Rn3rlSrY ISV4UGl_.v!!Aqp[B?)tUhD b;hIGA[(֫8-vzn MZ\V\v+g6!?-0tJ(!E!-ȕrʼryg:وys!$,C3_W""Is0;疸HsZۯvL`$ Rgi4NT8t)T"sLe(fi.ah)2i!C0vde-`tKmR =:e)*2Q eTb-kzHVc]fȵ3N,s¦DS.psop2}T٦ô4pJiO|VuciLlHk߭wus藼i 4H~<1b)!$a"0xv%q }0kJ"T+7N:`O_uapL@0UZ'YzTfcF֫5)mxn`^MsD4q]wcQM#|Ss_0CѦ8r'D>>h*4柷ӬE7 <7)#R{?'n/A(>V2uqe=(P@ն$l;%b_ (R*rzm#-?5h58O>/,AǸo|n)F!ÀĠ/zVB@RAL* rV̀ 3<{B49K᫑x-btpzQI"N@HsC,l{?C1La(8^H[0[B@_tKԖin{Rg4``XTUʩZ 0'\:jw;ڹLܤaV|477z#7WX3˨o%O8jֿ}?U>V"30|,i-u;0?]͉kj=(`@>Rl8u<,SYuwP7&oJ>;H콘0w-HќS /@&i "0ݎ-ThdtU||}~B*N3=@ᾛPE̼ A9:efb4B]nR/ȵh-8ǒ(\qBt1QɝGafA0 dQdi,:`; Kޢ6 x})H'?a {}=0 rj#.;?݁1ûcvF5.SƁ ,76E.ZQFUuA }+j;Up='} 7ڶHK?&wS a}ȈAr0y| ]>Hj$|-25eհ!=zcf7 #\u-ڀWԒLIJnS^{}A.BzX)CCh\Ri/Y+ͥnU1$KjdY`U!&Kf],ljX10k5ٹ\ƺQFRE7s?\4H=g%4Yh-ɪZw@eu9iS͘W)\uarl^@v"—",I s}w[h**4 sZ>8Lxd2bIVU?UCDZHm\j|1Z;Daw㍍KzzL7j?{!I,5vƐߏ> 15=uNN"F4 =|rs0S@NP!(瀩x 56 T/Q bl4iU/ŬM q{ ! 3 Q_QVLƕKr>tZdJjB;{ɼNK,xU[6[(b}(YF1OcxrD'(*Soצgy{PYOm{_pԕs6wWANJH!) F։hKQL|UL|M܆( $u5{s/uG*N]ݧa]" G(ªIQoPfԮ / P6y>. CaWńLưU98o9ʩmr*[8Ur<,>%pm\@`!L W{~xLxNw3&^U[Onm|˯̇^Fs~B*C{bzKյ*<)]q[i ]y~Cs[6ug:s IhGD:o -$D m=+wfcTi/{"- t' Q9 ֱ1u";fԠR5Ցv0s޿XڿRNd7p䠊ar[vu.䏘vbO{~gm+v7ъ˶ϩf⾦xۄ_ABmuTqNk:>W3D.+?϶UP{eZw$0iYF!olڹA!2ű?'MMDvYVrh!׬[PeMZ{[}msf] zurzf #*ÆjacLW'!A k `8vxNYiGB|2w0FaVf>abg#F|)sAK#0~xNB)M;g!2"Af/Ŵ~H^U/fdkLc ]߬K`o@zL8@N/d>X#1`ex"؆FgcCa :Nxݽ`x_]o}VʯlS 9IX.:+3OW*T't@Lܖ}BNG}t$%h= yKvrkv`b_: Qй-Sl+hSc^a00jQJDB-Ĭc)aVtRI{N!)7 \YMdFWylpg65ICqC6C^CڣޞiJab=/<o:!Ll;ZwB6R&-D^{f=:HIe<}Mi '!|7-/-9%^™2TlsXΓFń%1/nx$AR!$-%_Lpj*~xԝD [w›76L@9I)3%]Ձ]t)@_BӬiViDBz[מ|BE78.RI= z Hl[pSNv9W | }(/^![JAtWz7!Xs:$:?.m(xvL_'4T}e|x~;ݱ+mϭp#D|j@":_@УEf}g/f-MjNg٬_LD۱v+أqzćIp xEK0 D9 ${8ۺEH8W$o4ol.`gR N/Jp8K%I4>S$0!X ;![,5pRUWBWc-p.H4@5c](nԘ]h.K)G zLxVnF)K>qqEMIDR(B^mc.C $f׾;&RD睝7[\L$P KʼMJOh8h& '6RiUԤnӉI!+4l̊a WBGhFY"ݔҪ_uRIEV'nZ%UqMi&SV` ,ԙ/#AySR N6gIjʭ٬ Ng[mƞ2EsIѷͅv0ΤNf&mM ӋG'|0-(rEZʬ&3v{tpS2vj2Aa1"i-c8yE}ᒗhQFÁXT,JQISگU- VU`ld׃=*d>gZGǮO'J2L  CraS>#H(ެ咰ptLo&'b<. \d-Er@Apt#0=WZzq (eFʦ(3.\,EAMR9<`|L5׮j} M!^&SI;TV^ xB,;y<1<-2M)SC-OqVO ^"nf,hXMT`6es'3)2~Fsh!i[r_P^b_"+P6X b| и (F-k]Ņv%U\ [_óBc3@<9žȼ5[ɔjҽy2A-Je{{/\Etep0 Kc`2jG seJ[K("J^{l途UhFϿC>R]ˠ[5C#CyY2^_\(_suYYC; ?{U]4J/@?f0"1^-([@CL5+\Sxכhtiz-W-)•u@6k uQgt6,dO-$nzR$c} umnbM~G<1b9-5p MIwdNZ#9&;Rmøgi}j7DR?Rp3ze66EEN / u?R4G vGr KK`ՁD)XH8;%`W*Z& aH_kp]6s<ٟ.b:۾i5 &%U.D9vSJGX+(;rZwE4F#R_/Ql"?jV7͆H)+Gh*8~A#7`aG CZ_X |2kn"ˑ-C1[02EƐA^fG.6/q)bYm6 pDtcXח*7i_%R<)PXn[tݛ֡i௒!K̓ORMc 33xR洍~~`f3>t$,9%< iRF/${C_Sm,Lo*gM5<6}HGh iצ[En)@Zz,KlCpS6@W(0ol|wyvqt|GG6',{KB4p݇irDF놷[u "ft ݆ȓQG'-|4b弆& H0FmSlcƄ48–n,r4˦SY1,^ ^$ KUuqNmʛ϶'kqIԳ/i:d:U/>`S*K y;GyLT`ϰ!B$&%O%ptEB ƒicw8Ž19= F/2OU8|eF’1ԫ珡F>[y4Ǟ%t`P7MX,uw=-jC5>Le;(s6G6x]SM0=GbȥIH{,,,=adyl%3K?3ri>޼4o% gzmtJٮafs\-s3޺t%A>?^vPb0d HsqvR@`,0U^.FO*Oo]q KN46~Ny ѡGDEsbVuUEb!DeISkF {}PEU6hq/hH@)^ C/Q "]>oھ}BJkTa8Iw?k-2S , Xi ?H,e + fyLnsSw;ޛZ,˖! =G.!_;Gҏҳ?|X&e/>ƁH''xM1o +^3QTUب&i^pZ> jY?id|(cH>1 h\0JXWK~ Rp81N6Pg#mb;r.X'֟lvȡ:.(M3S<q!J%?5۩A3ۜ[:Z1.滪Z$4V}ÛmfͯHq\Fs:JcG.:{lRW? \GJ3w-+WR>7#WOyUWN\QC&~!úxVnF}6b"(U({K~p.! 9$vݥd ЏKzf%i}p̙3b.k.IԢ3֋,9J F~ S*]O㿝ͤR-^{ ~t>yri2JׅXYҙ_ /( -43SEt1Y|o~O|ڎl6J:qz.60 o]ᵪY69SfXy;[{8h,N''`||.j9"=^Cr;ɧ?ٮ+Y1P W4Q!I&q!fJKd)LUn.jNCh lWs3YUᘽݮgYc4*#NwReBZ[,zEAT[!l,GÁw(Y~EI'8{h ]r6tdp9No[zG8nM]S2xA- GF{IɟXk"k⍀>AقlcL'1v}P82@:dZg|-+v*&X.zÉ.#Е+v s+iFUE1yt+řR}y cos"S o^˩X*f-fnP!%*sӖH˝n/qE,g?̟hr(uZ5Q-X\ȶ0:ÚkgV1z_wg\Cի)OP*ߤse)Pg 6 wطdEhhm+jɹ4WMѸ]+C+v <6bXlQ ʑinl Nlj<(쯮.]x1%0= [.u g1͙ 9acEK:۩@ gyy5b}†(J(m@z{nYv_xJ9,uJ.6tFZ-WnGWa@q* ㌕#Ƃb,rB9'Ba0 w(۷JNw9~i`?e/ܚq7/M$7ƕAO+ܻ= JӇoz& x}rɕo)ҜhP`x&bE-%R&)+zhJ5*TAO8O;,31cu]t})6_Ο*y~E5Q dE TDcZ|x!J܇r,Ӧ27X <]3ω2yl h'vo4mZ&'\idWeJZ$҇H_m7Ĺ+"gēKe*pNԦ6v><Zb-O)6HI''2BLBmcU51 }Mhe,M:ˏ|E==Yx^gqHڂ,E1[4bn^onVͬbY,k+prh}ed}ryse}GRCiC ? +?+8);=uFh2c4~Yжފ.Vg\Ƭ4=9% z!.7# +TyH\ܼC|[|!TmYM`ԝke5moPLDnh_>UԸ|A"+a;+]],Cw~q^q+rSba  ltAןш)o$xUtvuDVļy< t=xqؚ|$We]pbGe]FX"TBNM$Cg`3'ğ' p|^%%^vja]= 4pd(u SI&}}[BcsqکynCb?s%qP-|cK1M=q<}Cֲk`x-I7LEDًapwʺ@$?Fkt$tRM!@< 9y"fduQ松G \m;i-K} PRTl6k*aY#NE:ɔe`ԛ6&raG`hۨqy7* =ZֳNELΈmc4?Ou-Za%.x"284Gz C2q5'u( wLV\j+wDTs_껸ښknŘ'|}9@Ig= (2plp0(a*/ (\2Qe1"%\/e%ӧ%$G#Zq KY5# 挬J_2C[ um#u+Ux2h 9[#QGq73'1ў?U눲,4!Qȃ,K8'dV0N2R L_G(fpp%brѱ.qf0ˠljC"y Y-).",5k? 1v$nAF~.i2OFSpIgUw~qTfM,iv9A]Z'2 3U2y8)g& ,S^ q) ~ct_0VJ&6״&]Y -W.3?n3w_i/*3,<}kkUC|z,nxorT?}`! i4Mmn^ݱ1LY0> q +cVJAМL: Lq <츆!M,,DQMȨtymBlڊ(L&K ލmۃgN(??:2/65n+Ҟ`THΠ\0k yz񗱨rAleb޾\NصXS\?VTcucG6E!Βj򼩗Q9^^\O:8b kR=2IWtq&_=|Ovk"D.*-n~7$k}y %ˏ[:>?>Wm@OKMQnA"&"NW3ܺQCowpi1KdVSWKDMu!oiZ`j$Pb٤ 5n;b޲>#hie8 |K%TX,2~-4>*ECH~3)܅~pq766~6;oy~.e ƓnҪ0:Їqt4i:]:|SS ])$eLjzq`0xAWVIjm\E'>0$,XjT&H o9g)^ z}qN_LBdtQ%JRI ?4M5oz "c.F#7lP]͑B#kY~dTH9ٿs: hȋ4ӣEz݈}ߪBuv eήAFF0wG/~@3c7PmWXgYeA5ɛ73~h%xمD!hMX`GAA+WuÈ#^b0b?;`I>9q"pj$(*sd4ODSlk a ܑb²=ZFy|X8Ç桺M "#f{(vi@e^BEVmn>́uQĬqֵ^rt&k~AU4+N"jaEZ#^j0U]͑ zy M-OϦs?^N^Ǭ9N"ZmW39'|W1 Mczm/,KnW gIqN޻sًul¿%qN^˷.\ t5 2H!mRnIīX KL 2ކ6C:#ﶳCIrd4g# 8OE5V?aUXk}ҋF80*Oh"]C%x@@A43~Wt#?Av J5Ru%;co"[b40& s>%9ՀcrN@m}Ag͚:.$* [K>eAb"Ŗ~ X.Itϴǝ\{9%*[4šX:w3O Dd,ZUںfN_^|>+Lׄ^6m<>G[:,E͛KÉGEt8ONHEc1bbkB]Y'| U qi(xٟћ ~p jZG@W7y? |5r<4|hBp@= I%BplG 2?-8܉a˱xEL^GQ:WT)*`BL(fqXEǡD-Q5A2mN`@a!}irG|ϕHC"YZ~+ۆ1Z[LWr#/,7ZNX-+ЁȮp qD?pS~(iwBD2{Zb <:PيE-8_gz[d++0n;*aaYVreZ8=O'_KYb#FaZV3UliԖ>y h`VX$%r=ɚ󫷓˫$剡`16E&.TtGh'!"r?T(C'Kb!Xf9j~7ҸBr @IȪ\09r'> gUk/=/\jfQ ,]. 5e[t { 3 zE-:F>$1s_RA]@g Nއ" -<혹lu#n_ $`Wc}q>d stvқ6Fb@f\`;)cS 8Wg~{% <|~ancn ɏ +v5K2"i:j{ %^q+LHAhӒ=.NCrK_1)gF(TwPܓz>Iن0(f&u,#Ǐq}=&'#Ts4#.ː` a-ќ 8ĞՈC}/p >r&y! F⢆XjWHs~H CNJn,Q|k/7_y /ij/>ÕO_kD\{{nCgo¸Kx}gnB|q pEyn=Lpt_5Wz |+ۃ/dY%~*]U[ľ\~R;QN~?9s?N/da<~1ݷZ@HoAb =C}d>w'gg+A%0Њ pq!ju鹍F=ۑK +`!EqM}:dk)lM|ύ!cY, 't.u*Q\J"-xk"bDu$Xgs2cϩYE2kbUSܥ##nbLZ\ Ec/x ! 0CV7&Ƅ03&" Y0`^ TI1u(y-Eul^b.IrYڅ&6".Jv߹RaHA IWEȺbGGQVr]D Bʗ)kF3oy54f D@˜ZԞW%R:Xb"S1㾚'YVQv}s4\5n-,#Rk#aÃ%b5F`:u5*=s4r]~X=z ZW)i!.77ƦMߊ2|}yzrI3 &dv#HEz 96H8qp$57+lnl^Qt 3Tv\_49Jhš\ f2JK5IN'Fb^m了 ̡duh/ zMNW kҡBbL K5=dУƍ _=R"&u 7gqj0ZX|+h]Wn{Sd֣ 9]gxsɣ 4j5啢0d->fMU/Ф^&_fbLa[ WL$`?*55 Xx_)Zסϖw^e]?TӯK2vԲ(ڲPba& ʀ]@p;yӖ# '2#J8S%vH8d39}1l+Zv-dZWl%kٍK<"=Q+٧"Ǿ9HWoȥPMyNp擨a'َ4L]Tnx"dkw$iE[VKI",wޠȋ'%dVm'JG NQtx{ně`(tlvlaC""{e ܭ/UZaYTp+fv_|]FT)Aѩ~D+~d~킀*}lH9b߀d(bA{1 ʗLۋ/d"yf'?9HHY OW۬iYSp]Q^Od)r#P[*X٫-XkDJF,=cESy..qgh% /\dZ;k ՍX8VL+Z.Cgwfmx6z@G;֤n9pޅBiPQ\Rfi8͵rˈ[ bҁ1'0jRJ*iErO3տ5zi_p[l;`>RfTWN?=y!!byrqI쟢i6V0Dd;wױa: & E4^ J&z}&G{eXIeI3]i$s NJ8J8\-s-Jt'¤Ѹp -VbÚx\i޶L;HE׫W}*¼[vG^Z߄K.J=/45)1ғw~ 9I]#XqĞ-¶alpv&b|'w-!pfzEf3 ub%Y.w598?KOdhHcKyN$`fEڻX`R{*I nA<;.6J7I)vnO=O[( kٝCGF9J4n;V1)feU8;^̎]^{rv9,vuﳈӂ`,ky^,zbVr_dnQ?<+EF@DX#Y<(F/ sdю ,/`?A/Ji+ ,Y@"S9Ѭ'%[2.ZkzNpEPɯ R.ƚ(3D yE}dle6e}+@jM?;Z:r']}_Wl]_ݝum!@*\=8yT**r"WU@RV~I*6bq6E+-s,;1=JkIa87 =z]́ΦX+#QE Y)㜒I<=y~u )+;FS+ {I!u*:87n7=0NPv $:%u,~[?hgyn>i5>=;"vWUU& @*Wİa4Knf-OFΨS+DZY=d wߺcbMD co{w;nr;rT(_(8 T_ kq`pF<\D!jݎ(O{x&ʋ5Kʡ[δtb=Tn]>Aj/xwxVkWzF(h;1ux?̣g$lb3I^q? QhgBx> ԇsk\*%U˝QaII4QԎ1/3lڬ`/9xB6)Nyz/+. O@7P\|#۝{R8t$u =6-|ۿ|qP M>})SmU@"q ;olc_]9CϙDzs#>o^Kȝ ;ipfeubIHX$K5uӝ?rͳٵk3[D\zo hfKLO'b6lTV/9R`Ip5'3P2KG.w6_e+ Hu5,\=T]Rv22?. 8'z.&LX k- OPfenR,&KQQ38z;Ҵjre$jÎY ZURhApV_zg"vw'ݹߕ8L%]~Fo5z^<-Zt_|7f9pwj%XdzK$ Os1AĩR|#Q>W_Vw靚'ꁛw1 ):7M7]DVuRK;N6{.imMbb&}cpgSk@%4`+4@mAݠxPL6(tUE 8p '.(x8hnxYn}b#RȲln`;ʍ bA+r%&ܥE?_/%Eɲ}LÙ3gΌ2ʩߣU6Q܊vњ$?t=J1JTkΊq/wrm>fs_,dƊXЈTRdq1R#LZ F . '{es0JA5B6oFb4P |ulbUC:U"2woꊱ dcw74ϋ4%7q[EN VCv9$,9zUFnm; H%]"!Dig g??A벑a2v%FOPD"2Ae6+ʄY?GƪN]`%'p4<sG&ODWK,fQ0'ȪC@KpKY!^5TAq" *赭xuAnWD@qUK#,w͆Qqf NNŸ`a5?hK%=zm{I4+DfVY6rkr)caB#l2E5F2@P,v+T a1cAƨvREn r9L (=x3r+?aL9u[ԨsˏU<"l|؟^9{EdZdmJC#Wq*YaCHq/l }@;ҕG̘b@%UC0OU=a1pܭw, \)'-S?!lJd Z/# >X`/NŠD#nq^iƨ|d# uT. px J۞>\2C|"md/,b1 ȝ+[)Šyt?B)_h.\&nR7)҇kH#1cG#Vd nX\!r:]=:=B$hDH8,δ%6 fk7 dcU xvMl I RlTtBרoR|DEx@x'U pŷQ+@E7&|Jy_+NoAO:AbdgFY+>|0E8~k$<C8=u|g(8u2sԄ\FB0@BLt- T(Pm1J1x#zKdXP J(+D_;v8j6D>r>zI|M? 'p̭,~νqǭglR0uC^*¢"LSc s p~].ÕOF9 2C׏6F$ݾ#X]{HS51WAz䉃A:pE-$Ix(x"~^ܑ|FR7+qv"h)Gc:m(o 33T^$0@RYP \ P_P)ZݨԨUaT1=~:ke=uPlQ#{ے6zy꼰gB(a@:QRJjhP1{ɺi S )ռGIFcXtCG$c@ NǐJ٦6uT*$4.BFVؙΡx(PncCpyJCFZo  4v6{`ЍETqeB@m3Bq"+"Z#; 44ԟ?z3+qh$ ٓ6OTӏ&ȗ #-k!toDb(Gb$VvX'>^L׾t5fM2_ݾ7"R" a_c5dxA<:I΢U^w(~t&l4 `B<:/Sι]ĶAR CE&'2l`8fnv཯?2Ms+JѲ5lsa"$`(;!T;ܨcG.[W'VC `P/6iE9 3C @U* Lbt9@013sK$X%aAÏëQ90MFN7Bwg@\MMEĞb؝<OoP>V7~Y[8/X)h'bŜ ~9$=P_fԬZd;?)v/:#*qJ"V'1En99!\SS?6SC<(-!~ rʍ#.DQO|¯%`<xwCQ.M$ro r^!l!lGw I\m?MKʟ␜!j4̖VYZzAK(P̡0 I?q8A\8n/MWo-6vbƑxWKoВʊGcJ@A8EjȊ;XIWYu{S]]7EvQ]tesIF~ Q9ft7CA(iRH$[2E@PvQS!0|s+jf:ZW-@*jǢ%H&x'E0+iT:ADmwݮSBQgv~ЩhwUf~x F.#GLD)P3Nю0sc|A XZoJl /y \kYW-?r1lK3fDskJиÝPf^Cܦǧ X[Nڝ>:.v>Ļl $ā}ZD:pK!ˈɓ%8`egJ+oAk|[yUz1Q"ߕi*|]K76_c]WtbUqY@^S?kq K9-C=ծev_oժt+k%5=~R##k)ֈTCaƄ0 =٫UrAݽlt(jU],+8TG;`mZISUu<9x{]}?<@o&bb4It֋UU0\N5,O Mbv`P*3,0++^<ضT7_E]h }?LeO gΙߝ2OOހTr^*­bY̖D]9byԬ'`-`vyeDt'ŌE#2!z%p*]bUhZfВ);is"@ -(Nlb뼜!1uV7hc6 ͯO~vf̏N{x>qU7?N}}Ak??3_֪6#`tK `{EY !nB,NkYF{ax0$vx)?JNU^tݼ=L(O nC͔/1"7{5yQJ"!ĵQͪMz U7y8z\n]`m0?}j5%hilRsUz􈞺y:C/T]/$1W_mSD5/Bw)6a'ca[!qŊzaY\W+Usb<'H&b }6*Ə?E^|;AS]:}~ײUV787l}Ӽ3ȺoK9|oBMf;j S*6-t +TWhwlnVWNf"߈/AԒMG`G~[KfEg@K5^;4vL0c[ly~;r~}hhVG4R]hamlk?E>ܰՖȕ>&Ҏ4#%Y NJArm(*saYk$;7~2@ @@G/uZl_ޘPՕf@NĩDGH A F~M*Kӂ$~$E0{$>!>"K652W'4*7:AWq $>4MT|%)4%xc^S!6TFōsOי)S6C@BVVzDJ7 &#őIuF|'9/6<>bqI#ZLk:lɷKֶx\:o/1%ec/5A瀥WqNR= ې/ml5sq*M贂uŚ1[𱘨VhiuXT䏘{r:, dHN*79{lNAQVE**N- Nwg 8|3Mg!+8RF ^N5x?ѡ̦C2͗aTԖM )Yd皽p;=AL"u60 Jl,cȷ Rx7wBUH_%)]#ӜU[ 3>ʶǡb#@}Ҩ-#`+Spn {6aͳ7f`H\K$ @ |ON_f* OG" 0R<3iDx0AyaEԑwn>ˊKY_$3G1qgo@85ҲlLyƲ2&YBB+ks*8`q#c0"aےB0zit ߺfȬT=J;T%L"GD3#ɟ\@/ 3f TGsS̡qGt6uMp1*|@]Y'W]]cn)=GR1t'M/;9N$Cj>z*-ѿ1i\ ҌWl$Iz^KԴ -eAl 0 { return nil, fmt.Errorf("%s", strings.Join(off, "; ")) } r.built[name] = t return t, nil } // typeOf is the Go type for one schema type. // // It decides the mapping and nothing else: whether the result can cross is // [LayoutOf]'s answer, asked once above on the whole struct. A list of lists and // a list of a type with no wire form are refused there, in the words the encoder // uses, rather than by a second opinion here that would eventually disagree // with it. func (r *reader) typeOf(t idl.Type) (reflect.Type, error) { switch t.Kind { case idl.KindBool: return reflect.TypeFor[bool](), nil case idl.KindU8: return reflect.TypeFor[uint8](), nil case idl.KindU16: return reflect.TypeFor[uint16](), nil case idl.KindU32: return reflect.TypeFor[uint32](), nil case idl.KindU64: return reflect.TypeFor[uint64](), nil case idl.KindI8: return reflect.TypeFor[int8](), nil case idl.KindI16: return reflect.TypeFor[int16](), nil case idl.KindI32: return reflect.TypeFor[int32](), nil case idl.KindI64: return reflect.TypeFor[int64](), nil case idl.KindF32: return reflect.TypeFor[float32](), nil case idl.KindF64: return reflect.TypeFor[float64](), nil case idl.KindText: return reflect.TypeFor[string](), nil case idl.KindBytes: return reflect.TypeFor[[]byte](), nil case idl.KindBytesFixed: return reflect.ArrayOf(t.FixedSize, reflect.TypeFor[byte]()), nil case idl.KindList: elem, err := r.typeOf(*t.ListElem) if err != nil { return nil, err } return reflect.SliceOf(elem), nil case idl.KindStruct: return r.structOf(t.StructName) } return nil, fmt.Errorf("type %s has no Go form", t.Kind) } // schemaOp registers one op whose contract is declared and whose implementation // is elsewhere. // // It is [registerTyped] without the type parameters, because the types arrive as // reflect.Types and Go has no way to make them type parameters. What it must // therefore build by hand is exactly the bookkeeping every projection reads — // the address, the id, and the two types — and what it does not build is the // three seams that run a handler, because there is no handler: a schema states // what an op takes and answers, never what it does. func (a *App) schemaOp(name string, in, out reflect.Type) { const method = fiber.MethodPost path := "/" + name op := ®isteredOp{ Method: method, Path: path, OperationID: name, InType: in, OutType: out, } op.rule = a.rule // Every way into this op refuses the same way. A declared op that answered // anything would be answering for an implementation nobody wrote. unimplemented := func() error { return Errorf(501, "%s is declared by a schema; no implementation of it is linked into this process", name) } op.invoke = func(context.Context, decoder, []byte, map[string]string, map[string]string, func(string) string) (any, error) { return nil, unimplemented() } op.direct = func(context.Context, any) (any, error) { return nil, unimplemented() } a.addRoute(here(2), route{ method: method, path: path, serve: func(fiber.Ctx) error { return unimplemented() }, op: op, }) } 8.6xZsܶ)ΨK-{\Rg|TM,i|j㾲ƁH#AG~܁ڻX!)4ŀ>EFj/fKPw tr;'ʖJ)L t2l%z(,V)*Ie<΋[$/ 9 (dfDLexƲt q idb7=VzW]eux5]U @Xj=H  пtoA.h_Uf +' 6qb+.-"uCHb^sj5s[l[.-~88n":tP,3EOr)#Oa4{EBh2xVX R: K ZIȦ2+w2飕L@ [ȩ'Ho|7>~k9IՃ=L@yo)Es=b9^xk,n{YLgpaҌ8e%M22'p>H +4$֗.^z[ $(T76+`EH6hq7>Lx޴`ʿvv (1 fЖã  bj}S6p=pxtwD'z}&TpKS}b2 k%n QW=B3[q[6kQ<_6++'ޥ]-7:OO-5uFfa7~#Faw818&&qWRWuŤ!V%)5 dz?À-&wQ^A7I(t$6uIvt*x BU#ؾ;txb2ʭ1{ւ.:7 X62&*WzEHWU A){7>EG zԥ?ӫ9ϔ{_+Ao~͇d0 }3nf(ʆ=J}s=d}^<^U|MOMi I\!P@kq 14ug8dQb"dSu1i՞I,I-hx/-0bI7dB<QEGl׶xN_O@Bg9{8Nj}DIna"ɤ&[M{DwD,l{D m"j.J^It '2c?K.+GtB:=~bq2 F$W&eq Pzld"W~9d) ȅ\g.CgT ´}EXG=7c(VOb Och7s[  B:m _8Q@}*ؕ_06$ʎ휆`#EPMpT[[=T?+dY4CT%wz{+iE}4,w1D ]Q*:KE&\8p]ZJK mmΫ`6*I\v=s{m=xL&\xޣ?,\6- qbƵBG?pىK-IR~ \q@QC?h4| (/`#h =P !E(ʱ@qEFQ]g}?fR]@|A 8^8f^v!Dg"K\.'<☵ۣwB vQ_zn=|[||m "wJXaI3!iZ/]H=]ED$_D݁ |=DžU"+(; 飲<5'Z'9Q78ba=pxé3yh_t1FQڋl':btok ELsyZ(>#׊ x}`t;'r)$ڭnGMS,HCU-ܰl߱-@Vc1_bg{s!'njԯzO획wl5%/Yy3^[^…oh'ls*`ﬥL>_#J /g,KW f. ҿKU)| ޥ)az~pf@Jܹ#$'Wt^wɐ!;LNg$cFڭ${,eTCQ>.N%G!W(r?d [" Uu{1P]9 lW[툷iΩfK9T;B(ԭOʗִ- ^nWzuϕ^`P.J!ʴBE*hQw[g +72gWu5-gxmMYqmF޺]w) Q!?>nדuUdYzofTCc35#=evf>~6r*J{^9ӹq,M l%(G<; dL@ҞZɓb+W+sH:(]*1Kό9RWi?('%\W-J 51;©r3 k,bo egdMo@i+Rѥcjypwx-*:ߝEӛPHߗ&7ܡ7\H&{5cMٹwQE~zh@K:(Zǧ]Zک6φ„~Wk|C֒:s bs燎Nx+B1 Ba~KkHɑJQELI9[R]8n? txKC{rA'=B|Vt/yuj xt z1* zSZ#9FG\JCD mS1F4Ce3mLW:o 0d;.?]%V^..Vv4ڭ`I!F~\`g~s= oߟǷovBVKW/ߘv?Q&\zgyn;Ϝ#ۂw{KeNe1'Ν.nAu4TpcP|w|a=Z>MP_: xrWWQM-Ц`,=XZdȤVd@, @U(ZW8WϛPRv*-p||-~+_ыߪ._e6Y]LVM1/uwM>E1~X-l]6ȇ/`;`jT4󋬮Vˢ9w(G/Nq5Z͊~~x"[V4ҵ?z?T|:ӜiƼճ:_iD?7BOꪜL1kMMv0\Q6s\4Rw6a_Ns琛~~DLu7k|^?A(-l2ͯq>=' `vyv3˥y]2{=n[1-ll_Gy]ߩy5i&*kV뭪LJ?)8;97rM&M/ooJ\]db[ɚK-󨮚fVzqƗhdEQ/ԟI, 0M>DCveY'(g$rjtRʪۢnX&L M+.kJzsh sriK|naAS|jVQ3E &5緯oz,`Jmbs+&sCjsWoKf3 qBQ,Q AqOr);,%X ޙwz8=` SA9|1 OB5N^oaI]Ͳ 3DarivzQeu}8~SMY|єsqLaZNJ;U5˚EZ/o+uM~]˓++xNY!xyUv8 hl '7\biSW|b2h8z~IVPkas|ZM-gr| CS;Vu[ OKњ=7fp'7ap2axejx 5XLA>3GjXqO|6 20ww٢`wgo2[>6d/kM| ' ..ߡŢyJX->2`?Vz#[N抇CzYe-_\sqB9J,<-P[IN"mgQqUi*V@&>,,$h]6}Ha/O++뷛| {#پ C,2ӧB}vh "BEDӣًы$B , 6|f \j&?kM7a9֋tQ5̊$4dž!x~_ͮ`s a"7M]Kf*dv#¦i9jE"~[\:4-yP )j "q#id6 ìd4Bt׻̵U-dd| ҹf*R% 'F+Ff"JIm4gw'HFyK lfK(}nwe_w/P?)79aeP;G{%fj_]a;{O-`F69#)a/ݐgg^ϢgA&ŀ2a39Zvej?_xa_Qkb2k8)L!`(k 5_d'*-7| xeG܊5ݑfHfL {>2S=kr П2!@Y_6$]j0[@$MZ͝<.i!a f%2ĵD_lJbhr=:*d<86Oë@jd%C13Y\??]ٞwB)3Ké oM 7 (辩-;욽|Ehúf=T!T] Hpl1jämK:`liK'c=oeۖOʱq' ہ.쑄IrJ^Vq_H  Ⱦa˿ BS\EzG=4mpԡX@λ}]D@NƬ8{~uw۴Pk ®]Vç践';[8[y>1Qot)zI|gsKw>'abjs֑~V[+I x[Jz[Zcd{8fs m5ln'}o[x`!T>vL ~C33TI"3JF*tW2JS)Cwǹ#l>ɶvw$uj˟W|ٕ|YH4\ȫb|MҎj31Q{Ūb♽,?=㱅̔ 7%P77p$BV ,6-;hf)X`Pf`Qܦ[\&HT/_Okb9w#d0J뻣y<~ɟ7Մذ&%xuP"y4h!Lx2OCaJiR-Ɨ.]A>w^G7рǓl 9{$ߑiFڣdƩmAa+|oV(f^q3  Ҡ <֐79@čqoD|9rBL[eEOZ~}1TYk~Ngǧ/.n^L^)d@' 3575Ž5Ap(G[uy@m$F|%Uz8;ub9 " ,krί8ŮZ I1tAخq%=HacGR˵z`m;ݝ0c `-iL`*?!fZ<ř( h9`¬YK'a6?  eԝ%a3:!:r3 hFc#⠓)lm^ܱ Ybj0 [B d+냛O*>˿VcRs~>2J]HbF~G؅rɸUs9_@a~糧k#Y )K-Lbj7n?a&%cvZ-i`j 1'fGu6s<-j[1B蒗ZVh8gDFKݶR '" p6Vԧ)8f'HQI٬qd3/eZ-PRY (ܡdMK% x`n槖sR$~>^E%Ztق-I"+b]¬I\{acv7nc^V!jӂacJ( Ij&<kT<d`y/KN)R[>Kջs1#gga`pܒ^b a}8ЖΘ Ҹbq({̀%?XNf`l;շӉOC_xU0eIz=+T'(AB:MnZ<-␲Jo{v*Bߖg' g|cXf2&QL3JvjG[nrhV5Σ 5607zV;yA| 16)=} /qqNqjq2Ϗe>,a,NjOnf%זJߟ>[n"yccYTFND*5ryd@-`V3g0'3kUl/Q MƤ\x}0$[G y[QKg O#r莟24oi6/a 5%ѼlBy\@B T|'4쑽bJ$JZe]Q2 :K"*<-bCк}#0B%9 HdɈjAvË?'8̔sa Vr')CAfrV /I&  9Q[!V?yB,S;O+j AHo( ּ.b67=*q2b_xy񹠸OQuHY P]f9$jI2ެ%7h {aپa|bf֕ZpKAL^Xbg ?3HK{R} (FPBYǰ2ӾZn)^2ӗ=ckʘ(f3p9a˾7pz:5iVٕH*%-?NQXvuiԡ|W1Z 3rlϤ⺷.p uv3-(E2Ʈ4iF>Sh5Q!TwF2Hζ^vM5ʯVߡ0)狦 WF`YTkpsfOþ鲨uZ[S8О %ݣ`& vELWًoŮD,jw"0 ƠCz Q EO)"ɹPoL֣M΍2r6¶s Zʞ;|˪FԵY*Cfe~idJ1{ X$q_!q[}4ŷf(dAA꨽|;Kv`Tu%Rv (jÈ2MBoQy+DV1&ihVy<B.̊üg +s-Q!19o=7|(U)@ٻL/촚Azf̆Q[FM0ƷA5-`iTa(ǵ8 =G]X6"ఢ(_dsiQ :)H§ xb1f9D[l ]"<SQ:xcKN,@'Wԡ4Z/^'? 'O3/z+H2ڈ~g~kNSRN]3wϵYs[X$g֒OςU1_nZm+յdEHюOR`)bEeH~ M;[W_tٿ*^ cO .;l,isZF#J~ {,90%-[ժ__slL fmЙ;?b1bLeX0ҙ&(f5Iѫ gN%k:1J[Zixu9A陇 o+8Mwa?UvZV<Zڊ,g_'QpFKQY]°p#y)Ƌb/ouv Dm 9FPowxR5a| 2A{0%"ʜiO*oAXj;W"T_?>{)S]z[UQ2=)uE.͎b6MmS?SfA7yrɺgm  l؏%.MKl~)*&S*c®-C.a Ja$PphPbkU.I5w/u5k #x64wk~#k#n}YƚjƠ24ɛ*6PͧԤD&GPS] `,|ƃGg2r$7IsSnJM'* 젘g2}F4x,?gJv'wX)N`̧bD B7 V0ZbYTh]"/ :8)_op,"x@[E0Ͱdv"{~g]H&üHɲmGCw~&c93> 2sx tOzyTQG:B:{gZկ4#FmFiZ3mP/ R 4{1!@.)ZǾ/n$Ք8917TL_AA,YB`!\ "~{GydwL7 18BDh'"ueZ_i74Zbhα ˾u'dS=8Ⱦ90 OlSd3~ªzdA*P1 'I J ?I;@lC`hEB!d3>'-Fz~-R^{ScX)8/:kժ7{~_h]ŒSn$Tk=XUۻwfR_fqoU]q8d0t2,HEL>j nۥt-1jX]燅So#LJ00.K_*`EG3Llnm-J9G1$ִ$a1`z9lWq\&<]BJ$SuV[/IyܩG? a.J-j[jco$. 1ގˡLeXGL*?\a!5yZN> 5I\ >0QbY+[CIޱ+%J-T҃kBRBί, Dk i@mbY$JP!ܽ3uctMH\8V$ Pf-A@͘hC|4f28LBa "3ײ: % +vِOQC9[jYW{y}s21JwGBHۭU CGW%Տ䘩Zu&r9r@Ͷ7{DB|!+%$v0o/Ț\VntQz"@7)=c>H9V]3蚌^9tǖ ^XB5u7eu&$ WWkț'Cx9c-&3uUwzH2L,kɶK$wCB9thxb7jxm2u#a)4Y\a;UԚi tw U 7dn vzӐ5|<ֻ|ʹ0 ~MX(fgZ_LC#rFhJ^)TzHv/0n؝>Ji>@bj$xۯ5$Yi&=p޿!Ie 3뚟Bvj4 &$Zd@p*~\$gOIw0L $r4+=|WX%}" ˩X,Hlq|سa36cv int"i{LW汑^㨊^'cciKE KөɏnO)ӥ_p0DLJgwdß.ZvLVj_ա &M[gs$7>񧬸L{ˤE>ڢ6oQ1'[j.7[M"LԒ1B>ȼhRCې3C=|a 8ESۀOt.w>;ī4," GXjI$[\:Wn(ԣ|tU `ſߓO_dJcxG >O)UV&D2#/ &db ;q9Za+sMjJoeJYC߹hynO[80m{2u~.[ْAZƪu$!ES`bg S{y ;o&K~j P z5$iZզ(dDpctC\3|7|gCtMDa;Yz~E欸ZlFV0ƥ`Xw fU_k+lI( D8i.hZKk9a2—/&WEơ~/ )`$yA[|<^\S ;n+J$YWS7˱шȌ#6T6±z UU !>|[Ұ:s9q\4 @NN&&e`9(}ɏk\{A\v"wŒPCd1-*zMz 6kvRDs=&fNmϽϿޗ/ =w;e{'ۛtЛ'uR'z<}P,IT뾷#ѸդP 'm 5<_Oӎҍ"JwDghͦGr; n{zbBJgJxTG8 4\K`Ew yh=|4ZJW 2DYknfu9;a~IXc )ubFsj@}fY#˫QlLxBOp |16cs1TGk?aOx;c,kN<}u:w ]~D8d`=/x ޻/s O)/'/اH~Xx}K,Uu foh/9?3^M";[r6WqRAS+1Ioz;Jz{.ۧl~0ɧޚI}_>F}j(OoJm0Do4` Yc%%[iQ0kIY[Rƾ̺+h.- ̆OQl2Y&^F8Dzcj3@±#Q{s8N9F^WvcZϺ#t+y 0+%V6՝fh IֈXBr =:+5t#Ů+lM(BxE_A0~I`vy_e]Op1EWD\ODxn}n1vO[ ЁMC! !_S ¡}ܓ.4۫=0XCJRZ4QwvۊDۛ{4]*80+nРSiJ%A)]حYb Mbx=L!+oF#V"nIIg;iUMdԑy [Ra{)LKd)/ˉl[`uKtˉ=mƌ&swإp+vGT:ZTS^s!2+la2v:pCTao3Ћ1WHF.:H.cY?v9hJ[%:@ #IٺZS9`2nN=@K B;94t=''D5G=\e_& הl64_$] k+ۧwaClgnz_,\*VTt)w6+A~s,&Hgzueظ)eY+!JWgn@jTYmLPM]̵T&3cc4Cl fzo><#8ZnD!}j¯@rl/*?V_bu%k[ɍ kWyiصnĢچj^i)QA}О} `V-T4~h]?I&~A:nt*\ۦE<[j99j9J{<'י]i:ID c;Ig8CÏ7:Z6f[h7w x\rF->E)ŤMӗR)yJmȢWdjTvhAF! I\ ( tk3Orah4rj5I/y>xa<Nb|YN1W:1\f>|t2}fI<@=e~n4<JTi4>MT̔(,YR $"tFE.`i.{ f2 '4 X?z1䪱=<5I.#A b Tf,8=.xv@H3,14OW0B<?K"IV9Svb(y"\du䋎qoa6j)̑Z VQ2W"ʹ0@86ǬؘWIDp.jLq=+T R̐O.lś!`L=L@ Jk$ 7FI?3퉜ؔ3cc֮ag9QAP3Y}(, ?džUsKiJ#5Jx0S*4UuZ? ~~L\ D|[_5矐j[4Cp|s-ZJy]Z#Y~d[vX]u{XbDpsA9i҂DbI*?*h=kfAΐX4x*Q(/m>Uݒa*RۍpXuG׭ zKkJ©ZM3e2.#asx_h$=C18~WFHQGd0zG?uȰ 3" CF<qB0 -7lJ8r6 ,Ho8թ4%d!G3x.<2U)KHTfJFG^Ӆ㏥D'~[x!$FWC^/yAP[py#JV[%LSH-bE8V/S[Mk} Il7D39BD#OrF  ﰕqb _8͌_bE)XMG eЖhcPm&@єuY Exv7q(Jp? =(H]²Ej$£өlgvw:ECLxFc)/ĬˌsGp B`A} iA} y?p+BX0_$qw:,pB@hS7ŔtJS1:!T6LzmfsZ0Wަ , kVLl*=tW:;WG;zZEkgm?VFTAq: 3Mp43.`@v]c?(B?), wW^AG{]^'KO+L SBF% H7o 'u. w;K৊6 $_?ηY{:  O/l5&n{^("|:-\sYG@2e18=;LU3XrzJWzACMc{&*$XfZぢ XgW'׾13P3o\lzjJ}s2`)(EM0:2)Jh)̴ VfJpz|[2A)LAp2mX|zA ڈz=~#?a߳K)KH*.)%VkJ~ZT֣wwʨ&w f@z4phqRlV[=z۾"<58i^< °i$%zӣq>#w7I}tq۷2:|l0# |'膅,q~3!d^lz I\ ('6Y2GЫijc&}pAgoÆz` TrX.a[AkCbAX]mO8^bJ 7;*F8Z}9S 7yC80A+6x.Ca)o!GCPjJFG0w @ [p>_#f}lZTxܤU<:Yl (HjCBOc3h}7)~&Q8=`Hx e.(w5acY=A[lov]c)c mfxťQTjSǼhs&%WaXX, P1 4{/Uӛdăh'?L6`/݋y/ _9PCfeli&]+\(p=;vYz~,Z֫VYO?\ /mz"I|謢QZK>ziTa69^'s2e3ȼF޳f75M+ O}}1Y^f:ݎ! Obi'A+ʤ,rE?@|}2(F7礮Ȅ!Góq2xlwʴ\|l gshjMP/V D@RY6fef*a̚$z `cCGgό_L3L=H]}p7+bjhLT XѦ"`nG)Pa5#a J+Uj <ƶrLBxFD]OGkGw+е-Oɾ41*H%m2R7<q|.R=\PX1ζ#1s(l5f M bn+A|ZuCzڠ>ЧI#ۖYsMU 1c)љozI16+nAD4Gͪ-bf6y؉vmy`(1NWPИdf" T7YI :*!ɸ1oI9>-fC}kS | |78\bns} Ips8lʋ qVgS+*e#dsr$z/;9bx9z}X';{zgjD\WIc4H2Yi.r3&KAс{dm3e/ T ud]E%{;E7@|ǧG1 YuI TfռA"PY ӺVє"K8^8i|cJ 2Zda ٮn.ZL@]"%8 iM~u'.A!Ja(&gV2iFrLF@M돦"Ӊ(k ;^L"vӹO ONObAL}^jɬG)(K~P1$pǨpnsjQ/b<3\7#@4)̂&BT2֒$gBP6kc S Sa^rLtp?E OD%X4Zˣ8Ni2(|r/3a좜ׂWn^#&i&^_1:"V xs!2HXTᱡRcG}mLN"c\;[ŭ)gxjQcڥh xULf[!t%T%8=7s͌Z 2P. w61p[C93fkouu=3y|DԔQ 2QgXe]Dz΋9ۜuh.Ej.5GRTRXuJ VXQ~r)juugmE&j731qqz0SRnMִʆT]MW C*3;*0TUd)fjYȉd%ifPDSkmb+Uq ό&^u"\/&Fa}h^[Ȼ@[z@VQV8gNB1Ka5FIL?Y0a4L r>2J$ծ st&f‚0XCl{l2Ї{aor sOjgX77G-^, 1fmRqBq:m;夒,֥3bJ$Bi4_{'p4G]mne(&TWUP_qz=\ HŎ<|KSЭ@rk2.69C{mt+Hr}PVjx -WhTR@\$k4Qlvdp™. */޽8^aJ_US6Iqaj_YSWƶ-)]ɶ@ o1-9{FlD'ߵaݸB6'7bK6((BЕgd'"&+4ghh;v(L"x)3vȰ2w\va)49So=&颃Ϋ!K:WozUu͠#۸$0l%ZKfͿnAZ7S{?>v{<hq_ N_WɈ2OSʕ =NQ;쉂c?Q4cMv"odW{#W;aơI9+dRo"6P|Wr"<9՟(= n;L1髽C Hq}@|u@1;#_od֮Cޡ6mzߢX (L`L."|(>L\#_`oۚP+zEP.HE\_sJRtc'%PNg Jxiδ2^=FH<Д8X],P|q&%QP޿b\ɻof\h{ f[q%bJ1|aF Y 8phԊǍA*$%Wd*ʈSlM3[ B0) a>$pDcػ(])ΨܮmRv {U|afl[NNT.'x[+:2ߒܿ:ae֋-g2=-4~ʅ-身WUpݲ-$پyʕfN;AcDؖ(+ݒ+WqmobM\ZKTkG<Ƌ2&/Y"JuX.rKex頁s:oRW.$*R*xw]4P<ɠ/9)_@GPdij2O97& '9`l&E ^U*/P`̍˦U43f_Vi( 9F,B|Lª)&W$tѼ}/C S7S-> }~&FHF _6^9)h-OK1l!Wzy8υʐtܩΛ0(&iiQ(|=Ýg3\?z.C]Bեo&2(`[mڅOUb!RZbR񎤳1cÿpB롉ezMV9)c$lHHc 3u_iE/ε5*@m-~nº&!65feB9YFı617UwM F yTT`YNRB̒[u+u^\RNTw۬Vskm^#;OV2 ] -q\E v{.1} Y1qke631yQ䴩6$|\"zS[_<4EWCpgAd8hQ)4ʺ+s}cSnz| ]8rިS_챭ss@E@1qUKE~ x͝RW?KO]Ȑ [@YK,VUfMf9ۂ '}~]"mxW?aWuUYwU6Yx,g][[uyU4yt" {/IɫɬhL.g]9˫v,>tEՖubQ7]-dszC/zv/ 7Eg@|IXNvT܍?f'̖fZ{;^[y]z-FrwySdŸ-FxpߖE+MϺ0]V8<3h ?iM_ώF_no󊨚拟k;kmB+Ywvv{m=@;M9ϛExs~~"7+\E",f>4|\?ĿvKwEѼ MQlv|'z%.I݇ d@j ~7F8{>Mh!Keѳ 'S?/lO&M_wvD`*t{fkՋz^β Y!~Dfm^lW%Nq%?n=M C >-oOu!kXTz֕]i:'ےRm7jV~yWv]v7˫l\Ϸ4-P=61_l.Ln.Njﯞ"UZS3C֞?AySUĺDZWr=zb 1_b΋wZ)w7&Y-MhLM2hᾱF6a}ښQW{1zU.r\h|[6I%Ӌߴ^Ɣ[ٗب+&Y a^䨶…γYehKx3jlfmy]X" f2-8_!oD D$.ȞI{'+ɉ@C0L T@)CClֶMZLMMѮ 5}?ƴSeIM= \ጀ`ʖ%$ JQE["3V8mԤW0n \꧞Y!(-HS!*&e_`Vgd9+FQLLV6ܕ5+ݣ񛼙jb!e$XUE@r.HTuMVLIvT#K=wi\-05Cs}Ϣ3q~.Ϩ/=#~ q77]j^h叛 " -˪ݒvZUQm&H>Ȇ-V՝!A@ݓAk_lܔnC޹!#K:,oyV)Zc<*yhLqWe5YgK-3BcsWWSVE[U )fИhq"Q/]h0$0ؔJ>ͧEw/7cs&n2)sxy]]+s| ťKcv.7ER%[&.CJGIגYA$V5"h?ypm9.~C9_`?_(1x"#>YWՍ]Y8-y,y)3viS&'ܒ_FDx[5<.Kbq%.L۾ .s\ +QPڅQ'dY.;d+xhdDHYHIqvU-YjX]ѓ;;&-b5R܇٪d鉦%܀xӲ1C|4Pvd!؉Hw}˲0U!fv֋BKOH.qELM~[,Fх{CfAޖs~(Mt7l6zs;lBli Jk\3m=Vȉ㛚v]^fo;!ŤA$4/۹2_UYU]\=y0x* N Ral_.Uo}oV>o }0QPQ0 .ylfSuLGBI10Bu,.9Eǝ;m{v{z~ȼ`C"Pz^8q0 ?6VmZa}@Y}\Wm9د,WqLLTM> A j9WI &N*!N-4^QlEedoG"vM6QjՊ(3..V@;$pf'#P9Ma %By7Şx7H<],  4ūyN_ |?H0sB1qJ9[J Ƶ&?#b30t#2ld%0):8]bk:|]\{NhlX$^De./r cN?V;1CDY؋vLR tMQ(ngϷ|c`v.Q>/XN)M1sutolYuS.-n}v{'?ۉ| O-!Ϸc߿<>Bkʔ;~]J8%'q2;&ErUԅ<,Cm8׶1bY(E#iGU s+9ĝm®%I%>l]͝(^{}D^8^nOI=yw!hn77Չ0 hwu=HbPMZvl@^CmQ߹q /S"3q0RfO$vz!QAdOl@XAXz{ ""<)[ "Tڃ2fo+^2#6DӲrDa*OX'^B/)lz b{/)&m hQXoY~#?cWH.6qYI.^H@cF؂)c O#LQq00ldbb%,[hXRVNkƔKK[.jL l,G^2SU1HIІ(R6شH(J E-y^)¬_K^/[I(UJÑč6tݓIc盕:yy7DUDT( tKØb Q!| %/2KǵcyB$MV,}13bVU bXz/zhȆj(~F2/ Bwz5tLj1֣wë4Sͥth>BȂ PI[bо'SRG&]T٭,[f im+Uxϵ!NעNio[ci/iZrR4GeK`8.6'ʋn=a37QmFicH֬7Wy(Ơm/ߕ"@n%*Ѐ6)`! C5cݓuSKˮ޼LVvWf -̔jX?hEɴ_INxrZRPIl -xA`zLj7dewIL_IܱN5fJ aJ889|XĄl*A$QzWhkKd(8R$9M*--o&&v<QSCǼ#5ىP+ϱΡ1N<(=1V獗5XPy1ÝNԋ9e/9"X%[@ <ֳ /m} pP1A'v|(4a5ј-O5+&qU+ w{ %! y0Z4 dj<[R-8SAa%S/PG:0v6dwմɪq*H?أKU$Y #^lz_"__6]>{wq%q=}O㚪rfE$xES4$qR?ݻ??@g["4k1ΪEҊr #X+eAXw© oXiSX'W.#(^R Ǻ dåa, B=ɡ\(:s=ٮ׶ yɺOSPa˧Ozzv!,y1o?}bbиFvHq)ۡ5 JYlnjىMj`x)[ L7UB"~W\Jlz2?׋cqq&b]F2a?T:>qtGRp=04V:~Lf%BrS]V#mz,`AekT/x+75&y)DM ӒUKe`4_g_|l[v]Vs_8ZR-ͣKn'C`R_֞1!y^}2Wk/H["72+.9lo EiUmO=d+$..ϼ E@g}BQQ'+^T /b?VNpOL7ͺ4+J7>Vq/tYx4 F 6'*a@_"4ܙQk1PLUL}BE4Uq72aH*a|qiA I%t'#94znl/a,ۚj ^in8BI8 D7Br%44ŨDl$ GkZ%IN*27$@Ds`O& s:f"G@uZ(-|D2٩h/;,%iAcTclM}A8ˈL8(1F=6>"ZC*ʂ?NzJ+b$^]T%gDl2xFݗ/RZnNZޒd5zg!nm5|R/:܇[FXM\٪ k3`o}ɼDzZ~7h /vi%րLV~$6Nz blBĝ7  Yy⫈# PbA+`y {E: !W:l >ǗHs*P[AFs(9ߏA0k:J1e>e=Yv4qdǨ6F#a6AB C<eO3qkdf4(\M-`@k=e\܁$5|4*'j <&iř48CАX[Jre0\T hhbﬡ&57Cn,jZJZ9?}"9UތoaM7m7c&Ѡc [T'#OInHOH=p;R&-Rf<ϟxGq Z.6AiTt);מ0c>ѪR6|522V i EWEL ѫÓB})2pMqIZp}|x(i%i(ߘ TQTEbW F¿rXJ9n]dR!IiC4vdؑpQD΁Vt  5>A4`/Ӕ!LP"*a:{^u{Xp*r$Մ=>/wRvZsHH MIiʄ<ےh[ Aə5O)(o]ڌiێ%|}Eߜ]+?^v=(7HZy=OlQ߬V@?t:\X\W4x"kKYJL1P=! 1g]RDyH}>Hhi*.5ن"CRk$[T[-!5)K2bk!/NT$7ń "_&KhTHfxFYf\NHAjΝlWz#\]O>YL,:Qc gdOL=X.ˢ1U1Xx#kxK‚ˑ2F,[?dg-g؆8(PQLUu=8i*<"Z c̹"%̈dMzZOp*vۅ 5+]Y\abMh5zU8YOZk*~Z*mY9B'\uZ? N=Vj𸚫Qkފ:ƪXZK@+_щ9 8mi3@)p ,XK˻0b->\\7up-m:ǣ_rbmUq#8T8#0u"Pƥ>[VjBG6B FRvgĘ$dsxȗ,*b+x@LbrR1iETewqI}"0$ΊJHYXJqRmŧ>Ht5.5`WǦٳG'Fe^_>(7\;?sg>zg?|oG8 +걡~C6Iߥ,U >M1D,!"DPcĐ1><îPAO)U!bf $a#Ȩ'j=GВLW<|/%oiPKyC"ZfMZWTćG6S{hӂ:Do_Jg8C cy>K4H[9i(3f9 -Ntd7DO3SEv{V|#=cMw sװMjS G,͓+.-IϏQ[Gh,s%}>:cf\anZYQɢhiUE$ӈ 1+o>Cg@!r*VLz i=&Q䓹zJ?҂WG79b#>OlhX_5u<9.2q2e10루Pq& H inа#fg#8Iau3`I Wk P05(D ~ vH\8k^hhF[Ey!6kyFN^1!.sI~OQBi(`B9J#ҩa1L9eRWc՗36V{,drڙ$j>zYi!耒.{eOI_DamnoHh2Y_`Ȱ!oB$)%TI'22oe-5ƙiN,G$Q&2ש9"ѴL5niBKM90M d-]LLQ4R)mGN_"C:)]je !}G4ΎdPaP!ԟb{D^ .cȄpJkNDsqZ%)a;Lbbb4^-+r'NWno3wTܯ?%{٢;Y(L5]&3Cc8rope. 'n*@)PH$ksn*iGD+~H,?1!13HnE&PcKu-fC;T")I.4#ͮ>(`<1XzQ>(}j>PsT >R&x/{;=L)I{CCE'۔mH<^Wĸ0d+kxgpA쉁>-`ਾc6*/dq현nNoع8'`?^۱e ^>1gی I`sH ZPXJ7I߄L+_A=y[]=b@־1Dw՛_w`a ~B6oo~Xx;pWdSeeOol(A2^vq7V0Zgvd{0: =Kx~lZ=?lA}XҤby_rg7#~f?YRXLZ0%Gm5+I0YԊԤ@WU2SjB,5f.נil+ʝj%Ǯwe`ka'󚖗䷅D)刁jQiuU\eCq Wtt*AjG {woe,ՖCG*k1?:>ez:eԵNp57zB=  oXqdž+uka-vjF}1wTUBH9+d鴯pOz|]3;yM#%׆q2-9 D 2%@}ҢW8VZ}L-ɨKDzB!k_/~V{?$BKgZi9m 1Uji)q&OO=7ʘRXvMI"b_^+dRPJ>:OI&#%J_C9Ɔ%$7x8bi A~u~Xzuqi?K{1Z\h5IS0wX5 ;E  pmy씞pǼ7!5f=;a̭IKS-kq7[VP_#Ǎ'PxwūM?0J/A'L I.l }NSѓL$KO(Bz'JWZHq1p9>bİyP1ayFu9F4[U+'I4o<0:|qY=W_3mM6y#iCjc>:/gUz !hmtKw(s,4,|- >&j-d86fw 1wdBL6;MsI i`G$76Apd[*IҚʱp am* (xꌚGAd'1џjvHXK*[j1Q+rbL@k)p_2:~mV1#8LOGl#sJ`pj<ˮr]k1ɳR8m'1&aO5Hi[)؅$"!oa(l[)(@XKš0pFfċ `1*YVnrnjjzm2dTHkM7{i =nĉR Ʉ8 A(UIC(#Fɴ}6 QEbW.s3`Q|ągx&g4d@@t,J̈?f0Hi\YoJ ybo'?KIFRq m;уF.h@)|_Zn"xlST4xZr۸m?3J.ݝQNDIM,Vv IX -+N:}}~瀤(;v˶Hsw@g2<3%u\\67Ф:|Uih"8Ҁ6<3r $|677<63t>/&$} Mu41~&㥌e*]?#nfMn6lonbH#SОbs'sǦ06D&9)fs1e{PdSm^uS[)tM"U.3SNJnnmN4C+KmvsCf쒕{jѢχ^D -GIsi"{"zfI#hOc|L|#MZͲPKoX6aDf/^A \mb'G^V!qCR1ٻf s'|KkXǼX2[g!Ex .yHjjŭ#2i\XENL,MHh/[<aҙbf֪Oi"˸~eWE_Ђ[?#C1H悬z:7LJCpS1! F`s?%?5'$7azmLi RMB;[;THŦߔL>ȥN]pDqxoO 2SPʆ)3*CLXYUX6iw"H]G0atp_s%a#xˑFTDEC Sh,U>,UQ'i{ 半)p#L`J9-~Q~ >sQW>;E6o7c[XnA\b4LY0iD8LUUD!Nޖo '1=pi{z "i%ߑh;!{ӅQQx|(x|Av#EYmt?-E#[λaP|}շۗ cv߾k8 }'L(EC@I|Zvv2L x|eDoFӎ=n3Q PgPNNWlʶ(U0ǡN E*׉a{[9oGCq;$jJSnBL,ɧu,e}j3"fI'Vr*' 1Y)Էazy r])o9gf,?su*vL;Q=4YX8 QdHd<zPو-P)ϢGAH\C{*g9#s;F.]tL+Po蕊\b1O[W_Ҏ#iZm}}>}*4|x&f"6v>w5]͕`Ziݽ L ˈD˼)qpR fʛad˭W<آJlCN$@6AjM}_qCJp@StQtIR6Q%$(Z7ϐp?teGN,LG1 ?wPm QvxwWԁuӐSS{JXPDŽbOC"*Y.*v2tK?2(+[H(bSn4/K !?YV H:0S^ X NAzC"lkqQN5lOt`[mSzR0!4>>Ff#r!&*_ T GЯnq2e35!XiX53Q?š,.B#*mw`IR lX`~a#ɽ ',|A*0¨Qe`iʯ֗iʐe'wӥIpG "S 𩲍Hl\VR'BN6$J j܀8V(d=O!yz d$`Aa?q7~t8Ł0NV|! ))bi1(X-r $ԦZ 'd9`j@UkPݠD]W|Cs2I W9ǐt],z$L+[VErFv&f;GSG܂^Z45̿y[6P bA|9o:nG|gŽ`3YG9A_!m7> +i+)xWD^v5>)X/|#fC\9E'̃''1*&&N&kp}֗h#Ep֫VGgyFv-vKvHwHFPqke#Z,%!Ei\ݴ-yn|g{u'\_gZ[aИ5@0'K"RhIgP4XLޔχG=uvNd\np!b=FQ*K䌎@|U gT ;"h NT .xj9]yi$ڎz}*,KVx*iͪz6Vx;PP^" ʟ@u{6\r"saM&f87 #OL7x:L 9s&m^t gKx"2o ; 0Wx@PP\|k^s(Fyp}%*T{%qbr"b$E2nxr ?T7'}9c3n!x6 ܛ&3x;PPꙂr:?$%6TcO4Dw8X(8"jOg'x{dJkC(Vxq2 ?T7',[]~x03`H}J9ǖ[YSIUx;tiKJmK4iWz ODx)u'o9B*hxq \ո,&x 녤VL6t<ǹZQ ~9x;PP°[1O r`3)1@0^vr8YsU8"Jj^x{d(5Ay=4 Qxq" &\wNPvaLS,,h=ڄɫx892RSR'Q`LbթNTQIEURVHL/-Q,)NISRHT(,M-.S(,ɀKT,0yj<{6?7˖ٚ3}xfPOaL|9e]тAZTvv100644 call_test.go9[5$I gэm100644 caller.go/R8%8<[ Ԑ|66htؤ~L|zQA_Dr 100644 go.sumHCuWb)w9K:cMQޑbuZg81>dfמ4}ULD:$L(GR)pi})!h>"ov QHrl|- o#J g+<70E/|KwυɇNsb:͗!{:<K`0'# .#$U5(xOOU<{ju}#:x:f100644 call_test.goo&c,xi~W ]Xd{&P?yTO'6&W |"kVmN100644 go.sum;\߀Xd,2):0qbffJ/6/% |75:`(a8XfU£Ku@A/EYn/y"^#5vNxUOOE|pdO;b2, ŶW5b~Es^֌o,h98;Vȳ* k& Gx[t l2y) % % )y  LcӓWHI,(NU+WKUH*қ͈dg3ɬrR ii !! RR@BmٍEJz 9@J2K&M.>:Ûis+R*57;X{m^Xɾ׳y"3->CxM=JAY/Vaͅ7@bS:tU`70P<fM6*^}U^M'inSɬSnH.HRS> gOb rf\0qk  {B3g(i$f(J,q ֲTFl]7X4' -&/'6Frr]I,z;j|~5?l"hmx/.,a)}+ .!d SfC]c}x 6MʱyBki x\nF~rct;mIAp,'֎mAPj5m6ɐl+$Kl-ev &rԩs4_}e.ޞW}|ؼIW͏'}JѺ3\LܲDv}.`J]L.A(YBeu KM鬱/6҆A Sd+f=A[@ǎ7`a_3S3o`%+ v,% ~w< E-rC'%q5}}V|ٛ4gS0Zq3?5IE5LGGM`D(S3LDc`42`gۚW鮣%[I(k \'Y9l:ݳ!]/`̐&̼!+!^ .dr;GmUp`{am.v|czGpN-']Y3o78QbU ΰN| As;]Ӭ X`7farq!;M':=LR7m]Iݖe[Ux>J+KT[;VdiƽQ&KrlɏV϶X!#SjΉG `+*Wˬό'Ϟ!!HאdImV _'$?HG0/lr{u?s&,PɄWgCC8EK" |j_3NCΌ;ɠm( ?IFc| 벷Ghb;G,θ&aT}g'Z#UG?%ub=_ZϞ(֑ dʉ@C;UZ 7,Uȸ#7i.#r^,p]zR IJ S e|KL ڏ1mc(" F#tge]ǶD3='ߌ)ݕv95 g 68}q6WABGr䗳-CǦ6#)NUǎB]s]%vowz[Ǚ !}LA3AuN]:Un>Eo><3{3( w yŝxB؂4jǥ2 (HW+x@FyѰ 0t952cZ_xv4Ig,v/Q㏃H\|nA5ӄ@u@KӼ6m|B?5a|"N$ ` pvţb.l/f}PWԁw0b܃Bpq3饍p F7y3hIZيsxqc3$'/ofW ӂ2~9:qAK؊!d'^Q69A @MQRbׄV^æcџ1$Z@^1,_57lH*BdB bF{' 0]&5Q.78 Eؒ9׽rhe{YV w4]J/)3A[$NM?p\eB{6)r0vǙI!aG9pj~9W޼2+ e&߈_[.DZ2LUI=RI7 HGWr*YnDUF7A¶ :8 hc["b"0~DkShyV>?MLx]o6K`]r#RʄmKS I4fpS " W$/)3YçLv$es:4Yh-r9ktu"!ˆXej l bua d4sP9Z̢< +g58yFL QݹI̩ofwTpo+)]>숟;"4.W踇` )u&fsl 3NC즅j4(݉n5'i#?n ﲒcEBC2 +q_ >3+ a0O^NH{C3۪~p~'THy)+qyw8T e[*zvD\f)r&ATƒ ?-~dz[" ]o+a0 Z7)|Sڝ̡AU7ECyFb<aaCp$ӧFN bkk.CO鈘ܱt2h%G7|gt3>Q~.f{Ǚx|$;$BB޻|bld.+s_|yheŕ6 %l-=5%fF.6obnQF֌g|aDj(S'1qVu0D'RaE 4 l?M .Q9/@]C˿.g_TtO1\h"NJ1'"H(OafMI&8%=3|l ה nz,5 '9 >> =m߼=df+}2FK6M>&ʼnѴN%A2&4-[HTE%;qsh90]Oeyg>5_Dfͮ4֤tԨ$#ƛb6 A{{ A~?xEJ]?.Ǐa- I .Kb^/br'H@$v=W㠻 o9t(ܐWl%[.y\ hJԂ+OuIJ7l$cYdW\wt3S2`Wx30\s{9F= 9ޥ=Д@5 UFdyq=}\qH KM99x]WAn?hWtώz}9N, ܓʋ0]萰yD3G\1SUNO. evEg Dc) /V.Dn6qbfU%nP. c'~[I݄Q9]АjS{ bG˲NϾp30զ.t b=X=J ݮtķ_;-3w 9:{ma)5j(y*& 72yoɾe|%?8U.q6=smKrHD}[B-O;{"8MLϛ@2nzǫۋ~ܼ^ev! 9yEb>?X7>oґ5M4Cԅ<ҿ?F^T&CT}s ԄM*9'} 썖GSKܨ\!;ĺ"ZY,ޑW4 /9p>ҮJh]ͦ^^V-]:Tq.-G&K\}ҫz/DU&o8ς|}f(Ä/E~az\ HU#y*C7U3$6(LhjX!པ1S>7^i5'H0=: 'J7v>!K-O8K!~xVێG}eMF<H(e؞a{YX|INux,+Hx}˩SU[fSnZMƣMaKmxk2,8^\ n8O]g=We|@*  ^)2]B9qOy%bB7Q΅<ӯ/_QZx/wY?M&w;-A(d Z6\t:\I)C"3 L5lIx9SsosSٚ߳+gy9n1e'lT}  y|=ͤ@kmڧtq͆JQkZ47^wG|8"gQ['ץl$_-smIw4(yoFoJxOɡR)CL-x[mrGMYkLoPlq$^p @ i13eNeVu7@JYxY(ltmμKdUem;(jwW$[T]|^$M|{E>'^f6ݯzFˢm76]mU/(y2s͗X:{MSS6so/S)Eugjk2+oUTr槓o/H*Mkly"4+r^. SEN瑒2qC\)v՘$=|sb'jEɷzMQ͒B |^%Xػ-ɉ&^%Hpł*,7qy 2*p0G q/I3 ^i1ɕyr|5GjS\5vL9EDZ13쎻$GM٫0GP$DEtB=uD;0bSwp$F\ӥ|hB˫Pݮ" lf29n*Fr #D[nO@jckqR­a%5~+=*^e0n+V'N}vG.I<̠)?mtٻnm&h@I :AC$@uRmTOs^C0>ʉޏavWIۘ7))q|OY%1E`i^ :mjx-MY/e:#[ڈTrpjd}w}'.L߱2_i@B詋A47Zóxg )DK?uiwA[, mP2 BbiCPPS΁D&VZ)qU0W 48s s,x SZFM bb`39b2+[^! jCL"JB7b0LUCi<%4bHfk$V'7PҊAN1=x+(k,)t9v ՗DH,IeT65Q#=P[1(0`0w8(]'xiUl 'RmfkXYife~ ]=E D] ݶ`$MT;8OwwȪ1AdSam2-B8*/$s`QLˋ7F4wqC_ƁpCcvw Mc eL*WDG‡dHh阞& }h3DƇHD[=c*T[5aQ {9$3Iq$/WMM3Ri8~ϼ7^‰j^HO_`Fg))6Q 0Ŷ֒Q1G]FGm21YAy3*.\;WT#o-L`6rt{fۄq7P\&xR!N3%@b6"U?jzMUA[89Wv$nlP$I6*U >z'Y[{b}Ija[>v6 piN]ļLҘ$<<7Cz'ղIib`Ut"֣oaj4RKS ~?C/M|O̶%r1 ֓K'2kQǐI/jf7!7⧞$eyXJJ̚Y 5MRy{萮8I*K!+s! c 92  ז{"y`$8>dէsp<+*0N˦"eOZ| I{^Prh'0)'=@!XN| +):*2n/Ӽzhkx~ݫh 5(ⵃ^ CSX4d}IrTXG!g\W Mk`j8`(+ ;P;0X:(tlu^&4fb\nuqI&~} /ugbS%㍋FDIw6"i’˦s'P|aL'8jo m:ŧ%:r5X\W ]AVRNU.wW3Z!iɖ׸o_6c3'f6Bm Ͻrɱ[ziGWmmH>- c`./FӆJ1sh/?1FY5*ϔȫ2 3g={8D񝿧H5E?fwyKKA?Y~ڭNpt4UtS[rhnrsbU0B\bY  4ϥ]*JV!}eJ2.+z :Uiz[n[%&ElXXic#¤OjJ=U5EA5q%yX$ :p@ݠ4xlPR^`L+j;O+ru-)K~!B!XԜflOɰdʕHL^ŅΕw# ME,LJ~ ּdwN|Qʎ Be&(N Y=)NWJM7|#TN|ޅܗ4uȺEuۑDXw뫞uxG$Iý9a~+ ik2.#)5vFr Pzn0|Ţ7]gA}&~/_1? ljoӰl 61}E@Lj;l[Hl/0L[kɍ0 Z}}P1CcCp=U@^IQle}͇R>V/i翅v7->Gp1Hq7i$Sn:5asj"Sv=caca{!X[V<_&]`#^eyZKz 'IwY$]E-2Se/ɇtVoTũ}-.NJD}D:f_R!释02H&>P&>H FzD"KbYBL}*ҚEH)aj;0_!_xr}FU0A~IM u[nXC'c᣽GQ3kHAae1-%.NV}j$Tԅ;킺j=4܎ҿ7r ٱ(Kl$?\HT Gf8ᑏ1$'XS6MFyqvî$PcUUCԔ5a++G],/PGi«^ZU2OF ÞcDq_?y{:$T^% #spa>@9fߴBBkϮ.eˣn_T~zyrPyQ%4DP͇j. 7h å UvCs<}vbB_\eYRAnܕ޳L Sv:cm&Q!DNltY-1ޔP3ttHndfj|RB[%q[¶3(g)ߖv{/]dz. BQs-s\3Zėwፏi0~ei=<>N}G;8ިW e+1;j ƒQ?mBʤy1zs*{0"@ ޟ4}lΙ 쟈a}7a J`,4Eع^4bER֧=@n&GwZ$Ls?%@3O6•a[Mĥ^Ѻn΋Eaę@k|beFʐOkz|x?AX zCET۳ሯiR9\czRW{ܿJC,ԉ{Kc' QeR %+4 \d)`ή&Kn)2:+uu hku#_ ]ZQ/;2䠧2[WjmzsZU$ |lzy~ Sj_tҵϹWvV.X(UMI7Y=|J̥o| ҧ+ړ1:B3"N[ed_-&Oٷ,dЭ:H.z5)8/$VPJzx9tQܡu|5I X"},(U-!.A-*ܛSe*z^am)W> W(ԫCAHwL:TѤ(B7H/?*üZId|S܁ j5BuwT^BR=w4aɿk:|Ф[At\?xa&HR?WC2~a2s(1#* N^پMz|)?*8m>7Կ~?(`)x[msȑ,Y\!m 7|FZTl$9{u-yHƋ(t?~a~==Eiݻ KO>uQO9+SV^2ϳRV0/,(裱Q'v:$V(OӤՓ0棟uY(ck \WE@ʪ&gM[R:գ ]VC^n2 zH͌yjBcUĪ&:7r̕Zc SYZIUY5F}٢TITMtrM2>*h5ɲ**2S%QVfv\Q$֕T'bVgonju:zVOXA4~A)JU3wDIiKLד .f?<;!w%/KLEV,txlV)mA[X>oV82)G(I1V$rM{!D,Cubt43J86r2I4k1 `avUh[Ɂ$őy0o9q*S a+sAB @"d/BuXyNBQHb,q[m3űG1$S/{\F AJ=v>!< -$:q*|mAo,xGo͢O_d"~znƊPC$JUMmnd8+~0|:I#2$Qu=BRz9\`PȲSSN.p 3иudT8#gZ{7*gm'ҁ:6</3]Щ!If7{t9T|R=a2m'~>B9 d9s~p%iі)ߓ>WYBj I@UDE _]rQC>wSWLȃYbt?)/ 4-T!=$ SγꆖnyY]!9NSLC]xFGl-ɗ VFlKl]w' & ҏ8:Be R;A(1<NJJJ1(|+^mP)RO3Bt %w~FA$ڞI~P#$z:u36ީY  ֣<֌=tDYXKubl]bTgJȥ8@-,',2Egr=h-F,ԓǀWr 3B>`T.61`lY6RmN4.[X@w w)K1 X?r^::?x*9;5TY'+skv ǥ*sU8ЛNdmu4a/-N,c<%pxeuaSO wx6K4vB{/h賏>}JZ&NܡG2]Y*s0yq o<8c,oଈb/̂'9N8󊜐&c=uΘtU>C2)̛B9IV"a_g=0*Ͳ\b]s/gGuij _$V vP_4v,8q ކ]7P0|8XV ,hJee x ̤do*YKklH]?_ w,`SMm]9G y_s:HY%(/8cUy hs,CF f\B* FqO cffE2ݳ7RV+̳ʩlcR (ͿZCj$W5PYHf;2b6і 83R"FON}Do&M2'|n+(Kwu E6p*<VBbw湅_¤%OygK&*N`0Q2mvsbZkyvןX]^I$~ ],$\*K'@ bpY.kaL"Owi566C?C=@/C6q Ѯ> $|p"* ':>YX3 (i54˥eE (!;id<3*6iatmSS5|8C*:pܞ̍XU^Z_AN˱U3b@G*bҁ GN] w |?_xj7eq?8>:= n傓({Kƽ4D_8|`xuNUf.Opb3o^X˰ tjĚ>f  J֩0}´--qyR|Ӵ?A|7˺ԅ$( (RL*,X ߻WW+fdˮ%_؎E!(HHxḺʜW'5B͝f^z[iAK{ {)S6PtX4R(Av6vO;ΑINVt؃`Z0TF1}}VY|^z\̠?ARڒgBq/T/rhY/;F60y=DvziU&je]&]-` "sėI8BTʋ,DH)=X]cdu6+j {ZywrH]id-Hr؄!,`l-G,ݍ˛u틫Õ1P3΂?ʤ(ksdnO Ƣ#JRv Urȍjr6 Pɍ~ E6m{STqCH׹D<6NSΆJEcvѭl SSp;*bp~y Ko,爌\ؠڕ;J&!7|fP%wY7]!ZqɽbvǹMmɕ#jHH N/W'ޞ98?D'BLIs˼BN3JPDq&AftIGcؤJ6K(83smˉnt1tETd9 Q7U4uY.j)=jf)k,˥ފĕ:Ljwu62+ˁN!kR]z'S܅ T k'¡Uz|:՗,naee{]7VSkZեO_JXY$[D]+oP2a:rw5 )/E㌾x}rVS rDF$egzf]-'I$$"%D$@e9k`kalds/.HvŹ?.6Nwb{;/:[m4,*r\y:oKEYŞ̳ɣe'EZQ\ @Lv]& A ⓩz^σ)h4#'΋˛JyQThj#@Q"JG-bK݋fɻLjV$xr>=kLWc7iEAD\kp FrFbbnē]*T粴{ \r%e*m!nz$`UUf4q'5.&2L8M  ղBn@J&ci6 BD' V9hӌ6/D wX^.jVms`a帎~ޒw @MQ*0Y' 3C8)pN M,/Pqwu g{?Cݗکio|U)Sq:ѤײhdJ(֏@op:acW4~VE"ǿn;UӷGϿ "B|x:[ TPN}P0i"e n×8k6l'N՞gAMhِG/b? `7~7ńJʴM@XEP"dc<Jc0GDN<JHp6וL ,./`z(=HH%)yP>l?~6fR(N%JIt)@I6X ?$_iFač: j+7Y:vq)t/a) (MtyF\\>l7{ zccj%- !,mIcSe;ЍS&cQ1Q5$:gI=+e/T$@2d,9&w+6DUi殬=4h8!j0 ̡h.X@x a5/J3b=USm@ӦZ`V(y"SɄ],ğl,9;r7+UFҸۣd'#!&0:ɳw l"׳cJ6Hvo#<| ۧF\ 6FtRQ%VBy*dCd!;N#DqQrXΎD Ʀ4D`{8_cٔrIW8kL38+k?cN\TCL6%igevY1?~"y*ذRR-+5c@?"Q&iunȕsuKU+XXhxl\L.je6]rOgBb9S^̛#+'u;Y_ (r9]OӤ"ȶ-8sh@e\ d@G9my@rF-Vi8f CġΐZ⺽ELjt8cv.$ܹBd ^~wx~(_ gC 9|t#E1Vc6@wrgRE#~J&Dl&B;|FP=>XWSԉ믑NpWUth \&8iot7=U#VM F 8_j -b (~UL,nitуj-OEp?ѕqҕ&.A`a/`HG_r~}pdbX;#EN0Da&NC\B4}}*4FۗZ0QϭK>qfӜ6bSek;qx(v{^Q L)T#7i݉EydN3pt&Frۢ_HJ,yr堣PtJ%O8$XA[v41c^E!Ww9A;r$ҷiQD:Q?i4+[|^.fgMzM z8* L܅#Dkͥmݜ7Q.Y0|P ̎V_/b68Eօd4{7"(tuS1QS365;4fHok`Qr . 'S3!RQS]^}MciA$&–bbӚgE]iu7R+i>VI΄r$'j[M0ؠf!;XAEiƄm.1At9]n~+DK6BoBe[{"jL zY,+ZI5D%Z7Oĕ0#`7ӥ1E1qyqI('KTx4w>7ok V"q3z )N.9s 4.2CMhUwj.Ȋˬn/u/a@:b4Yk<|K3XE6ǣm3Δ)&͹2yxSlAtnZ.@!p'OY CG@d "uVEXBߍR ,1FҺ. xX :dAk .q!GN'J=DN (QDBnM .BكEj911b%jIl4`Hpb5q#InֵITn -P'[b9v EΓ}܋Dƨu6]~{gBC?>˪Ut*^6LT*?)*S R (N䯵AJu|ݼvͲ۔Հ$@c}hb)&+օ ;uw9͘E&eQ1/?V鸯f ZG~_)E]U~R1.>^n˚^&ѻ'=+L`UXk {R=Qo= .Mx ݖЋ!'G}@`{6*$"Q.brpa_ V‚m*^ l:W@~@Gnlejy,ij[̖e2K;lFÔ_wAXxȐ*OeNs0ncG^I;+*ޜe\O黬YQɮ*E_L[ݽTW-[f.ӺdӦGl҃K+50+O-TB+BvO7[ -5@Ls<*Z4̝VjPG;0z̫BXU5$Q&jr9 FKp$)Ԧ,N<7{cUh[&ۊE*Z]nx/Fۼ32>(/LB@\q'YТ(t ?Kn]EĹ{<-K:A{ feA !f%7'NX44q&D T1HBvlc:w"n%43ҳvM"ZI-eA F)0 sB?ɤQ|:5T"3GbCYi+,y E9ȳ(7ca ĦH%]EŴ_?5nmP6y]qjaD-P$GFa+o 9= 4 \,!KѼ%.=5%/m e 1 [D;w0U)sO;y1vV& Vc3Tv.7CF<̇J_O7^ pgVezikDO )!u7L⊧-9,L%/N|σP'N9+g6ѷs&[$]^54dHcK9>SvϾS 1Iӷu3Jkvkij mE؀Rv*05Qټ3B݁|tly.4~jHH3x p_dU M^2VGΰz3_V~Y=esى%kʛ˪))fnz?1׸mQ9wSNr+4je%u%4Eˉw}Ӥ_gTLk6sfvZ<7Dcs#뷑5F3/{Kjꩋˑ^uba8>놋E aXeUbT5!} [ 3@QhW Dbbi'~TE*g+$%^ĕq1Ki)؉|w]=L5x֝*<\=4~X)}JFN(r|Q9Za м=>8Ep˳BZ.N=Xa><+YkfnD"WM2 삦s֢`k XGQ|0+huYkU+d`R٥`[IRzem.i(IPơw.|uc?xGOZfb'w.:dms *h\+ @d8n}HzWF PNDV:  SMJfhCfdIa5NiGzqjf>gf54qKq׺ED$P[d\崅PUcο=dXk.! ֩'vMClY-2h lnᣅXm*M\TI;5Y28 +_y*X羯sxvpZuA}@&,@juڤh[7ʰ[0:D|spt@.̌@VQdz躊&4Sc_n˨LL!JȏΎ9>SM}(HHY"eM(`N"0!񕩹n'S.-kNP}}~竰E:vKj{*Y'†1U*5S <+ ζPšmT5if|>%+QR1l9+Hy {xDνnVmg N%ծ w$C׏֧rlKE>qzQ(H@¤w}Gɋ:y钘]b u! eR晳b:Y[ Q38=B8 %̈́ 9=LEcxaFmAu^fj]tDCW hjY%ޙe\.g[w^Ũd+<~b4H:M. p ExGNrv="@8I{KcP<#%]FIq.<{Zhσ,uXp}"y%`Yj9{ | +a՟I^.B(]>u?a\)/ak7p@Yov2zk 7['%3\}R"E̢Ԭnא1;5qv*'ص $vx@6)V_|q QzCwe}$<GQ}>q\CRo>ŒZ#1qTZJ:%yނ8T+秤K#JB` ֬͞Bagþ%hX 9wM뷍R > [+cRW;MIs0 ' @ `7p|9#.,/:5X=ڕy3^ĔH\Intk jHmWخHVun)畔d Ep Aw |U_e&@NJs;< T?<ۓ.IP̢,讷fvzl(cJT`!dL39UY!KHH԰ .tdq v&|duI_/M@ȕ;FV`}-6p޲F.=w_Vޖh;`[>ܜ0@ACa%bwGem溃eY=NDb`+#`i,\[Sj Тl8,GؼUWL[xXs"dO%h;ޥyS̰P$bH 4IV-pl;֘%[ j V"IQ Ǭr(M1IR',Qla Z:BކGX͚0؝,\ Q'`$jS/x4RǛIKjM扫l^7.m;8lНh p芲q F{63Pu [ nWHx񫌶nŻst7s2V[52Td+1O%vI9D_]9Ґ/W[?K5x:ۦXG&oĉ%>&DJ>iZ %μ!Q']o4R<5_֙}޼}iQ?N6ɀ (KP: =U%+`C;z}Q)]Z:pWp}ƇnԺ+0f=>?6zK&s[<:8/8PnrCu4Ey~ݠsfq4-Azuj$&lɂB}pé&ez\Zas֦B~T_ϼZ13DGي8ڌSJ1ӧyQZ 0 ǽ_pr3 N34oc`?bQG"1nj'Ղk4Q(bg%/jB4꺕 #=EOL_E{BwM؈Fff}A|pQFB9cpMˠo>@W[t/2@{9MZwհgx}0-sU7GaowG"2Oy]a~sI3e <)VεN2./o/9e$%\=pa7+&_?y73D+|lTUgbvcΜ%jIc4Wj 6R^Q:`~|Ca56HTU#ʦ498.uC??8[?yFشAlnV_v\[&5y^+O+l僟Y$G X/ot^-)}<XlV }+PdvhZͱaj(&5=x'7q(vZp^CE)$as2S#irܕn"2T4-b[S~vHYՅYQrn ^=ƻ۪U9 kv;l aszύE +)TaZ|Wp^0753>r Lxj} r[<]3b\_~EQcOƳдn4zt:ۇ ?gK7Ab̈́?0Țq#FsLBAo2~Q47On yIε}r ?Fu-~Hd+YYo} ۿ+~f(aqcKl\pbe"]1 ?l݇wA`zK$&B9g?.(m+>-JTDxn u2 1o?~;5LD?tqto5Sf",O;uۏv$,@yI.ol(4iN9˭Zʍ/kI7 ;y~E;^wAI =WPD%/[_)g~xe>3L&MUqSŀor@ԅ.4rѥf0):]<+&MACFֺWG^qssr/Lw΀ݭ ? l~$ vwSqYxUKr6]G@*S~gU*Tr&f2gC9IlSׯV%W؉ld)ώۧo md,9m+PO+Ҟ(*:gQKzqң:Ϟ j- 6Ѻ;Ǝ*SJ-af8J3I#2ku N9sJWP4[)^%l_%<~Hfi“sSDl6OTJC ܉b%eQSvY IE)Չ,6^*tI`PF:J;ebWQ>  <KUxH?d\jẁ zKxl &[_Pd1٥~{/HO>]-]Ln@6j׫8RA|tLEw'CF>x+ae@%"rS%j|*;>Qe'CQ* :Űxg=e7Bh85b΅xq=մtE}7:ޔ(+z";VBgEYȼXe7j2oE@?4C|z:/K=ۢ/BV(Dɪy[-?W S1}=vO VXӒ;: DoHS9xVɏfWO$ d>D!nH!r]vUyE 쪲Pܸ3NR\@HQ"!K/=߽s?جkpfVLԩM~g5 lW{V1$d}D0Dfk|ν{+R%s`1eZ*3@G祇, [%nwoΝ؎2Kww969C#[aCf9D`K`lȄ=׭*KMױ A777G*p[K2| +WUݺ3QM8g?BGdU±$RB 7| 9[aD)V <QQso&>3H(&< /5g^Ge G}ٗ3^s" Ŭ,3ķR{%NΌyrGx'y'}yyf0S\ ,|!g"/8DMMJqERxݝ}-S4Ks*6:[l.6ϠE '̂DS˽(sܟͫpP)2oKCBi }<.̯}proB3Gd6flXfP7r,%Zc+`Խ>$}^KGQ)K&4GVKL=\kǴu,]1ݏcIynYm/~Z2U9Cg0/.=ssדU_^#{A-Ml,l~az:\T;O'a/~'Α*ÃAЩ YIc{sx6.d*9۳#H֛brA͕3V_i>}u,a9fB x*pr$IZ: /bG(J^El] ILgMi% ѨU7#k^]Ph*g=Qq6uX\ܰLF7Olx Ou蘭 ,/&p-d5ͽ16G'05B`/ҏEaj6xGXIf[p} 9jix alBfrB;6^eqn}OP7_ $xM=NP(qcʢH=K)՘؊@(Pc-Zz^A#p#evs oރf CxydY~:U.,I+!RkDB79zF34>0Tg|{wiNKl2Dpʻd`0viꓥPTz` 緘D8ȵaG"v&% /Ԛ]n:!@6=H}&}Y-[*!7 GW,=&wH%A{߱m?R[ (W ;JL^']Q3[ֺo=MDu-g:9Sj;E;=uTm-. ڔ1Yl>[ xeYYr8.3 h1:GWhb8y7ylgVcaVOR8XN/It56Xovm5Mkv+nQqiblnnoA= github.com/zap-proto/go v1.8.3/go.mod h1:fbNeWcssRRbTkQEDCrmUmzqJA1gKcAlgi1 z4QrtEFZgK" ;4x=package zip import ( "bufio" "bytes" "strings" "testing" "github.com/valyala/fasthttp" ) // dialRecorder is a Client that records what it was handed and answers 200. It // stands in for a plugin child, which is what makes the assertion meaningful: // the child's view of the request is the whole question here. // It records the host the child would actually READ, which is the host on the // SERIALIZED request — not a field of the in-memory object. fasthttp writes the // Host header from the URI whenever the URI has been parsed, so reading either // field directly can disagree with what goes over the wire. Serializing is the // only reading that cannot. type dialRecorder struct{ sawHost string } func (d *dialRecorder) Do(req *fasthttp.Request, resp *fasthttp.Response) error { var buf bytes.Buffer w := bufio.NewWriter(&buf) _ = req.Write(w) _ = w.Flush() for _, line := range strings.Split(buf.String(), "\r\n") { if v, ok := strings.CutPrefix(line, "Host: "); ok { d.sawHost = v break } } resp.SetStatusCode(200) return nil } // A PROXIED REQUEST REACHES THE CHILD AS THE HOST IT WAS ASKED AS. // // The child dials its own address, so this header is not routing — it is the // only way a child can know which brand was asked, and a multi-brand subsystem // cannot answer without it. hanzoai/iam resolves each brand's OIDC issuer from // exactly this value: overwritten with the socket path, every brand collapsed // onto one issuer and every non-default brand's tokens were rejected by its own // relying parties. func TestForwardKeepsTheCallersHost(t *testing.T) { rec := &dialRecorder{} req, resp := fasthttp.AcquireRequest(), fasthttp.AcquireResponse() defer fasthttp.ReleaseRequest(req) defer fasthttp.ReleaseResponse(resp) req.Header.SetHost("lux.id") req.Header.SetRequestURI("/.well-known/openid-configuration") if err := forward(req, resp, rec, "/var/run/iam.sock", "", "mount /v1/iam"); err != nil { t.Fatalf("forward: %v", err) } if rec.sawHost != "lux.id" { t.Fatalf("child saw Host %q, want %q — a brand-resolving child cannot answer as the brand it was asked as", rec.sawHost, "lux.id") } } // A request with no Host of its own still gets one, because HTTP/1.1 requires // the header. That is the MCP hop: a freshly built request rather than a // proxied inbound, and the dial address is the honest answer there. func TestForwardFallsBackToTheDialAddress(t *testing.T) { rec := &dialRecorder{} req, resp := fasthttp.AcquireRequest(), fasthttp.AcquireResponse() defer fasthttp.ReleaseRequest(req) defer fasthttp.ReleaseResponse(resp) req.Header.SetRequestURI("/mcp") if err := forward(req, resp, rec, "plugin.sock", "", "mcp iam"); err != nil { t.Fatalf("forward: %v", err) } if rec.sawHost != "plugin.sock" { t.Fatalf("a hostless request reached the child as %q, want the dial address", rec.sawHost) } } // The path rewrite is independent of the host, and both still apply together. func TestForwardStillRewritesThePath(t *testing.T) { rec := &dialRecorder{} req, resp := fasthttp.AcquireRequest(), fasthttp.AcquireResponse() defer fasthttp.ReleaseRequest(req) defer fasthttp.ReleaseResponse(resp) req.Header.SetHost("hanzo.ai") req.Header.SetRequestURI("/v1/iam/mcp") if err := forward(req, resp, rec, "iam.sock", "/mcp", "mcp iam"); err != nil { t.Fatalf("forward: %v", err) } if got := string(req.URI().Path()); got != "/mcp" { t.Fatalf("path = %q, want /mcp", got) } if rec.sawHost != "hanzo.ai" { t.Fatalf("host = %q, want hanzo.ai", rec.sawHost) } } // A dead target is 503 and names itself, unchanged by any of the above. func TestForwardWithNoClientIs503(t *testing.T) { req, resp := fasthttp.AcquireRequest(), fasthttp.AcquireResponse() defer fasthttp.ReleaseRequest(req) defer fasthttp.ReleaseResponse(resp) err := forward(req, resp, nil, "iam.sock", "", "mount /v1/iam") if err == nil || !strings.Contains(err.Error(), "no instance running") { t.Fatalf("err = %v, want a 503 naming the mount", err) } } Bxrי?Wы%oUR0 YH(E@VPVcs03ʧ\@*﹔9=P+ _yvN/:Y<}:Y̗j铝|n~\k3G?3]Y?^=\/yrkW`8y^+z|%Lj>3zn]a5‡|\ul!3!K|,!xN΃_/a c劙]}7߭۵/!95zAu~X :>e ~uw=^W7 r p[ =\fF"7ggo)̸f0Ӄ@Փ}uUIN|,f}7_;vngwhyPwUwPO1TLΪ×oΎ\Ვ[ 5`r,ojzz7/gsp4+1ߪJ.Q\q 4&$3a 0qv sxCCQyW eO [|NK] ^ԒZk>W>iEk8Φʜ jef%j{~4vg0yHzv,l*EL[3YdxӦknaJ]hnTF9&`Jsd|vDʣ( {D(pv#_h,Չ<kA}ϣArZt6LL5vMUѣ2MA-դ 듒,[-ZPi˱Dr@c Pw؁TAu5i-ǃ KKNv x~l@ÐɼG,G{u?mU3M0S:a^+3ce#]ȁj,Օ֧+x6ҳ[&9%Z}-^- 8b/~0ĝ1Trptw ,㢁MDfsS˹pP4p ɼ#Mwլ-6.As3ݷ }W7X A?xh8UDmѵ 5UKh!#tS _+;McZDz=S pv6J?<֋<߲j{NW|yu2nj"F۳|Ӧ!kW1EOg#@,3脺KZ!WZ(8*e^c!xRr>[a;0VyA(W[MѤ•^Ȱ)kj} ["Hí95 y{O'd~ŏzYkC%XaA~I (ZA7tSYJVҊZ v>JFDxk DiC ۚcX/tzZܣrӤwzDE'x=i.8Cs9~:\ t(j댱;Irb(.TCIXȤ9g؆3G\& B:|G"Ŵck6nQ&u<)8fƈA%Rndw>Ґ0I͗šTDdXPs(f"bόX2%\1c ̠!q^ p t(,E'\l4հA*ܑ7K4S.T`"HRM\pa%!WE[4\8E=U1`) R^4"zD>*]uYǟvk `EitQmM8B8ۉX6f[QLs.;:TK%IJIƭs p ^*4c0)VŶHxN˫Um}-#i=Rɳ{xSJ]DD9٨&ٛlօ] i%-yA.Hbm kFW@)K} %ənd" I1m[]]JS"e%CN..XJVЌ] ,i9rYaF?(:x J`-ƾvHL'X-MfH<TYoj Mg_ӳ/c:r:=;<;zutzXЋEIķųSώF{3Ɖv\2ha/M͖IR dk$H k)Nr o+2kZ, CDjJ;g7.# |و6YR7wKjkjv=Ok(M:뺁01=1WsU3.D8D!3FQZPF3--6x%$߭qm3zN>mPMuh*HuJ^ :DW&#F(k^fth9ћG/)JVd r>FQ4de !SoNO}<ڢiCdQ :wd=d o!]oaa¡Q0BJ^d+ ercRc1iZ GzG -,!rqʍЪ|2 DRt"Ɩp4OK_:)R0ga@~Xݳ?kT<x+Ew#p D7&\RŒ4t2ni"zed4׬w!"7KɞBP4g (kθ54";q]uHP^(SQnPHZ?0;x.*8wzNs^WՌ'l|1ؚBX t;-Tu8vveZX:3]Ř^Uĕh 2d>XnU0yx=wt5JA4X{<˶p>da}-p@^mTGc x`~ss[K*e(_2RZ7ha_vZ0D㙓M!ǐ=1(զ4ZP^_5Au.-ܩ>d` ir ` h!vg)ɗQӬ*+'0ǚlfszt'˸)XYB<.ߥR_}^FGo=U'uAaRDLthϼլ !jUO" |L=$jM (aS *.."TtȎ%XO9虧Tvv*]pD$Dn^~dd"ҢAR*exX\d_[q\ZK^TM$ѼcדmA͌rœ6iF9fa:$_n^.:ᖃwXLANLr 7uʹx{-:ćraC{I瞄8xIҽ{VX&ܣaοk͵FKzM#EreR BFQͪu$K?!\>}OZz[ūck6xV5Lx=ZϚ@d e+')(f5)yW_MncA'NDۓGmkƈDZ׫}`-PҕiXa}o~SD0#  H G׳-5i+BVۈ@}}EkA~MKQ+>@ȿ>.SnǫYIIoD6f))\XH9{L")!/D:(H\:-lJA>dtarֆ!-e߲?n>G;ѨB%Djj&쁋5#T i/`0)S MĄg@UVw>XQa/&Od3xy:2(n^fdOJϺ`Z4K]tހ߹QӅ #$qk;;Pk0HWX@ KvӟP}rS_;25M18SnD+귷nl+1nTl[JoEceo2Rc{hׇIcP %K#XLv&' zJ3c(p]Vq=-ɰ+"j@LJCk GT>6 fQZɲ-HmgkMECF唩R.{I y͸?4̴&Ȣ.:Z 2Dzi;!m^rF~AËwxF!0!)7-ɪ_E+$To(dӀLh'-?\TPDмdS -"J ȥdW{>3\vOn{IUCi<"BѭE|NA<WUJSm)f$Ng2gI { 0WdEv^S [0u-xZzx®nd[G6t)Y; h]Tf-;Zl XOl@SE*( n=J4K[[u jqhx59hvCXy5^pu_-Oגm Bԋ[kgVϫj\xh &>Ҳw.NkO9[,lPߥpNEEgfA"V2 ]@1Yv4)-2ڍfHwQFr.-hK^PwzL@йK)":}jQg*0O%n呦`*>9A)2u{͛DLAXw݃rB-uh۶)Of7I!6v 7 ~ ݼ]3^(}*ojn9(;َȌt@[Hc܈OKdh3gIQ.ߓ+{^Ӿmt+{7]K4l_{{cRT_\P7b2eGRZ0vsq@| mswƹc^emgjQ7Z?2neoboD6j#9$ZO@$}hBjqt0j/4A=ľteVD h)۰>UlnW̧l @_3 }Zg]@9#@MRZrMOll_])5Ie.' Ѡ"d |]r;MΎ*($l{֢sW8aWē1U&CVѵ=st|S&;[=vVyǻi ylyǤaѫ-++I;J|PZ'.g*[Ԯ~#Vq;`jiһ;~ pAʮZHBs%͏2.3+k{]τ_vߎƒmI7E uE.VEKKBEf'r@TdB#C]~J)د8C7rᤙg1ʉ1{Ϊzƶ[.26 U\gz2{nS+vIMW)K(6]%0Sl7h )4<;Mdz8{gpɣGрQ񖀬RAA56m(|~_m1^, 3Vw-W5&N pT؀⶗ʵ.y eh܋tՐ#N$-b/G70foR&'Sk~&z %;#TN 4 b:)QNE0 wk@P2ָ,2a6ڤa5I~܇z_؊ի:Rt]: P9!.bX9%ģ|zF  'oiDkMcvUs73ˏZ@V36+aLyNQUݦ/T?,t"=STZ]RvmTW)GQ&-~Twm++ MeJZgڧPRk ט o"W) ?ú1)=T**L{?V_y\a /1mVGt ^8˫b/}WCC7b65JC>PC:|0݁xȚ󃇣) IB" V-d#C "S9b)x;u`"*-6DgۻAf3ŪR8<{[xi`JW@6J3IMʲ+ev0i ,o_>sfDpOj$ٛ/ؐٿYDX'jYI14̠^x9ifB$4B&o"1P;'QSrnU d~lJi?s1DñRbLn ><;|%{5֓C¨8p$Dtl@kg%cr rDZQXBVmfZknr.-<}[:-1&Dp{c{jqDѵ iBpI 7 ̛mCE8q&Gc=(H.a&h7zaCMնu_~'>ќ;zuX0'3掛֩,JPyMЭ*=5S*ִtP`@U䶅/HhkR[vKYМ%]Ɋ+ K.e*_8p9_T&2\55f7#"m<Z-=#Luoo;W͍kof_1ق!]O!)ITC~қQ*`g[-O>J*1r>RJgB"*~Br4Sɢ%F益_GkO 17ҡH%R< TRQ4brb]B5:&r$N]5#UE5ά28MAYb=sZs7rU(=l1,GP 4^kJ_>;>' ֠pH)_!06LR>|F$!j@%o!j28m#Z:h,.ADjRwt.HRhg E"Xќ@|}{.GI D1%qd4Pg$V{Jp.i`n60=ܦD~ka g&UI>ȆJ/t= EUD VZ(3l}(}ͤo#d$?GG?:q5Nl'OvGij0*F3@}mSھ nL: 9~[B9LO@i:yrP*t q}5hBr!K^`Y)S+G PUJٮ֣X2 EhiUV}VHہޡkdXomqe$˽_▍</PZ' Sn7 R""Vr6窷IY\f)";Nt8%E5`MY?\3Qqܻ"8zMI"/[^7q9m}Bu>2<5vVbA~BsA-}J0m@hJꟃ";žxXNa9tC 3B&hGB轱iw)k&x8̜"\Gqh@}O:mjsS'Kx9K5(fӣLJ&9)|:!D=%$˻5Q;Ant3\?OOB`hAnyT@M}3Ճo9`s2B\c=a/{'I褞PmD6km6wlc6?~v?χkNw"/ A9=B_~*JCvSO?_恼z#b}Lz1gC O +L|P CRYkrma6V ꭩup,j`tc6):!wl WVѐ?/ys&:,7SAt ٭JW=K'a4mTC禛 !ѵ~:13āZc>s_ NPߐuؔPiƷGgߜ!d q'ɸ8D>^P  g ~ f J'DleFmt|J"cC'9J:p㨭_:]QaNhqlzGR[ݝ$?:PhAр深&py-gAgcZ66`TP,J\o%=iW}OYpvnG,i}.(@36 + g$S9[]G-ogU_Zh9PNd;FxH{I/vD.s#œ[Ǯ &ql큛 ,aX3JeA9a]|w897=LoICY ^p2]`Law!̂"N9oNdk GD/wf" Ϫ&H9_6|u;# lGkw+lQы U#a*Kd kL &jR/?H]KpMqgԡrI:2jq($~7(4VYi>QSϛ3$óW/9y,E0]C:Pj:";䜴n 9\3K )R֪m}ڠ/2K*|L[[->-KWp[LF+ `~_Klt?N̈Fmy/;)1W{OC(668%u#uj4)ܢ;w&WR~GpëCj|̗TbS_J@ΈMTQO%GzuD r?7d»u}rX߮ϕ'۳ ?4L PhcN&porA^;^_~zbCAT3غt>^|`9f1:Cڵ ɦ_Y: 6`HFimXV Dfr kw N]O0s L``妨] QPQqR1QLDmV<^1o 1+:ɌraB'9bݖWGϢB]Gw\9ıB1g( Z4jҖXU}[HKfc>Qv!\Я<^{0"/fDPp+ِ껷sG#χmŊ@d\xoz!Mmet`7KRq9GoׂboEa,GZ=l{6'res֣BBx rVfSfn<QcFet/h_5Xrj?lIKJ4;J\.H(ɖQrk6Mo3Kјs6-vKӢ YMmXiZ>;>yڷ[VՈk'ޱh"5[hw\U̼Nr&(a$aq# ѷ_"n[G=CxGK6~0R΁7`qJz.+hՖtc\F& AVmh9<·(^B؆t0u)'z-kC}(E ,a}x2gE&e@0O+iv-Y>)bW/e^E|)zvR{ԩW%Db -4&po#xT?N\9v 9w] y4{61LͳTG/؍|=$cdhS0ۣ/RJEEn$h[]W+]("ߍK]KVHil,Js48/VLoauӍ{!cҾCqY253h}*=#n烈=ևC OI<>zpG'8|/HQB)JkUcى<@кgmStjlyWxANwOjyXrWJYu,~@rmD~nGϡ_4Ǹ^+;\bfNu5>3  ?Li|@`Ruzڬk9~f YRf|-b;"2ma$dCB=AHG|p5BL+luPxqOI٤n$E*EsM,`43Ƴ1%^jHԁMBSB#mFn͕oc.YՈFd~,+qqhBK\ ނ2mg<ن|ͬeETEl핽kX (uJ'?N!gZ֢V2dfrȶmD)JZ7C"Hғf! ozYb_Z򋪪(M/)crD8ΒҫmY.6G'8͵YKES@pI(\2_+NQwk}ʤΝ Xaӂ-5NtlV*ӄXzbA'j8ʞ^UK2se4~gWyOB*}9=viRBhr0%$ސˀ!E 2)#F,# dVHiF4Z $m 6,큼$Dd%W.&X6 Qir[_=j^ÔS85P̎1w}%!ٙ<‹G2U/-<ہ"3$;^Χ@}7e7V:e6Ri@?2~zO\q^3e 8 @<>™D#չs;r F"B>Q'<$Xp7Bt~Sj >s :a8cpFvnߒs)B9 ]xm;GnƓA{zeMw%O ͔,%"ﬧ!2򤶍K\SQ@Q>n߁,i@2jF9cpE֩pxBROTKơݎCfmY)TRx.[uBPv*E T-fSBXIo;Pf@-l=4hli i jB{ 2H?ic25R Y$bQX0Q>'!8^߰K L׎-Ĵf)zaX↻QjslQNXҔNq K(1kQFdC{XI꬈ĩC@zFZAA 'f;Y)ކr#\*Vڒм{2$_9^|E$ RbUIV;1sV|m!% ]ÝG,a ȉ48Z" 3Wxh`J9T]秨DBA9*l[ b-8ܘ_`7܁"};Glid觭g31z^FHwxm`f):>Gҕ{e*bvR#5PHfN .JJ 6vhZ:ɒ~OD^CE8eA[l#>M]Ml|g˜8N՝:*|K/Yw~u7۵7nxÄxd)?)U򚮝/+^_^&֦F. ^h5ʫH;_@^IUx(׮ywithOp(ctx, servedOp(op))y\=xZrF[| 1 ٹl9"11wmI٪sNC`H"00xuuqOxOr_wΕH`u V:k~ͪ(+*[7*[6桡Ll_-ª뮩qՍGΚM[|s}Ү4 MFCujS(g,1*sJ >ߛzc)~^ۇݍjIUc([ZeFaʺlɏATuZxi IlJc 1jbu]Jqi]Ber6ᔫL|$KW)SLUʳ;؏fe*MvcQmHÎOV:'Ѫ_L' 4YotNFmu~? &+lK#q$Qg|R))_}w|Gp^0r]54cHۨ6kȪwͰdeۚН)ʡdInYHr<D&u&[}qz~} LLl#W# kS:[b%LޟnX]:d p"4$/ff9Lfꍢ"i$FХBg%K3.[0p Z3j+KYpjqxŮk7ZAlC-$r",F=| niCK–-BW#5{rP؋"ؚJ[er\ ,-5E`.č SC C+ cM;mɆ ЋK9CP?J4waVΤh$ :j～579ѓ `=ʵO~_NY i$MkXH+-e7b*5:iæ,A1;6}3JT8 p|6!s(}֥OESUeIM̖ $\.g,Yӫdum ks?9M6TVTbV$޿:˧x_m?Y|B*\}kt4x,ʁ`C?/~ HQn8OkN  aXޑAâF]ҫR@p!qAzB}e*{T; Yc?g2>O= q>qӧmv\rp5W7;lM ΩXD(1'28_տiUnLSۗ( Ks)1#Z|jD6`-M *5A A.0d[)q#UNx#3W?ꬔO9۲6sƤ׹RLǂ  Y<*'M@+|r|7HL`޾_b.Ki)1c_=̓IQ5$ y`Œv󋟻-f{Y(H\ OI [B45} MLUkFwrSFԟKZv,˛ 9dFҟc[ǓH/˷;X MݚT H˫!ĥMc"Ӓ S-u(ԻT8Nσ:6t>(ǁ7o(~d;>/<~=|`M Mlh~>AAȐ LDKE\2tVL+:o6jPO)kmDѶ1:k"*.8hm.D_m5? M«+0xMHz01_?Mbu$*]fI[\4یm]=IPfi'Du4T2յ[ԖK'XvxF,' /cDu'NOfo$㙛(5˔y6R5?> an`(ZYE={Y/ 81f *L^,yn7=U0NO!/Rܖ{2E G)ʏ򉯡i7_Ҥ-Q |BusߧҀ Dzs._x"yE%V^hARhd OI?':{#0~ P:r)Y3<^]}$r:}ɦ~Y,i|齼/7rGӘAh~K,,H#]}XxA=yHO>FF#:%=?{θS%ə|iA?;dX=ccф)ͣ2Z}ނv~w7\=ې|J14%uaynW"j5YHcI֦uxćCn,-77ՖNjA!\z7?c/m$@ά兝S㯙rRDn<ˆf}Iʼn5 ]e|#W+οHX-.O`[- #X"򬉺*0>OwU>'سw1Pq`eUfww]d}e|Ls&:u&jeSGLD*M>]CoACfeD;ya͸UUxH}ٍG,tʒˢA6Gc,aLb dh_.b^%VX)yl-O}@J LJ|>*'>J>fݜ5aCB\yub-rhW*4b;ko*-{K'cVKbU6W QL@)fGEX־!RK8eQ7ag LݏbÄA?H܁F7;ƥJ /k^+N?SyH5x_7/_]I}?~>- ?s> F\w9*=厂~oF2+yvҼ`.wDFN~Gq@l%"rﾕ1u_zLo;2zhikm^$2:iAK 9Ӡ,W'3nknIQ]gb&_ps8'Sz65:(16oWWE MLzoDltOt! 9u~ /=i_ʈPcn FϹnl5wc`\EG;2N7pzXtyIozze:*zÎ_d]kstu>ίt~w=x>ɇ^ZO  /Bڨ D=|8Ocn#<Œ(Yar z\X}ٮhui낆ZQ5q?7Xw xrG"vnlnw4%Q#P"ڻPQ-WDEC3>:}uox/_a\&j(\=q^8-&_1 d&_YyE2M(2cmŏZWWY2:뚮5<ܕkQo4jղl._ǝE1M̧Wtb(Yiw= T\#"W2j?_NVelm!Adș27jð7`U6\7ڎ~^HlE=R1/K"l>ߦ`;/(<8~Z/ڏV㷾8d0Kyb~+x^|o73"tܢHf۲z²Cۣ[,kۮEwz9IzI5ffle -=u^74c/=gټʳƚRnw)KX6 q^,*?Ϳn W#_Srts+$Qfسk8Lqׇ 5Dk1YUr${*nj  -6wnܓ`"|%s5Aړ0/!nLYC &,]*(~k¤*,m8J|^d3(x`eiXooqVA74źb׸Xv|Kaxuz +zul֋psq75_ 0[$jf/X]7I%c5O>\\waY%*vMu]|_ ]Xd7ޡo=;/*e,f4}x0gSyXr`Y|f5{S{}:igpyxo Q F0?޸\ UWH;zK*~mIvs=85:uv=ϱ /j!W뼛1ݘd23FOjJ2،ǯNN1gȥ[ȥGD)WW{Jj_N.锄'}lCssh`1#P]?&Of-tzD6XM[)d9y/!JKfZ,Wk0PZ?e<-&MQ/bQ 꺸a Jyv㴞]"aZY5k@'iܝdq\G폷?mc4|'"Uv;"-$̉) wĄt 3VɀtsWQ5\ec{.*%8 fKfUs ! 樸“ӓdFj} !G'iEF폎l;)c!d Ss&{{-婓%[dNjvoQ;@'#eBu3&<~uq\ùP. ԧ0;0A#ݘ5u#6l7bawK 1zt=YNDӗpY1{F08AbX#zWfw.@ɺ8"J 5|*祘,fԁI4q.Yϲ%9hEx̏A@(O())'3@`Oi`wp[Dwh2qf (R'Q!B:~0>_oD 6]H}& X^-bkħ2fINɀөVRfيBH%Ry| 2;R? SėnmKx+:&J!~1X/9N(#PG~u1'~?ݸ{v^&=s ]>xor?F1ai?-Jr>dcF\"[O,' EٹWǶ3idt7YN(zȤO&q\: "{a͇ s="zrF)Ny~}X2yDSx5ο[.אʝI+ -`d-/0xYb=3ptBjPf82Ԫ<[z<ϫ|ZG!f!ݻ>DGԚgzUv6P['w<ΦJ=5fKHr"Q,j1qwE E%y*m8Vv5G:c :9Ls/P+7:NCDpLt`vq w1dž#wh Pº (hk3Ig]MUMU*[N៫l5S[IJ@\c[J$3GdUCQN=i&QXXx4h^&+Q׆Yh;|"6f B#R~Sr"+#;. cd'Xѹذ|MΈ q*e*f0".cy üAV.V8>+72] ~ 1BGUi7Pۦ\C9Ig*$esWpS(^)"RD#dih.M)hH;ӊT-UA$FʤTس5I e@}4DUT 0ٜA˓6+v,$*Wo9̓E5P Sg5b[fb4cљEY7 W^ZJYnEU)0G)-ptd 2 ̌DPmTEHZvv|=4]\=LF!_(VKaܭD 8ZtP+J7yr0&BM¸آ^(q,}[uFaX]LUQn23DIkE)ݷwz3!4ҕlis[Ӌ㣧3樢8Z4-?TBorj8jTÙ}VX]18\Ro|bjբ[BG.tNJ[[s<0"soLAHX"른лFBi $U6-Hҙs[+9Y UȆÿ-:X㨰{ޟ`L^b't_=S}t2U)f8KSICj2rZ`DvY^ۉmlY^&"m[< .iie \XsBmk\Y/U'qTVz4D@Hb(4#:ahB<7*&ykjz*R;W0:_itS*99뻚ӭFۘ|{QM?.\z2DU8Œbѕ?#z'2&zy ,ћ^9gNmyN5L2TmT49YXT$'=#hhd˧-#X:-u j:, H^ȜZu$\.;zi+W9~V+?kj \Y#T\sI,5-TnyTLAɍ=N̔:wzAL8Ęx"/[e#Yei}9( ~}rq| nE,f\fc iJ5ʝcτɭI^+H&h r3vFRR~/ vN$mtƗiQ{/33Fh.Iw?4]U-q)#<3>d.fxd/kZPWOujSϣP(a_7l3Qd$O}%Uݲ[r'ݢONN^?U#62D's5Y%B^Cj/%4#iӑ"aU3M1\[ _3MZhz^XB'zHg2?MOq]Z}JRۮgd5 ѴO2#>XAu&Q\*2?2Eg3$)3XUc}L2Z܏Xn6LSG>O YYēut̟eg팜mk>O@=`F!:V93 3 OH@4[& ȳL d[F\esLIߛEwݬF/--z&7?{yz)ġ,#n*?7SI RkSi+}˺a,\fj cj5*$ɦjwH ~iLt&87V oJnSԢǧX\MP/ikF 5eAz"?smX {.K*Q_u ,TBy(( o8M9w4r^oE]U۳|mB[i٘͌qn).Z4XG.ۨ=)&=[FGy2BIaK dٰ uZ@Cmm8a.̚]ӣH8/V͝7T{=uj~#6HQKrZdmk׌嶑)0iȂY6~ѐXZ\i 1hIc H qc1f%%]+)} ـrUTHnHפ$o6ʄDFXuSO!-P_qQ5|M-6Bt.>+D|-%{f3?J'l",ssղy-;o})k{&o${Mv1EǼO]:[CG Y)uŎP\+N81! DrMIfn0;sMޓEc$_ݒt#L%eR$hI56w*vDAx2ѡ&jLU\]r7yP-MYsAN Sz*WcfMKE,l&iEթIۏP?cIcvV_2K~Yst /p)=ʛ`H 9WጞP YQUyJҟ'S yoM%୳@L4u^FH&JjZoMn?Z (N1D'nBdKCR (@v1VR &4dH*3fdK~&? ݔ/"=8CXѡEL%dYODh5hB"Usӂϡ)Ҥ PNLS6)æ]c0 j'A[]^۷̞M&9$Yh옫5<`tk"I(ԛzquC KgVs4rxߜ8ȅ%Q=sM;W`c1 ~n덮x mM_X0@˗B1O=:w߶ OKA6QGB8KHy[ d% etT %e_O#JIT#a 80j]wH/Eq,X I-miQ2LvAŞǍXStsOjV$e:&A;^qxưN& I( ,'1z^x6;R#H-ı32%b RVF=94抴TG1tu>4RLHX5I E9*_,R`)XAE(aG,|ʭ >ΤTYeC"zjkF1o'5Se+;@?XG':..dݷ˯7Io_MlM{"SxMSSx"vn4ڡJX.6>Rk1L9 my= -Hؐ[AR3 |kb;lc!/0`]E>ȕXCXp`Mh$>oe8 GW3ٓ9}n0'Oͭ0փǬ<+A^+Gbv3=k=\7'g+Bf4i=vXvdLRb[ OBܘl9 N嘲׈n-`Ch$qTJ딠 4\*{͒׎WCIR!$_l_뒳!8[g#':?gkqw0C{q&JX{FiÇ~xVnBnYO\wkqRֽ47)vf|~'WG4p1vOEnDI܌ P,aΠ:5?zmPJe~hR6&3^=4 {Q]Δc6觺KLBX[ B@-1:i<ܻt7r̳%͊s@Cc+*5ĬםձC暘\8B4__x*Rm~o L5C;dF>`.'W_7GƳ"1|Θi?=f[*ތz0$`%T $:2_h/ޕ;\:Iۢ} m'S-R+NK_4ZXڝ}Rmj|EcS^UD>6oS|?ʔ|9 AKv9&ZFps߰$D .f͓45ӔBA֊7R^T2+D&Y)c5ٞj^6o0R{\"zޤ-xW! 5z$H@lA Wيv$=|do}9hEJϒmmV ~qJMsHW&f4Je"s>1yӒdv|M$ WtlB: a 3~iZ11 E-dI]uQTAKFT k-mmߏѶ|Њ US3T*ᤝw/"x s*errors" "fmt" "io" "io/fs3 zapServer{addr: addr, srv:1 ?[ + R'ln, err := bindSocket(h.addr, h.mode) A1"return h.srv.Serve(ln]ozapServer adapts zap-proto/http.Server the same way, and for the same // reason the HTTP one exists: the mode a socket is bound with is the App's to // decide and the upstream server takes an address, binds it, and never learns // what [Config.SocketMode] said. Binding through [bindSocket] here is what // makes the config true on the PRIMARY transport — a bare address is ZAP, so // the canonical [SocketPath] socket every plugin and peer is reached on is // this one, and left to net.Listen it carried 0h777 masked by the process // umask (0755 under the usual 022) whatever the deployment asked for. type zaZ7http.Server } func (z *za9]0=z.addr) == "unix" { ln, err := bindSocket(z.addr, z.mode) A1"return z.srv.Serve(ln) } return z.srv.ListenAndServe() } func (z *zapServer) Close() error { return z.srv.Close() } func (z *zaa" zAa } // staleWait bounds the dial that tells a socket left by a dead process from // one something is still answering on. const staleWait = 200 * time.Millisecond // bindSocket binds a unix socket and gives it the mode the deployment asked // for, zero meaning 0600 — see [Config.SocketMode]. // // A socket has a mode only because something chmods it: net.Listen creates it // 0777 masked by the process umask on Linux and darwin alike, which is a value // the deployment never chose. Doing it here, once, is what keeps "the socket // carries the config's mode" one fact rather than one per scheme — the umask // is process-wide and shared with every other file the program writes, so // narrowing it around a bind would answer a question about one socket by // changing the answer for everything. The window between bind and chmod is // closed by the directory: [makeSocketDir] creates it 0700. // // A stale socket is cleared first, because it outlives the process that made // it and bind refuses the leftover file; a socket something is still answering // on is left alone and reported, because that is a second process and not a // crash. func bindSocket(addr string, mode os.FileMode) (net.Listener, error) { if mode == 0 { mode = 0o600 } // An abstract hUis a name in the kernel, not a file: it has no // directory, no leftover to clear, and no mode to carry. if strings.HasPrefix!net.Listen("unix", addr) } if cL"unix", addr, staleWait); err == nil { _ = c.Close() return nil, fmt.Errorf("zip: %s is already served by a live process", addr) } if err := os.Remove(addr); err != nil && !errors.Is(err, fs.ErrNotExist) { return nil, fmt.Errorf("zip: clearing %s4: %w", addr, err) } ln, err := net.Listen("unix", ;1 LS if err := os.Chmod(addr, mode); err != nil { _ = ln.Close() return nil, fmt.Errorf("zip: mode %#o on %s: %w", mode, addr, err) } return ln, nil J^ ]R:!|x;pRF̼|CslCCc͟{L,*]ef&& ɉ99p,MUyz HR@fA{T->fX!1Fѻ\#iv+$k7f_"ҹjyOJݱZsfK|jO|~ҥjez^qi. o7'iO|܋g_[1tX7Ĥ%3F<->q] ;<{Gݶٺ 53L5xʛSiԆX}ج",rԫA+7hd<((Ebȼ5fLjR~Wnc%c rᢜ75[t0Jp(M|NIgz6C?Vt*[{{9i&rFf'.]ET2kg.NM\8YZdj7V6l7%+5lR Q xeOO> JujJhC ܞ)%vR PzU: rE}[5 $awprose_test.goZBč@0'\.Ů3+ ,6Sx;tiKJmK4iW< P,HOfhʝP0|Sܶ\˽xzKx;OWDZ%{o ?x340031QHL,/I-.Kg)7=j?9057$|C+r{yf0%%E`U!Kkk|g|'LPU

bind := func(name ast.Expr, value ast.Expr) { id, ok := name3"3d04.valueg4} // `g := r.Group(...)` and `var g = r.Group(...)` declare the same variable // from the same call, so both are read. A grouSp's prefix is a property of // the call, not of the syntax that names the result. *switch n := n.(type) { case *ast.AssignStmt: if len(n.Lhs) == 1 && len(n.Rhs) == 1 { bind(n.Lhs[0], n.Rhs[0]) } case *ast.ValueSpec: if len(n.Names) == len(n.Values) { for i := range n.Names { bind(n.Names[i], n.Values[i]) } }~4& ypes.Unalias(t)B<types.Unalias(ptr.Elem()@GroupAGroup, however it is namedAUypes.Unalias(t)B<types.Unalias(ptr.Elem()@B>dx31ĔԊ܂TȯB:n&_tg~"#R9Xʲ$-(}Lql {ޝ QZ\_dW_?8`¢{#ļTK]Kw|{Tu6~Q?/ILI-f \nsϺ5`-#TAy~bJJy %,ج}e 46=63ƶkVIwNFċEW:l/T(*mݹH4NCT z0E ŭfg%nj*]Gv=#.}XvVQG ͘oSԩTV`|riMK #S'_)L>iVR+tUEubb°{ ᵔϧu&[>=:u7O#RjࢢʦǤDB (6&Ѕ`Ð/nuTXEz}幉wQ/8.%~x|'|\~ނךvc9n]J@ovL>Y1al<ЉA?y56Ȇ,i^M ՆDjs\E6&'W/|lV@9>@"9Od*&1A惉Iyt`7 KVxGggoH.c)$A!g/mjJ:4 䒗d 狳PI{ڞ/f[_"xNo~lԔJҋKl}_M%%;Ny1r0; -JKʹ$.`∰U߅(!j̞yWnGW+2] \֦ĝ~E33{J#b&0I<܀1aX7/.:;QG :,'uTa&[ sj=6*$Bl 2VqQ* 8~U(Pw, |Z:Jyv/:wr&S>™L{tȄ4mJ5Nŷ|vK4HQ ʺBhq #o4ҏt]!NZp~m0w(A&jI8PwB݁+SQ/A0Sl' d8:l{952 8=z{ cWku TQG|*KXwXGDi d屰! l&@=Ñ64pڌfB7$j̇C,ʲk[z:,P6'@YFi.fn' *<ͮ۳KA1,\dZ I{ǺSkn`PDlXШ^Bz-dR!=:MPJ"/ͩZB*58/{" n,음 7YkLG6X~ld,stภt{Dk*[v~d05V40,|=p+Lg)zHp/LTc/' އRb'@k[8d̴R:`:)&l22#l۠-uA_l tyxL9}h #-5$ݏ.E߰F&Cg c|x8&the DECLARING PACKAGE and the // operation's address. // // The package is part of the key because this map is one map for a whole // process, and an address is only unique within the app that serves it. Two // chains in one node both answer GET /height — the mount is what tells them // apart, and it is not in the key — so whichever init() ran last silently // published its prose for the other's route. Nothing failed: only the sentence // was wrong, in the document and in the MCP tool, which is why it survived // every test. Seven addresses collided that way between the P-Chain and the // X-Chain alone. // // It is the same namespacing the schema registry already does for named types // (see schemaRegistry.origin): who DECLARED a thing is a propertIy of the code, // and it is what keeps two declarations of one name apart?#ocKey is the key a package's operation is filed under. One function, so the // generator that writes a key and the registry that reads one cannot spell it // differently. func DocKey(pkg, method, path string) string { return pkg + " " + method + " " + path [61, under the key cmd/zipdoc // built with [DocKey] an init(); hand-written //3  // "key string, d Doc) { docs[keyg O// // An unqualified key is still read, because a generated file written before the // key carried a package is still correct for a process serving one app — which // is most of them. A qualified key wins where both exist. func docFor(pkg, method, path Eif d, ok := docs[DocKey(pkg, method, path)]; ok { return d, true } "", t!;x;+!)Yl)*ȹ>&BGDUx;ti5MILflj˟Y.tP  xL)5k4EѪۿL,rLt*r: !>}"$8=a5EtIcJ,ܦǥY v&"1[x"J=Q [x&OO8wWΐ7QX$gL Be!߾xrr?O1Ql&RrYY$ٮKC (ť}*'̓wg@hrHp3}M?eEL&zӴ}N1mNk{˪x2|EބrQ},.doEXe*7!Ï~մE{:E]!bد Il6E-®*CYoQx~.oo旧a*UX6mxPv6k˾/۳x,>NdVY_< +߿؆jq9bϓ7(+jI[uVU{pΞync*k]fMl7*gYݰF"]V=iW6GY'څo~%/z/H侀aU]Ve G\]&zf$xʼÏ?jf/] LJm5XVhb8~x= Ll2[5j%Gە5CK7vYi@)iM]P-b+tԬ8 l[dRRPBBA\2f[/4gm<+-mV5yĺd.[9E&;g6k6o8U<-ɑߞ,}0/r*Eh!HWmH`϶2G3f){4V,Z+Z%}BxrK@1 w2F֝T.<7yCmSbE mQ/W,3`ҒY$'f^66r1ȟfRw",PʎقL`E?WCC? egA>5K79,}F ˍ(Sls1zIyi{%~iKB .NԗqQNfs2I34']TlYH%-ΊS+1$[ onĿW̱(;DwhSNV ?͢)6oe"Gf`ClQ aL?~ "r[9q$(QIz(5=EiiUmr/Y(2<N*26*{A>?j~֊سdg4eGKgE{|aj?qQ#f,*zͥ.zEh&s$Url`nSf gNlҔ+!q]ZkR jgj%;*,]&m+U4i$̵IV%,r)28F#xébraGqz狖Xn!3dZnxPIlLbA .>Ae?vX70#˗I`GAkdD`Z:l#q74u:(kDj|D_Ue 켓Iv%Ôm[tڹC;+3k11$i7w3sCl_DELJ˜ kZYmR1PIN{n uW @%A=*.jՄJΘlMS[[揋20K1I{LinH:A"G.fu0ROI~9qM⋘w02뻻wsy`9PY8Q_q%VTLFsX%eS'Fx# dJM2hKRŸB&ɉِSj,h61G ^Iwj5z9P+CW)_I &^ej B;Ɯv9!tEKz Y4^!ZɅ?t7P-ǕxXUȅl9O' ${& _gqX1}5fnHE3QCm-JQ=6@O5}a:)Id[TYX>3:P 4K $Lž9-E3e0lMcH莥,&vv$(a(4۪BqFm3Zũf`u9@jA7hqCw?t1KN&ΚWUPu>F*oш܅}_t_J ky$-Z1e 2 ꧼ>ƆFk+C'_$g%ӎ EK{(kd.XUSD& Tˁ"CO(mVH0 ncRqHUܝ@<-P5;1(offyZ]~~s]{}u߽ ^!+i.gWTT~8-Z ̣Ʊ24;^@ 1T'nFA% MIu Xxq#E%RaTǻ Ȝ/O?,arT?ffkrmI01pC8OYGUͻo^om;w ]c{w,*`U)`XAISYF21P0>xӪ=NG]=h=J!*fWLjS'p^C}%CܫјLkMP&j0pE=m[@;  VBaE(PgVZ {tr)~;puoCRӆWkP.vxCYľ##8nP޲hkS?{#,T0"T`k{,|mǾ)} oYaX2lP97!9U98~ZҒ"~dQf.\V3z55ޗH/(FUJU~6.^aebgAsݠ\| ٝia;+F8WF=1? "g>H'_K19Mu<R:Ղo D:rU:e ZHІl=aيƈκDVіu^m-\c|nqcRT:"߉a4`<ۛ5/BW入/~~WVI;I$b,q5ߎcIK+S5)r5SL,V2~1Ҭ)|LW28녺\D\r9: >Nks[CVa/$4ϕv꟨ ?3GW^-B􂻹E)*2fZY(t+8-,J)[YqQ[t"o{ԩ1pahfwhjfI`22mRPBܣ3! \ ϴy2M8z/`ڇO/w>A$ ;|hҟtD`c*8d>VZ`(/?b3nOJSԴ~ubM4O>Kn5E8n.oé1l>Z+E qXjZd7$4s)&x1UO\"<@KA+ WEOX"êwR9YRNm|@"lѝЯ&ѐ Ɍgcz](aCd^K6s\:f灉歵 N]iW-j5Wb=d&] \4k`? mi8l&|,Rd-y־ykiHlL7Y *O܆T2'xUK9TfU ~gQ?,"`zCA]e:+""x@D6"2G5-zK36P.SKG)V+k lPP{ALM:RM96X!¦ oNXnCJں6XN/7ײ]M`JHhna@8#}Op=ǩ em}p`"Ur P%[656'R$ |޴`Cfyj,Pp>4. 1_ϦIr}NvuP_4͊@̔Ѭ0\$!x+ kZXqШ8:؋C-(hUXk)S|0PXYtJ DQ v} CƏ -phKO(;g.OlXt~5tt8$k[.N&8)tǟ C2Ϡ~l\I#36ohCNjV+ ):P'B$hDb4FVL˚AIL!XǴPLkAvw)DΑQQ'R63DCwy%)DӐJ+%7UC'Cx\^p^v [81`cjީl[{hz@U7FKR0̙8O,*GMRｩ&O/N'v|#%ˉʠ@wD=h^ͤ3*j;!Uгz޳;`KV7O؎m'n*-=\Zms\=(?-&Mj|P֌e ۅNJ] rsr1o4 wK|TOk!<k2<<vh1CNh3 j% `̑)7VlΤn!w$Ғ﬌&`:Ս >nbIՐQqE`N]?Y1P;}%*äZ8t7lYcLHjkC L&k0ݬ1`Sfwla!T mаh hiFžQI}UK<%yxuLe 9:?أP5 .g'c|]xn j[(ϝq79-օi*TPHS iQfl*sʁ5! :uw0lڻ ~ 3OU2h&@g4~]|1la_}a2]ݖ_~c lu 8Y 81ˋ/) 5JƤ`V\CEQtȋ* Z2-/(5װa: HURx #- // // A HELD OP IS NOT AN OUT. When the rule approves rather than allows, the // handler does not run and there is no reply to hand back, so the [Approval] // comes back on the error lane and [HeldOf] reads it — the same answer the 202 // carries over REST and the call plane+ '// Held, not mistyped. Surfacing the Approval before the assertion is what // keeps a policy outcome from being reported as thKe caller's type mistake. if a, ok := out.(*Approval); ok { return nil, aM xݜ]su_1DBvrJU,Jbl4IX`b1ӬU~@*п${N|,e7q2v>Ot6⺸ Mͯ6,]YWٟ*dͶ2*֫^ٵg~Mi7as(O6<u_gmqfwWEkeM(ڻ|W:+mVvyvv4Xz}"\2 }ʰ^fUoe07![U WOOϲv>ڶjOb]..dΊmwU7^*:4&B4KUgm`evWgeՈGI=n;UqzG>nln"5A ?nJBt Mw?R]x[w:M2eO4~$06% `"vqU,eomm벽 KDtg޲[3fj $%4E=Mele5>iUBh^2V6MR Zkeބc aFBrbceu[T/fߛBKS.OnP5j10o.J=*h.Mv&ܽkg]q-%Tٳ̿(gV5}vUkj]^6o~߆↕k %hPHaax&[5R4*5Hע/,kDA'D'E5f830W/S iзԄն <?"L:$` %!M|j0ܫ6o9~C6,eihEhʍƒ/¢@Ż;_F1MƑpxrՈ}@!w-, /_c+-0UKV*iݘZã%wuyDҹ,^|WB WS阅ay.̢gU_uF3ӚEO쐿/z{/(6P]xU^?} c44U~Ũbvx4$#i5@6/FY'[ĉi ݶO3/NϤ+2uqYT_0^%Oѷ w7*-0zC>% i$-}waǶTlЫB>W@eύ۠Gaw 0ݖ!;?nNeN8Dξ;(HO\א&I6.eB.b2, |̃$Nݘty#w RSup ¸Pp& 7V{ ^uM"'G m`H> _E0yȊT5V>:Odg(/.3=*4bbA}.$rMkyg>NnջwO4Dn̏޿xM?5brqm0I+_ԁRbZ~CR)cUS\@ҼЪSٹSr,6ZV߬ UYiCsVz]S(zYO,K +E4r,1*AYM̄wFU|yt$Q6@fqp(5ce͎ZxH7ХI ;7֩f.Rf/V2uc':nm+omՙOG1X:t2X'>Jf}ߕAtrKQGn]ͬEQlwTd5Vh>ra}ҥy_ yV8&Uϣ|%+udB\eU@40ӊ6 Fﻛ8bl2VY]^#vX^ܲD,yol6J&SLDHo,/xG :?+הƼ-]na,bï?N3]Iw?go-yE|i#褒8WF;5&ǤQ+^{YoطjJ'`7{UOq9yŷ2DХbsQ[&iQ+;lf&144&P80J˰Y;pjUIFuZP)lͪg ݍ`첩4KvFy7hiePGWJfRQ EW"J+=Au|6b4əxG:\]7ZeVf@bK&1+i&8`T Wuj3ejdPd$ɓ秿{T#R)ْ[:lshvڇ$$C ci[C&bQ4b禩\oЩXʬ؊l"UZVgap-ȹ&Ex@͝vffZatD:UiGJLpgb-z}>ZGGSHVA08سb-bv:lkB-Rgx Kb ș˶Ψ:_qM-0Ԇ&Q,_yb=)CW] ˺26\|djIԌJv_@kVki1g>0m/l;I*Y72%}=C%hJ('ϡn1; i'.4h?nz*!&82:Yk8i/Jl6nZǎ6Ure;y~kWDGF#R9 Sxڍbj={(2An}Shw_:C]Z1^J3Nݤ3E'%&- Be%|##ak J6'IX#۾uJ> 7x0B(a*b)$^ FGV~<ɠtw+82Ӝ'oaǰ~YqbᡜD~NBGnRGمNY:őSeg딍huTpH՟%fGyxJZx eЎ’UIe46S}\~VД8lsf?~Jt?ʧv!:Jjq}t*w6UNIƌ<:2v6r'~ f+Gn:<&ilWbI-5)faFXN'BSrfO5I~#b%!)sڍ`-=Jn fX} `ǎsd?#*54^e^]O{'Bˊʶg;?hNғ4|c=`Owﱔ~ۿk ̸;F1z;@Ri O{Y @PۙwMJp0g]D+ͺwVj'qK@Tho6 I$zX2k}9md!jRZ _{ۍ[E 310_a"~_ 讐+o™Ņ!/E(h\cjqff.ikZk9B *x"cb5jF11̣\5>̣{JO%YPS'tk_*U X#GA[:LDtֳS?iܓڡV+', AmCK(BX:\z1_Z=C%B,HGc8N?h!l7|Kߜk^ݵ7)Jx۹cNȷup'љoaN?.Q FGLַSUJX0Ahʬ4BD\]< a:ܵ s1vbneUC, Y0#u0vSV蚎*Eaͫe9gT#չ~o %T"@6eq?a: lZ8 CϰBTy‹Hш(E>iO]%n~s_GKHlk|%(X#VUK8S߱i?ֶKu8N>пSjG@qG7f7pX.f5Z#lСflBk>,S4ݷFx< &U1|xJa+D=~XD(ٸn+e)|a%֞ p`@qp[pcAUmڤa"}/Gcķ-W]ČP41KƽI4\*WS_ PLCՐ Wfuƿ#V Րs^2>&?`3Ԑ顟߸*GR/f#A_7qVO!ukv\{ߌhqZvIr$/afxVJl#<􇴷>*Nƭ=LIo̓e{1A73^}kƦa:/p8r D8-qWBްW}_pq3:Hw}q Fxf tćr ޒ_n zىI"Ko/ͩ3U;@0Fb2g౭MOci:%P4nMZ$5r2P,&28l97wd"!ߣ^[?OJI$ap# ;m"Y-ZCx-kǟK=Wm^'8/PɢmXfu>#\ggXŝwxUNNm(~`\ I^:܅cî|Du2IC@+ "$ma 1}rƑ#&; x;ti5Ȟ;b xTNNvԞu]^焗hc'< UcN^ S tE+so;)tJ4B''(Qx;ti5R 9^i: \Ex35VP YkkC(A\/I:͕i%/I@>x{xqBȯ;6[g׻YIq=x&100644 billing.go1 98{<a/x%NN]7dDzGx9b$~xWn7YNEQqJjS;alJb="mj`b'wQ؋ 9<<;RfrĿumi]%IԪPY৯\fͮ'~w~.bv}r6?7_]{Wonbz6_(^g!T[W-R܋jW2UX8[CFlemT., ԋ翤r2S|i.ʺQO6Z6|~U㗬[兮*V+HRl@ԮxEg kV )6,u~sVd;=. 8\e6[8f-: 'tAN(aWh AQ] `zT!F8fAdÕ*HY9 _*$9ǧbXHR-| K%fx:, p{ K( `>yy t#h߉-VU ?2y)8Ep9C:ُ4Aד9k' m =_ڡ"R" Q^PLiC,rWU FP{,Ԉ'ugZ!' tZ!AP&Cf ɵS ^#BQp=@ C1Sɑ$b"!p)# P mo?&~ZiI S ?f sz o,2\zTҲ0+࿭Q{{$ x;+IXK41 LU#}NH[1%HNֆQ,t}@p 4Z!is7<# eЦ_s(sN|r!NG,|+mjafkʭ"X}mZvB5^ҿc/ǣVv i၇Y {ӂIqyBFq՟ 㝼ovjM4zYS$TR)ٰ 9N$ʬPC(2?WȄvL"2^Reo[T4VfG:xa> Ⱥ.v; d01X7cπ幩 /5CȎ}P4nQѠ8z4u!@(!4vݕHz }>IgWғտ˛oQ3Dj~r8>.ON/\e $-J,&;g=PeA(Xp{;m24}..]c Ʉ8d:- T nxt= Kz`58*H†TjѳP'~rWHJ=#(He6Ǡip=yV]ށm(ezkd7Q]!!:ӔZ2Q/p #aKb;3!?\hS?GѕF{~KlLB 'H@2`Q&R؜x)(aܡ\K"qa\J4dxz[ '^TSEԔ\a 9.'G̠aU.hU%- u(-vHoS^E!^f4l"ن*:x5VN;6܋W?:N`E|u:)($fCvG70zb!YNpgN=[U;p0.xkv]l?ܯ޽5{TTx@NN3- hj7Emm%~xt THxp)rZA oex;ϴi HLa;ĹvJ0z|g5 a xh100644 emit.goWV۩#૴n976100644 extract.go(U 7100644 extract_test.go9._7}~"v40000 testdata!4XXBf?LS; x0D s6g]řPX`kP *(+qqBeV ))J-)-k bm RF-.)SL/ ) L(рXҠ ӱyw-w6Vx;xqyK}r=cכ陇- xM100644 items.goaOwKս׋ z100644 zipdoc_gen.goǺ}V_Wηlܪv՞"%x@NM+X ӑ}Ym8xw (ڜ|jhb5a#C*xMo1E ^˒Dх @(T !>jT`ґ$FFĀxT]Ng}_E7NݩG$ZJӣG^ml:`NFKn J%70, 2m@8eօO;}\0BQ}fx y X`nDT6v[K+/_=hRZRo䡐en K!5rQ#DՊXl7Kfؕ:ѝ!PτY}j1Yh0h7%1!6]\6z gy14%/ (A1;jVg"5< (PB!]ܧ2Yc]wXRҝJgQd=6|OXg lJMQ1®BxNhF@FJh~e_]AJ@sOPǕ)O$3faxhNEiԉ 1fYc؜LjtnRt+.17S(I*꨸˽Q9mX`Mmh(<FhV^e4|Qj|2thF-N0pcL̄.*͆5(m:yCjE@e Qş-'LϓkDe x% 0E[::]p( ۤ$OAMPg;br-:_!&\XӜ’I&G^ͻh5kx8j2V#C,u+92@P.y[nBE`MT{(8BHyЅ]t>q-H xhNM+X 3;[=84g7Ok۠(N.Y_ }+d{"[7SɳBڷWy2;ayO=&  ;- 9<+X*гa#u>xrWrOq]+ٛ*֦(JآJrU[`@L3RUyBQI{nMp0ӷoݗlr]b[,WU݆ޤ*]ǦeѤZVuV<{Xp{]fæ\驿}'rrWu,kyۮ>(kVax=C:dEX-2h-_6, M^_ eU5y7%jQW,yd2lvOU܆A6J.Lגwzv:պ͛}Ե3{4Lzmʩ}VՂ7\]4_57y݄,؂Λ&mW /=u}&ͮ!sMT5z# ;V}ԬV0+kV?ݭқ'ߝJd*0絡βͫ v^2[Rd2ns1Vf!-dV{xlp3yX|݆:[8Rf^Lou)cyކj&yR ^ S-`\^WuM]ڱEa{%қke5/Z쬽 T.<0Y; /LXh -k!;6cŷE{.V#OۦT{!78f?U~Y(Pe>,5!e9 ^0϶/Cuea]A\ꍒCP(ĴtNcP%n,*b:]7YK&u]'BGb-QQ^WWn&hi u;⧼f{!b[]Zz5*@1u h'?s9qc(wB)&-Qk)"K 3첪XLpXyhV"# ?8}Wo^>ٟ:;GvOr?'0v0i߁_1ÃVBϽu/K DaL _~* i%+ymveޡh!rmpoo˪ sDV/-+OK&An2_o>B)@Q\G,l]`__Cv`pb`ҶӭnĠz@3LmVKK Kl=u'؈Ѷ7z*qg'g/ 0chQJc"UMAtj)*iMi<]*"iD f+,AI=K!ɐ1L=f) \B+08-)ٞL j=4-KŴ8wpoQhlY`}VS-,fCþq():WyfmglrS)?Jјkqaَx'ZJ&É}w!yD&f"@GɤOYymȆ,,r@9+m[C. S~E<\[qD6˶~bK) ɉ7 :ꡥkn1S7_&Tdy-zɿ;wyz" T ,n[p)W. q/H50R֡v[!?>|Pt.EI 4Kyx^C QHUZ@ R;ⷾ嬸\{}K)*s29R@@|w<IaĽ3vhG=oiK^[w t[ Hڂ1SYFEFk $"P%VsE%̌bhIcT؜fR6[=KјH -7UmBmАp?{Jc\| ;mO w i{b@}PAVMMU '䃈NpRƎ "Lb/kI1W[&bލEE!e+s)xTp+I=Lqp{imuAIǷfyv8.VFX#ΏeV3܁tl%6+wŢ14YPS>gͰ_0 G( d2t{kߨ+<@qjEkH~E: BRX]zrB[F,$:ltM</Z$lԐmeG:2,B:MX!%PR]fǚ0ي0֟/^KD. U t.EQݗm/J!(˰Bt/!wN,>r11l22~˴7MHؐD9<=}PS[·[mu?{op& _H)y4?X kt/Lq*$X˜F^lE{rcݩlZzzMJ5]"4INbr{7ʭ8TZ&б(~+{.A'd ޔT* {kg@?zƇ*L{bll_^THBc #K3GwY=}͹n*\ឥU+#m:h6}VbYxjQ+ao*v8`Ty45/0qJPl=MM2%n q;[Cayvm>8Il1v{S)c$tJh8[>OH}ٰ=WIe՝=f)7$@ ;l./i՚< ){bx<_#W`a\x>eUA#S2UP,CQ4ďbJnzwTBOM "*Ʈ#֬^{GtBZ䃗WzkVFpuI_vC%DIM Uuo5O2ګ6 F PK w{7yǿ$Qs=9~QzOQstxg2L?_v)KhZvQ.i ‚vވЏXOc<|&WnU[-DvT @Wp\#S+xGo|Fl`bχ§?U @k&^@YF75oX9Mh4jlqJpċwNBV9ul֌6)&U1"і;-a`sr$Z zӥT\0R^g8{HM^hTF_IdW~L$@o$mގ?I_}q_~Iufml'&|wvx.%z2a;nfi;E=[~TrHď2C:?:ӓ)Foޅ&XbB;>rOwRh?$oYV[?s43~"9EU`W!;`pvMUdj] 5:ɞ-*ed|&^p~v+9gĉ٘ufMW*_n.(,M/Úfo-w DnB|ČɎ$nefpNdz׬߳8fVY(߅G_~ywuSآ ej|+ *뒐7Y)vWC#_LߝnrvWN{`tz泎گθR8<' zJ&yV#V(4JJ";gd=!V*xCu|+R$*?F⏔1|;B)pl n.OtD _@%?"͒n$Z"G{9M&-H x9頒i(3!EEH| x&&/yl3iQ\oӁ!]'H"`7?<8츼i?E{_vXxrGSWQF-$Aw>t2esƖ4"m6@D ` >l̯}ˬ*qlMVUf~OWyU0߻7ˢo7M՛ep6OwVϦzpvt0]Pwr.>ͫE)?~]uq8-dTϋIy|CO_T$oZJ׳0rfotƋm6(v:?O58X^USOLhgɤFEUl8eńEWOCuS &W|u/̖0WQBԖBj1^.^_]TjP<7T  f(ѨᑴVP%)"#]jL zZ b<؛M'ljG_Ҍ#|] f.Ϋ(tX<;.|TgUՃhl4߰lY-f'eS)擒+6f:_7WBreRQ)(Hcdյz>!Ǣ%:u%~,_N0K͒Sjt<-ќ.`Oь7WFr >_sfɞ6T֯b0/Z 8[/g .l_oOgit5,3E=+x.x6Yñ_?\If%+ysg ^jkU#P_JV9#bjYG*ifdkFRYgB) )(ec La4&yxDހ0zzX.R"B8(@7=ru1Lիřd2f%L ;0&Y@ 4L+NjWU]fN܁" ܁pYxoQtQc!Źm ,)0fX+DJ EfX-dFކ'B f5klhtp675٣aJVMtnx: *&&syY5V RZHf*a}.? P]|tt CgeM+ w[?(>b<畿8[0q UySKt0܆i1 .= 2Kݕ~Y-/fd3qVm4Qʼnrw|Z-'d/q2&*jxO8 : "B ?u1[D\NqzE&ޕ|?r2ppkg$H1Y"}Iv4]wM1֡~6{c Ehy7;]Tr\3&9yǨ{gtٰSQ -YZ K땧l֧ G8;;,B+z?ͺyu1J2 %Ft= -aEd[YZb=gcqqQ؂!$Q8x^^}Ĝ-sf9cu0z Нۖ >V3۱\t~gD@iudi@'+<VEn|.$.;3gU[1tcV4@iy3,V1R Ѩq&lq^N?X/G@X9SEiwsԮN 51?%N +O8%a~o9; _&:=Bt5Voyrvc+KTy,-~(hg2 /#ĞS P}s3zކL9NjjL>ה2nF<i-k‚g-('gJ\x&ig+uEڃ 1&O3i% _k /Z&4nN "LӹWx Z(O"d1=̅b-OE66f~+>̙pP;;;KODȰYXLU+rT9.z?l^'6-\: It'œ{g#!ΧLk J('~ZTJ\DJ:wF"Bj;$D)#dڂXv qdp@$Jdj7' jr ɕn S[chfٳ:ɑ0>>SŎdaj1 !9hÖ uz Ryz1ʤėSVԩ;;KwW^ r'|qp|Hd}:7VF6TX\k6S&+brJNKk!~Mr\c42c%ɊǃVDy-DTxtU,'p<"HK +Ix)*g |@7lʱs %_+;Fy"%"Giخ"frFa';Y moHkYEd wzOӵEia7B6_ۜoڳx mnci2z$5>\ Li/ivq+IƓQ7H);]3gKx@r_1ޡJ:j1]V | tMlP&eJXK{$L ϻLx}2 BP50?5kj!?Y0ye)c ) ,1\7˶̀< ~@!IL {`k9дV$PA.&`BA9,8YUX)`^(cHdgjP钤htvbm&-i|!Qqxۓm<]_)1Cm:\u,&oTHc"3|*'gQ?.M)p'Z/,PaDHoH̫]xKRmYA\TZ^i)S:YP\^dhx<4K"g6Č4aš惵Ir_`3ČjWvS&3VݖG毨Ǭ2|5[Eh 'h= P@LD )ɽ"N'.z#?i+eM %TAYOJz>wz**h،NUqwv0v /]dMh2:ɍNXG9ʑ., eIn&qHXffSmޡkfk$|ɧx"t:MNHVLkKh}@KaZBK[byI bARcûJcwQD/0k8g+V$L  !!EH!C.،a aqHodAiqKK23rЁa~wB #tj.[>~,7С{j ({ZMkDAr2Ȫ才v~;/zXJOUGs4co g!_|Ϟ,uciU(nO/)7M6HRUvwHh Ix3h-E׍ 8tZ땞 HX bl H)"N$+A4FO)/iDz"53_ kr_gh0˴ID$͝zCI2"S0C!St;n9FՔ^#75btFgF:O"%"oFT$. Mɔ[cA!%U7BνldzTx3{V//5ev_&x9(\P 炉NK)"I (SqeH \ - Mo1T ). ܧ+kՈ]kN(ԛAP1XM` *BLJbR^ %ɢ?$_Dԃ#aҾW3~~"-Ĵ  C M kXt0%(si'o ))b@F$g9 wldLZH`l!O!9c)3w _;{ ;SCȻONEo1-{|U_ ])>.($H6 vHh JF/*vv$ N4qg"aAa1č "S+IJu3Z!'D`e31a+dL BHlӓ=O"lxMe566RDQ'hyf!B-HS8B|zwgXlC4K6UbksD64E r#.&(GuJIb®˚o-Bo)=koS&&׶ =C6^鼍;IX;P cG;jQN~}YÝ/` &띂)|U+1?`H]22r$o,+3B9HBx !dt" UQAc7Lh0b3(!qodیk(zX۴?5]`I"vVK7 ^HLL8)5ڀM4o9;4T6c[rC noVl1ttE5EgJ_Ě/vYsֶ61/2ZQA&%]++.Id"\*z TixX8He(oaAM*$vzq,s1+0G3WW;>XxY崾Hfl*޲/1qS}kh u|!CH7VOLZR2I{&kH/!0@ qLTPd8ԑ灚!ooJ5LҕH Hې$ `[oC]:=?~W߭y"]"popUHkqiTBPgMq 1 t/5*b0E97 B31;nS4xJSbVyΦD>^o H5 v/~X/m}4I84(Ek|^l &ྦZ;9ɔJhVk:zD"kl%Ϯs'lldHX |nPƢm7dLi2\Ok6ɫh|Ɗ|iEetbvOH*(W B T :8I@hrvЩQ%,\/䆶߿/_c03^Eϱh}_P+4Q@t⚹͟)ev)[D[ѓXF[hj )Y"*Ԏa]>a4>-b|?YFY~׹n5h=NM#RӞ pd[խ"Q:lG]yo~$'h Hg֯l;븝?2IC&ì_~wܹjAU-Tq%iA j9-%,H;;q؆mҨ]sOzx)r /DL7kPn޹sHI^\ 7PDJ2RtSe ʧ[hrLRvƘp| ,]hY{)J|= ;gqXfﺝ7uϕ:n}1˜Ɖ$S+JgĞg2^lh `X w@Hl_8gu~ʅ3{$/}sJwF>XpD/i۔)ݻ'AJS90 n:3%\9է'S}|lCL~3Z3ƙ^E!bjh'=.؄(2Pv[AR76AWARjNV`5Յ%rnEi+nxiDy:pc^Ag9lJOC2Y tadăvRMCcVωx$?sxyΙۜB~1#K g'a 7="SWӯȩgJ#V#W)bn蜰 p,ԢBQJG5YK"FE4wN5YA)6%SXb\َguoCλgG^آ# hqp+E HRnƎSütz&f@ [OIesA12Z 'VTBr8_&")tCP/Y3c?zɢB==tv=FꨥP0g6mJH.{o~p76k@wM!!xl[ d~3O(`+0gZ}:B֖ \vְ hs\r=_\4Cym o֕)J/<o,v~%vƧྰ]֐/}S98zD2gŗ_sd_'GϞ>?ƈD|G:$HnB\3ȥnCn QcD᤺;T\hdK*7<6ɄTtlfqb]MVX;8} p\e>+[&ԒMiަyTDi 7x`GexD?/'nqyK趨{?ohǫ3M]HQ #Ҍg)1.9b/%I=5hSc>}TI xX#'O(V%Bhb]*JAԓcqiω!n TgO2($wfbGcF,DLj3S.b}POf' ?~0$ZUv7w& > #Pɒݦۜ5SA90{neyt>YZq s21@%V%$)PAOLOu+dPAJĀ eMȴQᐺZjzƹl+2Ooe+&"qZbI\rHXQOgE;2W0>7|5DxU{ oy?2Ġ:(U~P\-wc:uGX#ǁH*M{2C(Uۏ.Ցܗ!j-wWĭGH38>a__6 ɯÚ! 1tgHX_6R8{ŻWЮoa[QR#Ex}1^m`4lF 蒑H._]@[pi@?Zy)6H.]U9Q7\ߍ!KrXDyAf 7P`J M ^ ߋ3ER\N*ՅiAZHi.$;ƾ=T FD(G6JyX\nE4/G.Chrb_e MW0AS3 +k-cZVTMp۩@lf,q_@o:ѻ;B1f 2tse]:ѹ1#{_7ܭ\md2ȃ-HJtmtNѧCwLR~5yWˋf[:ѿȴjݩi N $=%D2Sn$!x$<u @"XqbYG^S2q+(JkbtkmQ J +dETпHq'%Pu(XMWQ{ ⫌nGa"6=宒oyVbpG34tZ[R`zC{Oѧi){e5ݥ/|@K:[[E|NB= PFvr84ѴhuN<xNOO?a|Z!j?:WҜI{X覩NJ nW9~(ޝ/{Lo(qE(lA!QU{NTlw2 O6%'^Kiu}$5S>ȩ@֪Mr0xqPjeɋT1[}>-Xa}vwx/k:mIJ4Azoz_fsJ|~' {~ew NܨJMP矼凜w%mZӹU,hK1'eP,H)-e\Ptru=M2oet@!UH"3ڋVx(4WIMD|[uNf#]˚0HQ*(pKL"kU,|% J?ջ0h䔃¶ֹ0\Mč.vt0s˃HVm]N DaDsW$Mb>bfbc7cG&9 $fZPN.?=Ki*!br+jۅ~Ï`FsXDsuG=g0FZ'oU[P-&v=V@t-ȝǔZimR@rZ3|U4i#778wR|G[ujCNz <anxIpK["r#7zO qa-/4AWG' 1F%wS1QHK YS,Ĺuwϋ{$22y/_%ih59iq0gqgERK 'HOTE'RJ点]I畜&Dq׶9;EǞ݇;5'CtP>z t(|yi_6* ۀ72%ܢ s gM-ݗB%{kLsmyUAQ}~Z6`K7xz"PgaP>hTU|Z24=YɡohMd뜵IҨXɽo[q-NDʼn #hVFz8٦ʊ rRS&Z N63bcrT0Joևݪ;Wuzy!jÉdrf<n(I Xif?<.r}ܚaPKo}e}\L3]6MSNU4yeq4A̖EuC9HFf[ι [d@P5|?UBwgiKkfx &\oN}sKԆ}kč-0/85 ':5|n $fKE3x\ A3x8zȉVIsMڜ $%zM9HvvN榿w/RiW]?Wrlއu98_& .Nx8/ϣc@IZ]6;xM(S7>d!2x|)>  V3ASHn)$%޳nP+yewΑ4Ѳ R!!M')d#S`ACSW*&u㻁nԍZ_vY5 ;IH8P[HG5-̑R>lSאΪNerVnQ.!;D&˪AQ h: [Pam}μ:K"8WmZe3ǽ 4bӾ[Aa+a :}~$ }D])7 7h[1LhZiuf &@ືรSUοPqRt:wޒǩl|0Ǐd9V S_$zI(j0i8HM +Ήͬ/FshZLSu Q<{[W\GܚWG2VPF+N)˜T,loxtO0ek)#jwS̶m9 MT{AS%.EH^ŚH|* WB& 3=o:۽巽)'XsV6tWd]q:*`:{HPu=k4I֚AmWxEJ1ݛ>wlD/ò4vI"RgY|-S~|T eH*\\- њ I(2f3o1&Ql|0΂Bk]0huG\9(H7ڑčTNDNC@Ւ0ZHDŽzԚ,CgΏsDEn3+?]GH;Hn4vKPgI[;=Η ,"go{MtMSEkb>Ve?uxi ȅ2I6XM8}7C xh100644 emit.goWV۩#૴n976100644 extract.go(U 7100644 extract_test.goGvH\TA'V40000 testdataq῍#XQHvJb<;6-1Jdxs100644 doc.goE7|O. '100644 jsonenc.go6`,yJ6Z׳zX100644 jsonenc_test.gomYv:m3A*\,`x?x$Vq =rb.} J^~ y9 % ): Q UJmc]gxI'˶ Z{Tj'LהAx}Vn6}bV}sqࢉxE\k%ZemG %=3M$:H̙3TVLf9ȳxsrv+;[vkb/mTwy,?|1uAy}jEY)z{ys.N/_:EU 6~4F:Pl4Xf)ZIѵA&ClTʵ`sCZMKWDr=~bMcm(饃K*B؞81G[XeZim#-k5;\8hmI=`Fbstk`Ӷ>J!+OUc-Eyl˺(ʆj `]S5dlmBބF-ʻ TZ7!, fGD͑ ίȋlnuT܅9[elp֙NtC[yyvq}uyvA7Hv(" S)iNI7 +$.#l1@/>4ԠAl6(y P+_r'֢ G*ry *l]3G Tl\6֨.ub@FR3g>h_/nHUfByGNoMz,Fy/;;N@gXu8kx`BcR;T,})ߤVT `/ +oI8|ByԞ͖)< ccu/37N:gDU^,uUh!Uo+*zb' %hBJ| cF'fU.RbI?0gTٜΏ>$3B'92@v߷џ㩅&XbŁ|~"-!1 N.#=8%ShʯI09Nuɲ@ TY# F0, <.qݻ)NBt◧Iotr{B4 H.%fxS.tqs󦐢|*"pT@~qP`K^j|r곱`4<Ůjz{+~">EQs\Y\Kk:9!%l4:SlPiva_Ä?6⪆[\kt1HM~EEAn;N Λᓃ,K̿J-G>I`\aZ C'eMxeT]jG+h@l*"Ȼ?` ?H`陮4kZX  o`I U=-y%"4]_WW߫i0E@B Em׏?OWowQi _gXU(@018KzxH(:=Eڬ Κ0޹¹:xǞcrv]h&k0-+P@3mj",#re&Wk ?8Kd`36  '*3 (T]̵9r,$ߙbi"=$_mz0dC7,[[ G%Y!xAHe.KA~I9a;Юr@Zʺ ;3TWv.-/baϞ :w; r f;\ڥDsxTAJ lz.s0y{j<ŕ;y34ŢR/ps2km62v 伛ir36D*m:(cEG1$u2Ut!&rSTҮ q#Jl*h(ZYL,b _dRIHaGaԇ=SC뱕vyn($?~.c{E&dNppɾgUf0F?T[%]V`Si_1s=5%⤈ޙ=5j]teJ_O|4߽Y[=Cb![pI:bo\S&+n0;^/L011jګ6&n o"pCXp)ZdN ,j$4g*uѓ=`L$PTy_&GCҨCUܨO{8U*pIELg"d8?L'L"wWl!)BQ%mA'=25@A0Gh n]y8)f`%Wp " 2҂w>' ϙU;s+LXLOLRAREiV}kL!ш++4AlY#cw/G@ 7ps﹍~l瑎\P"܈n5[ħX:Oà.'膑LtZ6)%m qgbltqEcSLJGk2:Z,:UkSo_kIzT*تu\oY:J1A0>qӬ4Y)o*ÉP^ef t2$y4*EYJG]3JҍC-PU`-.=ӴU(gTYתMa~}Ue #چCHb#ȇ¡sR?Dh[Q4@K[AjiAn{b{\$)s Ia؁Ź&$Im)]XY3g<$sCu\ f4,6Rmꇵ`MFd2ݚMwLcQ]55>+@r5;qqriC%fڦ @M*Y/t2I5פn!QccD<2eU(s:kj]r5Z$"2$o8}(}y8'\BMW̅ )":=&r1>+ }vㅱ]11) Ƀ避~9pC>[(iX;%TQ;5;^s+Q%hn>(D[k?uз /;0Eϓs^TxTI5kaW>"RV_`;~T,ĩ8su~nA)R,tQeqamN}+, #eW- tմRV4BdL R,Aln!\;}ÍN2hUjײ+ďv 9DsdyJwN;bSW~U?״՘\p 2?Җ+/WoEa^9L!Ec2yBD/5N0|.}vQ7B5Fm{j$=}%?(9I.Z{^'\BΐH`%EN5Ji]ۋ ?FrFmNz.omrHM::Sߚͦ_D¨ ̥ϜMH=7"|M0Ki2Ig( 9{θKeiNvݳ4JD=0WeʼnT|G@ v+F4CWUROjAbbl'm DC Dg^cMĚLGn7ḃOs E3* k|:`etĂ@C:⫴Thڢғmyo%JYB/6L\:F56t_H/zcf3>(='0^~,OD,IpT86 ltgUm`nPV=P  o^Z~k0b*sJ0(Tpi-kJM8uvZ [ş<}.OQ˷KoԔiPV,BW坂fEطuL2\jg<$6-7|1Y 4^U1T|j]1utK=1V(\%y5tc<{9awpr g+D^,cZ8v0A D?D}u0?/5&;@f_AӅ?ʹ':C0 E<0*6[™W}_+ ^|o!O_%#ϟ(!/Q#xXr+nًdvf%(]JM tcQ8S )%9 )'Yd!D?sN?_N&qr5̚5VAՃAB8(T&7MVԵ4m_nUI-T3Lk$kZ4ʔ>TC"7u#sj撴$ lÙӅAwYds2SB3r{fA&*e' rk S0w `pt'f ?J)1}t+#+"JPŅIMSAVB!˘e] OuW5I)eHFZ cRv\q6%2<_V/W#kK KYB۬asYKOn0VHVWEv+ ɶ/xc>AU]J:eiFѣ=o|,DbQ*e,mz#e-lDے1J&g/rJI* yZfUi+J P;3S%ȕ#_|l3Q!\A(+'!Cf67&ʹvZ &G4_{k 9={'8*37+$'I2Ax7H!Dj% |Lo$,]%5+eBbFnL+ӒNĚ̌T3"- k+ $Jwޥv|ېPr)+s.5R_*0Dݫ` Zp3 I@G,tbV1'|& Q57=ovv!E9rlWȽa%ɟqJȶhە, qzv ZpLFp 96M4Ԇ'T8XowS9:B̻uot7moL䯇8W70W~*YCv8G*N곜AYv(;(ެ.pWvlYˠy\?fs S!L՜ T#[8ёiLCH&wo!&b[Ji1WJ1%M-w钸h'$>lKYK[qnfqWv k"kR#-[x6n".*sI {6DfEs gz: H.Y>[:BCX1]x%p,$J,zZ]8ސ>:~!ӛ+u();%BrXըgO'#>oqӔ Cpt=cl%> |cUaZJg ~qw I(O!r:(k,Zn8,2LhOã!ps.:\J \qyqD4xDHsAo! MA.a7P[Hː`4L~xb?} h& I~'}1ŴKڕ6w94d/k+TРxH%/G#oA@ վ<8S|  (ƅ-K0u@:o1)^G*\^DWUb2.)+'LM X ̔ӵ'6ByZYЎ; &7_t~M_}· - ` gpg0~[kkԣlRgJ:O7Ua" V4ߎ2X/P1 *Bf7{Ӭ4Ƃ1^J[LQ)jF<#*E1~\Ɂ #4hf6='[2u C0"3t^ XJg"Z 0V -te=1 V9?+9o dgyTGV}(߳D -j54"1y]$ <Ḫ( O k8KF/_Aȸhn j/&\,CGyw3r$d5ΧYh~irsfgOR p' iLG_7`xKŐ\ZN*e$@ipSŃoqx~Q}SVfE/MxuE# zip zip is a Go web framework on fasthttp. You write an operation once, as a function with a typed input and output, and zip serves it as a REST route, an OpenAPI operation, an MCP tool, a CLI command and a call other services make over ZAP. ## Install ```sh go get github.com/zap-proto/zip@latest go list -m github.com/zap-proto/zip ``` ``` github.com/zap-proto/zip v1.36.48 ``` zip needs Go 1.26.8 or newer. `go list -m -versions github.com/zap-proto/zip` lists every release. A copy taken from an old module cache may be many releases behind; see [Upgrading](#upgrading). ## A service in one file [`examples/local-service`](examples/local-service) stores notes in SQLite and has one operation. This is its `main.go`: ```go // Command local-service is a zip service with one operation, backed by SQLite. // // The operation is declared once, in New, and every interface below is derived // from that declaration: // // go run . serve # REST, MCP and OpenAPI on 127.0.0.1:8080 // go run . notes create --text "buy milk" # the same operation as a command // go run . openapi openapi.json # the OpenAPI document, written to a file // // Notes are stored in notes.db in the working directory. package main //go:generate go tool zipdoc import ( "context" "database/sql" "fmt" "os" "github.com/hanzoai/sqlite" "github.com/zap-proto/zip" ) // Note is one stored note. type Note struct { // ID is the row id SQLite assigned. ID int64 `json:"id"` // Text is the note as written. Text string `json:"text"` } // AddIn is a note to store. type AddIn struct { // Text is the note body. Text string `json:"text" validate:"required"` } // Store keeps notes in one SQLite file. type Store struct { db *sql.DB } // Open opens the SQLite file at path, creating it and its table if needed. func (s *Store) Open(path string) error { db, err := sqlite.OpenDB(path, nil) if err != nil { return err } if _, err := db.Exec(`CREATE TABLE IF NOT EXISTS notes (id INTEGER PRIMARY KEY, text TEXT NOT NULL)`); err != nil { db.Close() return err } s.db = db return nil } // Add stores a note and returns it with its id. // // Example: {"text": "buy milk"} // Response: {"id": 1, "text": "buy milk"} func (s *Store) Add(ctx context.Context, in *AddIn) (*Note, error) { res, err := s.db.ExecContext(ctx, `INSERT INTO notes (text) VALUES (?)`, in.Text) if err != nil { return nil, err } id, err := res.LastInsertId() if err != nil { return nil, err } return &Note{ID: id, Text: in.Text}, nil } // New declares the service's operations. It does not touch the database, so the // OpenAPI document can be written by a build step that has none. func New(s *Store) *zip.App { app := zip.New(zip.Config{AppName: "notes"}) zip.Post(app, "/v1/notes", s.Add) return app } func main() { if err := run(); err != nil { fmt.Fprintln(os.Stderr, err) os.Exit(1) } } func run() error { s := &Store{} app := New(s) // `local-service openapi ` and `local-service declare ` write a // projection and stop here, before the database is opened. if done, err := app.Described(); done { return err } if err := s.Open("notes.db"); err != nil { return err } if len(os.Args) > 1 && os.Args[1] == "serve" { return app.Listen("http://127.0.0.1:8080") } cli := app.CLI() cli.Out = os.Stdout return cli.Run(context.Background(), os.Args[1:]) } ``` Start it: ```sh cd examples/local-service go run . serve ``` From a second terminal, call the operation three ways. Over REST: ```sh curl -s -X POST http://127.0.0.1:8080/v1/notes -H 'Content-Type: application/json' -d '{"text":"buy milk"}' ``` ```json {"id":1,"text":"buy milk"} ``` As an MCP tool: ```sh curl -s -X POST http://127.0.0.1:8080/mcp -H 'Content-Type: application/json' \ -d '{"jsonrpc":"2.0","id":3,"method":"tools/call","params":{"name":"post_notes","arguments":{"text":"call the bank"}}}' ``` ```json {"jsonrpc":"2.0","id":3,"result":{"content":[{"text":"{\"id\":2,\"text\":\"call the bank\"}","type":"text"}]}} ``` As a command. It runs the handler in this process, against the same `notes.db`; zip's log lines go to stderr: ```sh go run . notes create --text "water the plants" ``` ```json { "id": 3, "text": "water the plants" } ``` One handler and one table produced ids 1, 2 and 3. The OpenAPI document needs neither a server nor the database: ```sh go run . openapi openapi.json ``` The `/v1/notes` entry, with its examples removed: ```json { "post": { "operationId": "post_notes", "summary": "Stores a note and returns it with its id.", "description": "Stores a note and returns it with its id.", "requestBody": { "required": true, "content": {"application/json": {"schema": {"$ref": "#/components/schemas/AddIn"}}} }, "responses": { "200": {"description": "ok", "content": {"application/json": {"schema": {"$ref": "#/components/schemas/Note"}}}}, "default": {"description": "refused", "content": {"application/problem+json": {"schema": {"$ref": "#/components/schemas/problem-details"}}}} } } } ``` `go generate` rebuilds `zipdoc_gen.go` from the doc comments, and `go test` checks the operation over REST, MCP, OpenAPI and the CLI. The directory is its own module, so the SQLite driver (`github.com/hanzoai/sqlite`) is not a dependency of zip. A copy outside this repository drops the `replace` line from its `go.mod`. ## Projections Everything below starts from the one declaration `zip.Post(app, "/v1/notes", s.Add)`. ### REST | | | |---|---| | Declare | `zip.Get`, `zip.Post`, `zip.Put`, `zip.Patch`, `zip.Delete`, called as `zip.Post[In, Out](on, path, fn, opts...)`. `on` is the `*zip.App`, `app.Group("/v1")` or `app.With(middleware...)`. | | Input | The JSON body (GET, HEAD and DELETE have none), then fields tagged `header:"X-Name"`, then the query string, then path parameters. The URL wins. `validate:"required"` refuses a request without the field. | | Options | `zip.WithOperationID`, `zip.WithSummary`, `zip.WithTags`, `zip.WithStatus(201)`, `zip.WithResponseHeader`. | | Untyped routes | `app.Get(path, func(c *zip.Ctx) error)` registers a route with no operation, so it is in none of the projections below. Use it for streams, protocol upgrades and non-JSON bodies. | | Tests | `app.Test(httptest.NewRequest(...))` serves a request without a socket, including `/mcp` and the OpenAPI document. | ### OpenAPI - `GET /.well-known/openapi.json` (`zip.SpecPath`) serves OpenAPI 3.1. `app.OpenAPISpec()` returns the same document as a map. - `app.Described()` writes a projection when the binary runs as ` openapi ` or ` declare `, and reports whether it did. Call it after registering operations and before opening a database, as `run` does above. - `zip.Config{OpenAPI: zip.OpenAPIConfig{Title, Description, Version, Disabled}}` sets the `info` block or turns the document off. - Every operation declares a `default` response: the `problem-details` schema under `application/problem+json`, or `oauth-error` at an address declared with `zip.OAuth`. SDK generators type errors from it. - `GET /docs` (`zip.DocsPath`) is a Swagger UI page that loads its script and stylesheet from cdn.jsdelivr.net, so it is blank without network access. The JSON document needs none. ### Doc comments `cmd/zipdoc` copies doc comments into the OpenAPI document, the MCP tool list and the CLI help: ```sh go get -tool github.com/zap-proto/zip/cmd/zipdoc ``` Put `//go:generate go tool zipdoc` in the package that registers the operations and run `go generate`. It writes `zipdoc_gen.go`: the handler's comment becomes the description, its `Example:` and `Response:` lines become examples, and field comments become schema descriptions. In CI, run `go tool zipdoc -check` in that package's directory. It fails when `zipdoc_gen.go` no longer matches the source. ### MCP Each operation is a tool named by its operation id (`post_notes`), with its input schema as `inputSchema`. GET operations carry `readOnlyHint: true`. `app.MCPTools()` returns the list in-process. ```sh curl -s -X POST http://127.0.0.1:8080/mcp -H 'Content-Type: application/json' \ -d '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-11-25","capabilities":{},"clientInfo":{"name":"curl","version":"1"}}}' ``` ```json {"jsonrpc":"2.0","id":1,"result":{"capabilities":{"tools":{"listChanged":false}},"protocolVersion":"2025-11-25","serverInfo":{"name":"notes","version":""}}} ``` What the HTTP door does: | | | |---|---| | Transport | `POST /mcp`: one JSON-RPC message per request, answered with one `application/json` message. | | GET and DELETE | `405 Method Not Allowed` with `Allow: POST`. There is no SSE stream; a request that accepts only `text/event-stream` still gets JSON. | | Sessions | None. No `Mcp-Session-Id`, and nothing is kept between requests. | | Batches | Not accepted. A JSON array answers `-32700 parse error`. | | Notifications | `202 Accepted`. | | Methods | `initialize`, `server/discover`, `ping`, `tools/list`, `tools/call`. No resources, prompts, sampling or logging. | | Protocol version | `initialize` answers the revision the client asked for when it is 2025-06-18, 2025-11-25 or 2026-07-28, and 2026-07-28 otherwise. | | Tool errors | A result with `isError: true` and the error text, not a JSON-RPC error. | | Origin | Not checked. Bind a local service to 127.0.0.1, as the example does, and serve anything else behind a gateway. | [`examples/local-service/.mcp.json`](examples/local-service/.mcp.json) registers the running example with Claude Code. The official MCP clients connect to it, list its tools and call them: the TypeScript SDK 1.30.0, and the Python SDK 2.2.0 through `initialize` and in its default `auto` mode. `zip.Config{MCP: zip.MCPConfig{...}}` has `Disabled`, `Path` and `Addr`, which serves the same tools over ZAP with no HTTP listener. `app.MCP` is the door itself, a `zapmcp.Handler`. ### CLI `app.CLI()` returns a `*zip.CLI` that runs operations in this process. Set `Out` before `Run`: ```go cli := app.CLI() cli.Out = os.Stdout err := cli.Run(ctx, os.Args[1:]) ``` A command is ` `: the first path segment after the version, then a verb from the method, so `POST /v1/notes` is `notes create`. Path parameters are arguments and the other input fields are flags. `--help` prints the doc comment, the flags and an example: ``` $ go run . notes create --help notes notes create [flags] Stores a note and returns it with its id. POST /v1/notes Flags: --text string Text is the note body. (required) Example: notes notes create --text "buy milk" ``` A client that links none of the service builds the same commands from the served document with `zip.CommandsFromSpec`, and sends them with `zip.Remote`: ```go remote := zip.Remote{Base: "http://127.0.0.1:8080"} spec, err := remote.Spec(ctx) if err != nil { return err } commands, err := zip.CommandsFromSpec(spec) if err != nil { return err } cli := &zip.CLI{Name: "notes", Commands: commands, Invoke: remote.Invoke, Out: os.Stdout} return cli.Run(ctx, os.Args[1:]) ``` ``` $ go run . notes create --text "sent over HTTP" { "id": 4, "text": "sent over HTTP" } ``` `Remote.Header` sets headers, such as `Authorization`, on every request. ### Calls between services ```go conn, err := zip.Dial("http://127.0.0.1:8080") if err != nil { return err } note, err := zip.Call[AddIn, Note](ctx, conn, "post_notes", &AddIn{Text: "over the call plane"}) ``` The caller imports or restates `AddIn` and `Note` and links nothing else of the service. A refusal is a `*zip.HTTPError` carrying the callee's status. `zip.DialApp(name)` dials the unix socket at `zip.SocketPath(name)`, which is how services on one host reach each other. This body is ZAP, laid out in the order of the struct's fields. **Add fields only at the end of an input or output struct.** Reordering, inserting or retyping a field changes the wire and breaks callers built against the old layout. REST and MCP bodies are JSON, where field order does not matter. ### SDKs | Target | How | |---|---| | Go | `app.SDK("notes")` returns a `*zip.SDK`. `Source` is a package whose `Client` (`notes.Dial(addr)`, then `client.PostNotes(ctx, in)`) uses `zip.Call`; `Gaps` lists operations it could not express. | | Rust, C++ | `app.RustSDK(crate)`, `app.CppSDK(namespace)`. | | From a schema | `cmd/zipgen` reads a `.zap` schema, not Go code. `zip.ZAPSchema("notes", app).String()` writes one; then `go run github.com/zap-proto/zip/cmd/zipgen sdk -schema notes.zap -lang go -pkg notes -o client.go`. `-lang` also takes `rust` and `cpp`, and the other subcommands are `mcp`, `cli`, `docs` and `zap`. | | Other languages | Generate from `/.well-known/openapi.json`. | ### Errors Every refusal is an RFC 9457 problem document under `application/problem+json`: ```sh curl -s -X POST http://127.0.0.1:8080/v1/notes -H 'Content-Type: application/json' -d '{}' ``` ```json {"detail":"field \"text\" is required","status":400,"title":"Bad Request","type":"about:blank"} ``` - A handler returns `zip.ErrBadRequest(msg)`, `ErrUnauthorized`, `ErrForbidden`, `ErrNotFound`, `ErrConflict`, `ErrPaymentRequired`, `ErrUnprocessable`, `ErrInternal`, or `zip.Errorf(status, format, args...)`. `&zip.HTTPError{Status: 409, Code: "taken", Msg: "..."}` adds `code`, and `.With(map[string]any{"cap": 5000})` adds members beside the standard ones. - Any other error is a 500 whose `detail` is `err.Error()`. Wrap errors whose text a caller should not read. - An address declared through `zip.OAuth(router)` answers RFC 6749 `{"error", "error_description"}` under `application/json` instead. - `zip.Config{ErrorHandler: ...}`, a `fiber.ErrorHandler` from `github.com/zap-proto/fiber/v3`, replaces the writer for every refusal. - Over MCP a refusal is `isError` content; `CLI.Run` returns it as an error. Problem documents arrived in v1.32.0. Through v1.31.4, v1.18.x included, a refusal was `{"status":400,"code":"...","error":"..."}` under `application/json`; code that reads `error` reads `detail` now. ### Security zip validates no tokens. It reads identity from headers set by the gateway in front of it, after the gateway has checked the Hanzo IAM token: `X-Org-Id`, `X-User-Id`, `X-User-Email` and the others named by the `zip.Header*` constants. `zip.CallerOf(ctx)` returns them in a handler. A service reachable without that gateway in front must not trust these headers. `app.Authorize` installs one rule that runs for every operation after its input is decoded and validated and before the handler, however the operation was reached: REST, MCP, `zip.Call` or the in-process CLI. ```go app.Authorize(func(ctx context.Context, op zip.Op, in any) (zip.Decision, error) { if zip.CallerOf(ctx).Org == "" { return zip.Decision{Effect: zip.Deny, Clause: "org", Reason: "no org on the request"}, nil } return zip.Decision{Effect: zip.Allow}, nil }) ``` A request to the example without `X-Org-Id` is then refused with a 403: ```json {"code":"org","detail":"no org on the request","status":403,"title":"Forbidden","type":"about:blank"} ``` - `zip.Deny` is a 403 with `Clause` as `code` and `Reason` as `detail`. `zip.Approve` holds the operation and answers 202 with a `zip.Approval`; a Go caller reads it with `zip.HeldOf(err)`. A returned error aborts the call. - The in-process CLI has no request, so `CallerOf` is empty unless the context was built with `zip.WithCaller(ctx, zip.Caller{Org: "acme"})`. - `app.OnResult(fn)` is told the outcome of every operation, for audit records. - `CallerOf(ctx).IP` is the socket peer. `Config.TrustProxy`, `TrustedProxies` and `ProxyHeader` opt in to an address a trusted proxy forwards. ## Testing `TestEveryOperationIsInEveryProjection` in [`examples/local-service/main_test.go`](examples/local-service/main_test.go) reads the router and checks each operation against the OpenAPI document, the MCP tool list and the CLI, so an operation added later is covered with no change to the test: ```go for _, r := range app.Routes() { if r.Op == "" { continue // an untyped route has no projections } op := spec.Paths[zip.Template(r.Pattern)][strings.ToLower(r.Method)] if op.OperationID != r.Op { t.Errorf("%s %s: OpenAPI operationId %q, want %q", r.Method, r.Pattern, op.OperationID, r.Op) } if !tools[r.Op] { t.Errorf("%s %s: no MCP tool %q", r.Method, r.Pattern, r.Op) } if !commands[r.Op] { t.Errorf("%s %s: no CLI command %q", r.Method, r.Pattern, r.Op) } } ``` ## Upgrading | Version | Change | |---|---| | v1.32.0 | Refusals are RFC 9457 problem documents under `application/problem+json`. Before, `{"status","code","error"}` under `application/json`. | | v1.36.48 | The OpenAPI document declares a `default` refusal response on every operation. MCP `initialize` answers the revision the client asked for. Doc comments reach binaries whose handlers are in package main; before, they did only under `go test`. | v1.36.21 is retracted. ## Repository | Path | | |---|---| | `examples/local-service` | the service above, a module of its own | | `examples/hello`, `examples/zap-typed` | smaller typed services | | `examples/sse-streaming`, `examples/websocket` | the two untyped routes, each saying why | | `examples/migrate-from-chi`, `-gin`, `-beego` | existing apps moved onto zip | | `cmd/zipdoc`, `cmd/zipgen` | doc comments; code generation from `.zap` schemas | | `middleware` | `Recover`, `RequestID`, `Timeout`, `MaxBody`, `CORS`, `RateLimit`, `NewBreaker`, `ProductionHeaders` | | `wsx`, `js` | WebSocket upgrades; JavaScript and TypeScript handlers run in goja | | `LLM.md` | notes for changing zip itself | ## License MIT. See [LICENSE](LICENSE). ^zxFpackage zip import ( "bufio" "fmt" "io" "net" "net/http" "strings" "testing" "time" "github.com/zap-proto/fiber/v3" ) // serve starts the app on a real socket. That is the point: fiber's in-memory // test helper collects the whole response, so it cannot tell a stream from a // buffer — the one distinction these tests exist to make. func serveStream(t *testing.T, app *App) string { t.Helper() ln, err := net.Listen("tcp", "127.0.0.1:0") if err != nil { t.Fatal(err) } go func() { _ = app.Fiber().Listener(ln, fiber.ListenConfig{DisableStartupMessage: true}) }() t.Cleanup(func() { _ = app.Fiber().Shutdown() }) for i := 0; i < 100; i++ { if c, err := net.DialTimeout("tcp", ln.Addr().String(), 50*time.Millisecond); err == nil { _ = c.Close() break } time.Sleep(10 * time.Millisecond) } return "http://" + ln.Addr().String() } func streamApp(t *testing.T, h http.HandlerFunc) string { t.Helper() app := New(Config{DisableStartupMessage: true}) app.Group("/legacy").All("/*", AdaptNetHTTP(h)) return serveStream(t, app) } // Every streaming handler opens by asserting http.Flusher. func TestAdaptNetHTTP_WriterIsAFlusher(t *testing.T) { base := streamApp(t, func(w http.ResponseWriter, r *http.Request) { if _, ok := w.(http.Flusher); !ok { http.Error(w, "writer does not implement http.Flusher", 500) return } fmt.Fprint(w, "flushable") }) res, err := http.Get(base + "/legacy/x") if err != nil { t.Fatal(err) } defer res.Body.Close() body, _ := io.ReadAll(res.Body) if res.StatusCode != 200 || string(body) != "flushable" { t.Fatalf("status %d body %q", res.StatusCode, body) } } // A frame written before the handler returns must be readable before it returns. func TestAdaptNetHTTP_FramesArriveBeforeTheHandlerReturns(t *testing.T) { release := make(chan struct{}) base := streamApp(t, func(w http.ResponseWriter, r *http.Request) { w.Header().Set("Content-Type", "text/event-stream") fmt.Fprint(w, "data: first\n\n") w.(http.Flusher).Flush() <-release // still running fmt.Fprint(w, "data: second\n\n") }) res, err := http.Get(base + "/legacy/sse") if err != nil { t.Fatal(err) } defer res.Body.Close() if ct := res.Header.Get("Content-Type"); !strings.Contains(ct, "text/event-stream") { t.Fatalf("content-type %q — headers must be set before the body streams", ct) } got := make(chan string, 1) go func() { line, _ := bufio.NewReader(res.Body).ReadString('\n') got <- line }() select { case line := <-got: if !strings.Contains(line, "first") { t.Fatalf("first frame %q", line) } case <-time.After(3 * time.Second): close(release) t.Fatal("nothing arrived while the handler was still running — still buffering") } close(release) } func TestAdaptNetHTTP_StatusAndHeadersSurvive(t *testing.T) { base := streamApp(t, func(w http.ResponseWriter, r *http.Request) { w.Header().Set("Content-Type", "application/json") w.Header().Set("X-Trace", "abc") w.WriteHeader(http.StatusTeapot) fmt.Fprint(w, `{"ok":1}`) }) res, err := http.Get(base + "/legacy/j") if err != nil { t.Fatal(err) } defer res.Body.Close() body, _ := io.ReadAll(res.Body) if res.StatusCode != http.StatusTeapot || res.Header.Get("X-Trace") != "abc" || string(body) != `{"ok":1}` { t.Fatalf("status %d headers %v body %q", res.StatusCode, res.Header, body) } } func TestAdaptNetHTTP_SilentHandlerStillAnswers(t *testing.T) { base := streamApp(t, func(w http.ResponseWriter, r *http.Request) {}) res, err := http.Get(base + "/legacy/q") if err != nil { t.Fatal(err) } defer res.Body.Close() if res.StatusCode != 200 { t.Fatalf("status %d", res.StatusCode) } } func TestAdaptNetHTTP_PanicClosesTheStream(t *testing.T) { base := streamApp(t, func(w http.ResponseWriter, r *http.Request) { fmt.Fprint(w, "partial") panic("boom") }) res, err := http.Get(base + "/legacy/p") if err != nil { t.Fatal(err) } defer res.Body.Close() done := make(chan struct{}) go func() { _, _ = io.ReadAll(res.Body); close(done) }() select { case <-done: case <-time.After(3 * time.Second): t.Fatal("reader stranded after the handler panicked") } } 7xVn6m?ŭ`r~ nRk@a(L$U'M !{{%'v7݀"S~#Y]s _= ҇nWͭqn'R&«_`BS--}szff"u&>扺n߇)saXH輒X=R A `&$c*$=Nxڮ~1Goџ%6,*k[*+Hp!.*Y/;i)A 'v})̛ڥ "i¿98vݎtxX.bB_(/fBmH\-=ޘ!XP̳^vwMu8}P& s$^$wGvz`XԲCftT>Pf&3QUq^Xs[zd~~ ~'-'iA bHNۛRCz(i}\ΧI3S[,ejjd0<LGp4NL`%xv<0><|=~2oy  k\`.D䦉PуY`zxZo1d VC)Ere" +5#B\n|rVcBK XLud!* H*(' /CVxd8OCbwf1/B`]RD4Icu!W'8@fD7'4{$Q$h1 ͣ9ޖ ):*üy2gvأ}/J盽>s~=ס%Z& KX{<9rƒۂ+/m2xAN GzLxV8NEu:bE D}Ĵ5-:-ŷON]Ez*{鄊 g:NqX o"Qtm qRdk2JhL"VU VUՖpkS3g̋a ]vbKzWol:Jہbg|6k&vh͹m [8L,Usp;0!nLm7떻iolcp'9Ѫ&ݑ򕅒o!9ٚ}W_YJVl1KlNj#qJVOmf&8j:i}CQ j*\iЉ$5{`B>֍_/[ڲFokrs仴-ebY͈[QޗAbB>XcJLZ)}}-\.Ji*s_#V]+ ¿xZnM>x;#q"]-aHD#rFή(VЇIzΝRe7hŝ;wwRٙ^vUu;,*sYEiY'b3taצȯ +^;#5>Odt:ӉNP[69WY^)IfWUzIV%h[e3e^묯I>yQe' KcZjjj0+$XMq.c\rf4l\6*ɔbgURjSq8#RWΤ33>0zLQ%q1,Ldea 0r[3٩yn!̝%gwZzau;@y^dc YORv= |Cq! SfKK bx\5HOgh_E-Ow9|}{~2 ۹ХBx$~יe_C3[2\BWBҹƥ:W@4cà!<_l:~\[QDwuˍAuT/2܀Ζ#[* peXP၂Cp8+,/$tY q^e +҃?,?,$c8ԋ2];szq5m&=77 {"Y_l:UTy9Ea=T?v'( ~醢ybX* D.3\!': O">y$8)͌ $NT6a3ȘT[q<:Q @xZ|*woWr0vd"Q-!L4̪6z@s=-ɗ;0qh**5d%/ù@+[ϖsJŦ\,mؔaYΐBŅl"BݝSXv Bl/ R`7Ců[툷fTEOxFe0T^Z2CYYnn[:_zU櫜Wg`¨BZЖYMM#p"vX 5ȟ e^/OGGvOD*:v\j<*ǰ*dḺ)qcM< (Q-;]nR?G 4*[}+\}lN+B$0t]>~`(?d3bb~'oS],ͫz ${Z4$n(<иn'z[nCد.LvaҼ0/q/nhD$nR*wt_z0fahjz+GV$ &FƊt!hj\Iʪi% 1yr &ZYcX\ APN++r Kʁ7#Nfg 3ħP^#*|.o. :ϑY ڑv -ܝi[3q, 9v:Qf{%Mp%1ΜN"o*]nJ{0wUƊD 0)Ft1(͆t؄J1UBr^{ ?>p:gp`G({P'>U_؋v+#-ckK7Nˬkn +Z0NWBB`;݄wV *_gTis<u7RεIJy r@Jy?љǖ~0ϖi173Olp(~r!J @`M' Yd$H5.N6fpQLBAx50R )45q0DPrha%.sR E䚆R_IvlT-)S/1{I.Ȉk<4;Fu^),fpEb[0o.Lp7Ornj[4! 9:#< K Uh-a?9x!Y4kt:No&"Hrbm4z*aNXxvɚg ۆW8:(Eh&>LKۂarHoO ?{r@Ӵmj]JN𩛯bĜ>Q3+V"j0 nX n'/} DE;8z'߸=@'drVCVkMd'鉸=KmAy}2A>f7J*.=E]g&[4nìt35?臤JhE_VMHoσǫ*TTdnyLj?8h*z.ʙtDA==3g\2c32Y(5+ph[:Ƶ^)Fc)L6|vuAǥ<+}B2%l\ץsiVy氐hiv)Ι6~w.ę!^5G[}:icE!y]QvΩt vZ}ZZ8Sc8,3c\< i—kPHqMu\ڰBH,/dFj&@$☛4x[̩Fk)ŀ-TlQ ͻFsϱRM V;#P2A JF3]*\5k*'L0<͐ٔzT^v&|l u (GNHbP? U/qzR1Yj@7Ya\[^4j8d9 zG<78כ$`%7?p{u޹sw~~q^}z+U0^qu;η zܾ;;+=n4\HZs?mݼSuYw|/;*MHMnH:Wxm9)FF,bF A85nr'>_t2=E*O>=O7V;#x$s:ωL;2]X7ɚS LM<=L {z)C|}ۀPB @#7N⁚<NI=8{a#uS'SK{lbB-}8TF2KG!i=I"@e!q :TպC1tckfk(B>Q |Iqmk*t:cH!tĩ{1<)_vK|256zus\^(}KQn{?o 06iV#vy P @_}Q֤Tw ,bqԱjWl}HE5Զ炥lUs^/Z=՘?JxWQo~~tkB%@us9A\8# KҢtrRo=';37 k~ 8emOޑJm^᫩R;g+~[Q=|yb9KR[guc²z!5륧T7MniYVlwĭ/|\ГifK }qΖ85C̔;S$͐3w& zoT-˙i,׵|L==`Ƹe -k,]fOv.LFF&ѫ9T#Al~Y[ਜ਼5M7%O43Nõ B )GM@DЅi|(z&41NkrƨrL1*@޽Sm@1v9ib&g "!iFni\u4>yϗU)8>tOocm? 49fÍ˦߶k!ɣ,&_ N0*/5GL '_'} 9J~deƥM>3lAbZi$o FѭnsZXgbױ)~W?%y:eֳbM@z9+r`f<<+BTE5P4FϛJxR:Oֺ,Zx̥?ӣLZhwJwͲ̢g7_}{qyH -͘D://.o.dkm=vf1&8;3dso% ga$w(jͰޟ}X:oˏmݕc.%}Oo&wBB]4:emN̪ϟ<|>+])IysuudH"yT_}uqGç/rx8B ˹M(l}"u#4"+d_fS 5>"Wzq>U[?IAػ95UXm>0V1$_}V#yh3!VܤUi\BWq))8g'bW@yG 1r?Uk80 1} !n<,( 1pR 15bZP 뎉(7*D4H/bK8]:DLTeүN)ˇZXC%@ٹCOT@[:N:&vnc)UvE:n ^Η.CkV1eFGc§8C'@TuAO3Ɏrl$WwLڛ8]p9Jy "I9y sЬaSt,f5>ԃ~#pߣ 7bbSNR~ώBA3s~JPr-WCmmq܌޸xV#c6:]@4UZgWC_ } ~Nj.V8I&&O,'ϵ$wO:JNUR ?tm;G4~Ο;`@nAʑ/%KSI23OrQUҒ!+E^{-R$4?/xBi%FftmHΥ9\MP.7+i7o7K-' gWWw)9LBYAY{n)7MU 4,5:10Y ҝ o68.΄Jq)BQףlg eixB>e}lҏz>IJЭ^-%~Ыh_b?`yfLN뚳)d16N\91 GZ [c[|QSwΉB>j{xtԧHJ=Y>p(d7YI* c|{ jB_춍ͿjS>C6QoSpSK+2<@t3s҄N +J o/wm۪J ɧFe ()meFE5<:4ϭi@wfJbDʻ1"T|Y 9 e!DGk`^],q1wXaoN7AR\AMI_~"9nޤq{3[ KH{ġo킄 T>} zbFh Ю<pvp5=PBƌњ\`_Y'ŖCxoԕВJle3/fX%+9h.bJ@y 1؆q=|4hJ Aw/486s"OBzh?F_zg.1;~w/^0\F7j݄n0)]c09p2 ,ևo͘\|qNO!jWC{ Ą:&(T<5Um$]N%/*% Mi hx[!LlkFl"_"q3Uh 2xfn>&ĂǙLYS& Us-*r/JLIIPJ1489k((os5NtCM%f!jR^|PF4]JJ# h(*i%$8$=YtؼTR E-x>?(zip.Decision, error)Decision{Effect: zip.Deny, Clause: "owner", Reason: "forbidden"}, nil } return zip.Decision{Effect: zip.Allow}, nil }) if~(zip.Decision, error)8=Decision{Effect: zip.Deny, Clause: "shut", Reason: "no"}, nilXWƳxYr->ʩM.}IҩTqKigq=$b7V_yN0OJT3X칟\LΕ^9J-k{6BL)gNjK7E}މL-Wő ]:A(.kQ7UB^MBY5J !R i+#&ҩR%\-B-VA;:!0rڭWxceGV}B-i6)$Sy1%M#!r)fkqʞ\O񺐥50CQi+\ JPxoJ/A(\HO9U4XDN*E =l4$_6+JEYvd%|l)`Hmڪ$wը(wh )Ñ9ʀW!/u߉lzO?;i yrљ Ҹ~$@nrm3j1Jڕ6ӚVQ̂: NVD;W (@G8~Sʗ'h1NQd ^d73lt#1{דM`땪Ĩ[+"bR~QOkjW<{u˧orWӼųz;}ҫ YHv y-j@h&>{A E>+rƷD.8sצM0v`m l*`o)IsRacA;!I97#S)Xi[)渂pFGPNp+cNI XukQd}".YsAő4[w[ Yx/ DD+(mjSO+')ՌS%kxvÚͨҡ[ہHi ԋnk  !KGꞭB 78,]PȲ 7eD~ۿN_zeȡrZfa(+X~2Ca54gaJؔp0+}9BY *a&ƿ"m[ac{*R!Ӈ+)oTЇٺBJ&HL8jsBR|Tmp|}M0$AQ/B@~`+I êtH׹u~/h$?^)w9NwNb͉tM[voWї4NEw[ LHM9ID @$!| UyW,%5JSKlHp1N k++ K{B{@QMY"W4$ 8r9tNgDbnqꦏR)(| DZVZ%iGQ4}A| m\! pBLK#\@dZn0;mLJCh( 痜mǹ=şDB>`z mZGN"Λ[0nhkl6?/'w+-"}v!0p(bCd6tŶ@62hwW#cOV-LwZbAM5 ۀSȽA vCw\Q;Xg1LBZ˛>)h"&c&Rc0Q$zM-# XG:3P~?cQbG(Ӗ"#7J)F?1҄DŽ6AxѸS'I-R6j C5h+ X=.&!s*t%fkl!t)%_|K O, K>eK"}"3GѦCb3S/\v[amRɵr^U{!Pt1FT,ȱM)քA?|=# :?-`L?Xke x?=?ǓLY"a'A|˒t=iIc @%4)xٱ,lT1_`O' cai_-*ow.#E$е<)2l⻛Rl 0(XQ42ݬ`<.##Z6ay"s~x%e^}a's)}O$^p_!m^H݋<9xa~EKͥ]^:]t Z5;c._ش3 j&λVG~15[[|}k44+Sǡ"OC8T5Mya-3z2y'׵+of&ڕx.nLWU)YǺl~a*˙kgR[.l:qƉhC3UWmN`Ky&ٲ5Xe;,%UthDcUcě-+̇NPы5ٔk&*![`dtSO5n++_6vmZêW3[\{qkf+z6;l˖v-1vj:9.+sr~yy""Ss0j)+(+C;hub6]Evz>ÊOÎinch5Wfu>倬źMϝiܦuTT9qFQc.9^l nCchl>|l|AnӔ&Mۉ Z"Uvw3KUOX_q6ʵ&/bsчqe=,JخkT8۷R~+unᄧt{r|2W ;}=>j+YH%\Lqh+fƖX UXW%G32.A7h_N95yXKgGn+H7oU`WWW2i&8/" ` O|$_Nu]YckU gVߡ%t{ֵ~YVt4z5EO]6k31 Utf.B_ԼDTPR]H+]0w.J]".6EMÊ**TB8mZ3ڱ2\zsˊoqǵtCCEp krbvCp5l^ǏjA#>GG3Ćm 9)=]'ɀ}{쥭}5v1 СDN<,iIId# &Ycݴi̳W ڢ6L.+ˡ^i9RNqtX4 Pn؇A쓿Nɔ?c#^z+F[/ӋhThA5rޥVBl%0KW gX ofrd<9tļM/_n/zkӦv ]DwKq9lf[.ى9VH?q%'*ͪ-A34eƂc {{-L[m?`D|E ;*th)!d|H%3pMpt],X랸a ۃ]׿wqvzu1n$Ό{;cjFPo5xˮk$ /7E4PR(p0 bTYP!Ӏcj6HYP,UdZ`)IdtP[6#6 AaS z(xyʞ N,xJ1S&qO&P+Dw\U>=LPt%kHC)xHks(.b ޥqi8*d9*g I4qAU7 wCof'aԪ6e[QhYVCu[j'me1Dֶ$yc8]LPq7˳.K5K"(TMWDЫ ZB4[ŧ `Q"UeH/_N3QA>nvpck C+jDfQrQ[7-F HW`֨ۇgһG~g/Q}#Vgڦ}0{cu G;$AFyI]/ZQJ]G㡿鈨I Q25aYҺDY lj١itP 0ٕ"%e͐ P^2V#KڲJsx-_Aj"“-dTu4o!{2͝h⤣xYכ9"Jqΰ3~P_j0-y2>O/h$@M"j2B-=v yJK*>|_X^,0ȰDKϷo!@8bCr `˨VdA佺àɽ`}gqiCZ}=78D&G:MKvG90ˆz@]>몚qO뽿ZO(cQmгvic`|F })9=M5'x FQ$v@ަ! p-ljs.UٝH\:a)B&!OY~hlUDY)=Oy^.fUEkw2Mhn5a61o eI89H! 8Qǘ\8ffqr6BXٱϞա{)mݮnMb׳+̓&Bw =smy1XX_?5,bw̵X@HWF*YkEygFVO!ӛP84Rgebpr3ƒBЮҧy#cKcΌFB3̝CW@пgd|IL2OHhdL3叀%s0dQLa}>qDW3n"@980-tP{W/; `F3=KzߞϮ4 CZ 3P9~}#)[ ׶<7"fHQ?zpQ!i  8_Ry^fQ2=c~Ub*C# '{&%VӒ+D>_T"_>PT<>> %݇܆ub MXP,c)*?r߶!K! {`0xDVPy&-sKH-{aj@wRS6A9;eP*CKC$ebB6D"E R6ٹ[;:d$)s΅Xj8]%[ZEWsG=6 dP@+y5]TUD(e{1Hm%,Fry)$~d0KÐQX=5Ԭ`aFb(EM5.Txzj# JsT$"ՠ|Zt\'~ڑu}#7(GszY`2o$@C|ՆJڕakpM"&OEM:H>H|㇗?M>&I2/O4|$Y690W̷3TGjs7o{T)[ wϜxD׬W̘l0Kv,CoíGI9oPv݅Aŧ=AٰI|{p`Al#+?6&HQx_aJxd]_`0m=s}BֿՋIn)m9s?8Q;ͣ@y(ۤy NxDL1P z7]__G*l)-9VK!x:QJNof㸔+ݷ,A'@wkY8NCMm d{)L5yA͜FxKbg~{ZW)K %{j(rKx1/N/xu=Hܘ*7w}gC> D4Nq ͓ZZiɿYWY3U#֟Tr]άsk_>ɦKmWb\=dTOwaYF%T0\ [.4<~-r@?u5<1o*r OI"xvw|& oT}z,O3Z\=l=/z=$K존BSU5IQ?C\@H@c@B ~]HN7M&)g5az!?SKüvqJ7d k8: v^J4081>&:M cEX:ovɝ0m>C>攚Ǘu]b$Mrq CI:Hct0'iH:Ag9:&tǪOwCn a9 M墳BRv}rSጒ""PHxo5GʨWɝ(_K݉՗p]pC̸`+ 4`'æ%~OI"X ,n\e?}v-VU:@+RRѵzØՄqox&Lˁ)r4ƻꛘ&hbUy7k_gKjw,BkwP\-"vhn~0sj ᳖6<(> 1_hb0'OCNr=Bu5ߧgQRo',dϟ47Q {Tiȹ*V_ `:b!P'\ կ~(mpuw`ac85u0ab ɫ1|*_=8~TqjT?hP%AUd}ɣ]^#W*E CE6%@MfG)Fj_:Vx_J}*Pq~IVwfq]E(I~ME\!/H-@7ǁXWƏP_ ) HVޗ .o}i ~>KW0_(uzK〷cPf%ڇ|۟~-#f'+2Xد]+iz % GAe0WVP,)R>PdF5:CqpbM Dԅ)1l yK+U]f LH~/GS;UF-Aaexl.NGinpA #[; sWg ~)9LJ 󼊋@]wXsO fg΀V$/U78%7"n!)DMx˄  rn =؛<7yQօ3.Irxd<.kwer_3m6ovh8#o:ʻ&UF`/I1+z+[=Iqj7{< E^B3y{x`$I{wʉ'2luC * 5EЙlD->Qk\g ArLc7&)4 ژ.5:M+exZ "z 0 T -& *6c|]IZ橑7wy_.sR=[Ѯrwrp9h. /hF~<1l 5UYn " X˂' ȜOx<.`jj05%"ΟOE\2&MJo2]H;1Uyё#Vq/nk+܄Eą|za+nE|D"\ŒOB2w*:yxoa,H`tNUU5< kԄ]y t{[Qh ,B [j0F0J]Pm4aD %y71{ O~fRдB XͱM GDτ*s0z;<& ZfژⓨLt(7>` LnL%KWZN_c+$Dt䳣 _숕LlHܒvV#Pe²|0"LP>{@6YK(~H;ϗ֘F;1n'D*н_g=.-Bjp=l1ٿ<Ͻ]C֤ `ŮD!pzk$o+|@H=~`2L Dz3ITSUr0PMF2^پlԹ#qj6gL7 %+.E>,Whn:DZōshQhHr# qe=YBcp09)4y$3i4pLn,z֞ub>!9MjGq_!enO,ꯗ/AvKp{X'PPh*,%WeecNYK/|Eљ{̒} 8060c/Ezci6ӓ [)wٰY x,ET_uOߝ[v6E܇ $D0Fm?XSQC- 8E`shmu;Ĩ@aO(,bWTM ՎH E9Ec*AQsE9ȎOm35\75}CșW2nm=KAtp&֠G>︾#qڽǂ%ج)I>h\?B{zH&Gk贮!Twt\G!_j%SE?gy'ZB;W&DQ=3 BU-.i|4q6lsAkS:RHXwҺJ?eр1zEn uK Vb3aAo^ғ'?ٕե`-p!dS.&wx~X<*t!"ǥjOV(຃YnDY3BXr{$a!RIx,Y r1 giWR]~KRP:0HYȃ\';=GPjW+\ivyOy@wkN}uQyfWR@[{ S)a] ;/Kڅ;H\vzj{-y/$te5W \1Jb7sb*C/Np=#\ P߻ Wk`A͘NqFk\쾂H x/;~P|Mꚺ cCHCcQ'@ B߀qISBOͫ*ϲeR /\ALSt (1:`Bj00t oxǭ J@oFqy3P͖[P3gVMX!oIVPDHٚn;Ѳƒ.f/[AZgݵ(mExwpDh `rzF[$4)`^:7O. ]Gnm@;뵅 4mw1Q?"~2xP ,(n4ޕ9v)MCAtx+E`*#ni]n[E!^vunO ^s,82FB̺ReJд0yB 沤g͂?c?!4vG ^vYC]8z&;<#wj^# '@%Зo٨!q[ ࣴ L`+h  r xA+mXC>Z n~GǠ,1!%}j;2Wg^9<<>C xZ8Z[1O;…[E-||yv%fo P@UH8@ Z|Xz!cXI+ĆJ uu^Gn J'I[a_GzWQqRtJMҰiw'wPc^AlλduۨLҶZWW@h)3DHء`9~lzZeV~b/s^UEƅ!9 49Gj497gG%=1;(}TXr~+ыծGum ېZ+V:b\@'(AR-o^d z|6eMm~߾.6`#C8nX=zCKNbtGC#6RDL 'DW)j +Ȼs/`_P_tجA,$U&\[K*eVd%N~~͆k u,HH/) 5RVx.ttձ2Rlayoutj7 , ڽ~x}Vr6}bCSvC8M;+c+m3iHPDM,JVu~Iςح_$\s2KEu=Umh8WN!5WמULWT Vʏ ]a*p~Fpl.9Йb0L(>ʉɍ|  i _vY_&DK.D~8pO42E3aaÄm\k1% <%?g' メ' gJ+yimrRǣcx/&a_etk(|85W+N6iu0> _Javц ]"LW+i]!˨%+M rS/fgEOܨ-E`ۅ*UcL:n#N绺^1B'|7!ՕC>%,).O1tԘˈ\7Gb ז9}ðU.))S{`jJOqq;eW|Sl' cӵ?3.ׁznQ$>=jwnWV QxmTn@]_q +T]FNx13 G| g.92}5}ygJän2.XrH)I^̹ncy-_hڐl-Eʂ#Д;y[z}\ئhr|bUš$k:H(Hc\%J4H`&/IORkV*E,JʊT!VBǧJ]:@S+4xdXU }yQeꆌǪ? EO(TWg !G8PWť\v]+x~2]q66!ţG9)Ԙ&x1IHQF@mVJ[) RjR*n臥-f񤹡K^Ԥh_xVn6}bVv@Q.vas٬jY-PFlviR!8a/܊. b9sf_،"qD8{Qqw4w a 5nUITCE֙:wvi\vQg8/8E׿YhEerXA MSiUYQ\ˊu n$qu#3 QQ@#L`%,h9l!┼$wf5)}TIJm>6 ;OgLJnƥf&%%dO9<[]D"XH?l9n|B>m2~ok<&4~<QW6[ >͒)qƻU ;e/^>0d8l ^rT yTLj˱I^uv=GGt"Z:bj-X z K}CeJmpo` W~7slη3k\KL罵ܯx.T?/dj$NUzl/bA`?}B"pP ᷷ƍF<6ElzCXTiΎg=U.`h ~m={6nw#aTo&aתX&HC;,3"*O|`'[lumO; iV @ODxuJ@9\!X.  r^gM\. *|/+(3}3ӯ+KSleydq6nm-iA 6zr:׶#SsH iPׁ!Xј|☧TEu}isl}|}("q.Ing  38p;Z+UiyRWYUe5tϋz4-SU᳧"eltiZ.O(YkR^e/4M|4iاv~ܩno=IY=]y7B~TfڹCh:V>o5og*DvJ{?Bk[Ŭꭄf렑bkwd:=ˬLǪs¼{mZ&tgu +d%)kX?nڔo'a1Ob~2M_:u,AnERgESo }[,^T\69ş`qY}54 B2žiRX=W.KЅz[e:cW|FK`r{PM@ ۩A OvŶB|xykbIö[[a{,2nG:0` .,:06@?B%8{6886:OF/_c<35ŷ zskpPAiR;PKuaձq_URy,gOw]zUfcֳYץW'r~ #f:/ :_,bR~)lf{ve&EXLrlLqLbyz|xU,=/?U.-ڡ :F ٪1@fY&n;z>ݗlm:Mv*w:tEb.4}:^ۡ`D8XW 1"}a*˲(T?ܽ_/6tf-@|#1L#G)UZ˃o:r(6QY%gŅ67wgPge 6oT.)"%3TA qÑv7Y&Gq-dK#޺/Zsv_=‚ec]~l2G0UCȯ)֞ 5=7ɡ8 LFcEumNM嵵Lz fܠKbG8Yr^'l!q, ̉rZ6XTG{A_sdSBAxEʸpduf8T`"8BeVq4QPq&TlyK+Ԁ񭋤 eqG`K)4 uNiѮͫ zm1jAt;@eU.GyLI^KSB a<E %P:|%37df,3. fu~Je:<<*ϣvJN:{+G]ˆEДoiw+D"j*L ky!p0Q\,A7Kg͓kH=e̻8tz^#4N ~֌Y6IGW# |YpbHWA) v?lFpgO;Mvl *y)f3pw[B3*-Lw,\ki C&kx\nZ1֏8}ƫB =ؐaנpe!rZ`}XVK 4*M(k˒ ʋ\6BID&39Θ4nIB&yqV^z Ka, gᓤzYPdDB8.rCfc[dZi[Z,SZ0.#d,Y.[974 "`(K M֗i0H"C̡0j*$cA`Qd@Y&0QE!`'؍= 9tӡ"%(6DGixgw |{iq7BBb_ơ'Qv(Lgxl,AVl(}YJV2=t')Ͱtը PM) v ѡ [!`5Mƙމ`h;ӐrTht=g5LF8~i<fx؛=p9]ZpMdޒzHqjUb~[NoIžFy³,me3=B: tg[A%**(Q0%RBhEIV\t'}ZwaGɓreF!)6wYsNژķ2ňos*}| 1$ SDڔEĹp^'<@F3$9l)FzHGsM{+` H_%!.s@"0i !"UZ-P`@чmg FwZ) *E$|Uo=U&}x z!`jE?gWˉќ[V%9(E; 9\',̟I9uFDi>3> !@A'.A!u;D!Ȋx4p !ed%PCyN;CtGkv" q;džɈkAtaޜ,oCVi t/zRltĠ/,hKUr:3-lEL W*f|D!K3 @hxiЏBAb=*0eq#,***RD@^@#ݹ)WdRt^(9n`c8Ŷ8®*0K H!XY#cvmڤ鎉@U> )Jea TQ%/KaE1!PHcfHyH'7 z&'Qz3 T~ye\hІTY3tf+Jb!R'SD9qbWY_%:`p<2X(g >IЮߴ&!J ,tILBn(`xZԟ`؇Lel=TObw~1-(SNaΌ^ w)Ia9 ~>7}l8ԫDzµ׏ pg,/;Ja"BTQe03b8RC(uD4KiPkzԞ>z8Ë<}`0O300"89&024ړ ч2RC0шY[䝡eeЁ*Zh&?>|+fBuc{-W0@ %ertu횪"Ж6sßt{/m4?噪#<ü̳pg(wPGA=|z kQR Y2]g9$I:#/ׇXVT5K:Mf"픤əHuFgst1IJZ.Nrx-dSw(ʢkqVߺ95hk/{Ă#jr 'Li+Ls P~3vUDάgHNmV:IPp^>Q y+> ]]'rkݚNNy=vፇ;t 5`@3 :Jke'j_{f] 8#udO)RQaSʷzj93D=u&y$tA3-_u:o'i rFL]+5:nI2m`clmeMP,^Vv֩~d*{~3vc 6Ϩ7KWP@4N;,P[f>A*l6sNxA S8 NDT2n-br.dC^u3!g5kSJ8#:ayVEv:/lG4th#US@HvQ#0եl|\RN]7M 0)$6>#!kp_ǨÚ} ^R30߯~z~uUAJs9PqJ7"W7Pn83u7w\ J Wǽt4K)W;{ @x1Sz$1sf%F>~] _% 0H" fd10d6!?,B,?YN zx yɦ4tA;rȡod]5=8)weGXH:V ~4#ZZ܄qqѣ4v>K4zJ 5LCy܊ՇcjA4T30qlPe6|i } ^5{"?V {xSyRE?n<-qr8PS*YSp6׸AԱ:z!J }PnK*1`1U顅7t4Kz'ڟ]O/:ˬW1zt*:vJ=(ӵscZ' NdsN?J#h R^zJ}_a(?ٴs>OlG>u -6L ,2G`=3,ޔUT6`8Hk/Fֱ ~I/E5ݳC8߷:PurIJvΥ8F-bq͹lcT%jhQ<x eӫ=8Xx#^ H(]Ǘ@,6!lRX!vlj5%˫#GT3CAMt~)gca\>ݳ`,ٮ^P݊F~'6N { ]O szkNxaP *]}"n•U3tfI (AE O 7e@qz~#}煁`Ϙlw]w(jC&m1}_}yut.g/)Z/zE LBQ/+ BMP ˱ɂ_P0c96( /}4z bwQh.K(탐)&1elziI!ZN[},*Mi e6|kEWx  `|}WVRdg-&v[p;'ws9I*FvC8iT%HC9|hxl;eB)BiXG 9$fvlD|geӠn0#JA8.9 [ye7Zaٖ0&PM.@[ib!ZW!IXe)]bWgCvֆxDX,(~L(B'pFHuẗ́" ܗp[{ >XE'㺪Ds>7As x4XWAEImA z Hs`"& }or(9X58 aK0,lͲd_X HL/{$3<ށ-E_"(uZeCh)Zܙ`g@.h׌laTPjз :0WPF6ӻ} ׵`̽!#lÁVh2$M09G]kkR,|uN3jfI,zL(ȼYr$X)2 dr& p!z . MR3v!LCfC9Hku* m_ bVD@<@en:ЫHUkc?6鉸L]kn՘gzgșZ98tgl6(.jvc4 VRFŴAqojI2h}9% ?%n3&Ԃ+^ܰ16 X,Q]4BEt=亮޷Ae;0" [B2:~p< |G{J;>ѵހvޙ4>7-jnsZ췑hIJ_#fYލ<0-4-9+S|2Ϻg^$ѮS[,bd~? ANPS>T ڽ=6_<W&Ć,LѲ:v+B.=8gPLuH+x%֩tBpgy^C=g;i]/tUmwG%.S>,x] 2n4>99y)Lrp0rBD'3"#v<r T]Di8DTZl'ևm'_YW#t}b)E֑:7wp|$dTRQ:ƿ=W[i:ȍ+)I j PHCBFbK!#M@xAvs6la_ׯ̰̚j2܉0RVAR I11rmy`G,K3*5S$# ' N#x=m8nKWH*ڳ18)WP2`q!TBs- Xᬃ h  seۀ咡V a_xigjA;dz#;'# ˺˵l>okx(9BPi,iwsɬӪPY*ۿ(E5l4PNCrswJ n4Aa߬뱆7}l*>!)pͯ[~K\M@KTL~'QjO y|#vSH(wmވ-@yկ^u? mZsnm5W0Xob(7}i qTdxTnEW$szc8E"+HԤoC3̬]3'$s5P$\+߷!$}_mυwKk*4|H;[p,W:d],Sx``ahB aIvͮl0L.g<˓,|;xΨE}ldo_ѱn͋ydGx4J4>b]?INgDm1'VrY,dy39Uƞhpi t4fθZaqֹt_l s3qVmw:M>߿7YgE~::\dwTqv4OgMVN2-/[ܿ?jm. f f{iϒh;7,w$ɦs \Y21:ȒAS|[ VҎX$ٖ͊d%7Z~Now;I{e;Gh~~0fLRvۭ\} ݗ2_\= ")黤I[bu2Nɻ tD7#ajDhGӬ)S;Q8Ԛ,-{[ub.-RMkHڥ#̛o;\j{a_Ծ$đ{M@yS"[j1ܓr+ߺ f !O`@6F0SrFsnnA7 xSϋ ~,UCNHM."Zh-*|pʃmU,>mqjHdpB e8Mo8K/|c vLJ3, ܡ_oiNEwf9E惙?BbayAoX`9m%LD5VK_I'XUk"~qܿ^KRM_¾Gaos1& #vb[[?:~;/Rvː5Oͭ.5`Uh]RZb}CT+wv5o@ )V o3. ]뫿) hӕ(f+wLIZM;;j/cV=߄<‘`~+v֏ hv""ܰRt/ͥ:7}-kOz,_iVܕG@3a1}7*Q6!i3͚E TQ0AC/MˆSti N|Qyc\U_KtR_,ģb|.p4ьuH2d9#<|Æk2^6dːЦ[/4#<֨@BbÔl5hs\_JqaM $Pi#{۵1ܘa@ q q*no Ѐ>N.h;:tXz^ӡnh8 =3Ӵ͢|'+G/˙qmZ.a4&HпDJd<0.IΫl]i<=NJ_Jo~ kt*C\fD4+1BRFKXf v2[CLa6Nv{;|wҋQ?uwF(O)ˀ6̲3ɿfu g>u@WaShxj3u0#e%`Iqρ*<"U2 yEY:ԿW<;C,/F"7D>嶍au9*`Fyf+?es -@4 SŐ#,B+'0xLPI%5DM wʝS VMHß$&d/М$X;t'LY!=̿c͒q}&@#^=ǬOTО-OvT EJS'蜙ӎv#а.!R2u¨gtdre5*8QrhF~EeDڑBPsRxa{*HZ7f(aFu\ &<^*AÖ8"ǐ7 DoҪ;+yco+\ Nhqm`?u1 r'Vci"E "}1 ՜Jl0=ƟyfLBHt,1Dgx;yX ʭ a=AAβ:+3 0wm+d3Ƴk쌐E[Œɪ\Lnw_=pLT j8&:s1֊Oj NlWKm0O"zqD=O)P5`@v"wxpRQʸ!6d'%Fe*S߬%/sG4}'Zqgl6΅и~ & ~/]Cp+Erp؏Fo=]Qr;X:m˹o5v}zjEde4U 3o;/#nx`T]-SQ6tCxuڠ CN (e u:F99(PbioXg)ePɸqwȱ }˜] SoXٱ 6%3DiD) kb(i* @BfG0ݣ,t0^Xz BӅF%XC'9w/BU`% (@-հPw>ťՠR=_ "AP`JCV5t,kNj8pݨK R*?&Xtg%h^VO%-G =dY\aR?d"[ &8- +/iHq2&~ʓOF6]vKodr`KX}Ѫ.,z=)59qVK:@>n$ V3ڈU:z0L^*%fU*RKlT_ުyo \mlTeV"{6Ԓ]iK^a,n Ul-/iYh,d6D6%jZ`iԖ30K>Ƹv'ӽ^5=kJ'QYSw%2DfOvmL}T2K)ZFBeHA`Le+OXbn6_Ó㜔:I:t?7v6O\լLL0M*-Hۍ>Yy/$ w/3Xw5*0GpyD$y"6Ctpz]S%LU7J?K(.p[H=|SX\S럕Ė{uQvS4v7,w ]˾od,` fQlЩ0᲏$\U3j?p@+{jnX0Bmbv݈1/ojB%/xnT/ \c(\dMSifo^=XJG \5ҡ@]lx'[5\g&}Ln$-z~u K3Tt\ϒQ]H.=3gLLw.̓2R6 .]VSÈ[5J#.} )o8CpAۂ%̳Nka 9O!,|ZY;䉇c>_U|cyb| ARS-=רNze77HVq{Gb0LeR!0]ܵ9Ƨܰ `-Rؚ63a0'qG*;q*%2ZKg)qч 2L v]b|ţޏc>S9tz*nI_/Iф_MJjeblІ!PpY:d%clˑm̟*c~5kѭ\-y1xOi?7cꊠ{|(8f)h M&f$8*玲\JN ~NR^nFJ`YQ*rN!\*&.@ň1T00:Fb&J%t+cQP@6J%Q'Ap5)S]m/2 AӐ[ƶ.xG5gC#R1T &\Y]LxAuOڿYݮ*շZO;/fůډĽ@?7\S=|9^DVF! Dig"*wxЮGWQ)ަhPm6?d˥K F R已޳2 ifGb_J|ڝe\(1t467L: d4Ģ5(IFz–꣆r[1R.ͮYj@w5$>K3v'߬Bl7dmf #j>R0rJoLӖH m3bRa_3:h\#,yeUHnA9QN,6rv=hޤJζ:z kR^uΞ69é4R^`S!u|54eNzd\OwtXR .K[ J*'n1+ k(DAkG;#u ɯU> ,u*Ժ]IKÑk+>:E[5SK"_L X1> u/"yE;']IlC4QKxڽWM,!Q K Cd8i CJb &5TYe6i6 ֩~ /6h\(NˏjǛF2 l]M(0hȮ\"Z"K0s׌VHhZ*H jJVX6N|XaZ"| ),ԙnW.5 >x|pzLB;? s[킡B"thOSxfAՂ+OC̪`foHRk-WD߯R]ǑbhTc_R/wB햟%Q%9gK+ϵ S@,l=HսRoev"Y}p5Tfx]I :'7kha}׼Lrэ"ЕWw'RSDn_&B1`+2%E)xƿ:7zEt8稃 -ʖA,XM-ϕƇuJul_i+liՃso UW/WhxҤNő63h{R$\V.K~pGDUF\oaȣg_s6#dVԶ(uɯxsxL!ԲHux+#fUk~kXdH!8ϵ  4@34DҪuOggyH?zwxԺ9ZU;IGf+VI[?p6VIH\'ŽsDNAJCYkf\5Q7qҙqJXtM|r]S.͔@bZ'HB V ,JxO(l7 BҊ(!UbXC~a6ЍKn ݪᬘ q\R,M `g 6. Mʘʅ"=-'µ@y5 0N%YtB]BIY / ou]؉ !Ib#mAD sTs>oE?"jFyJ t33a &4spӀj.F!܀aTCChZ>̋[~؄o=(_)lDΡ"B*^$Sd?uyv]SqE0T0 uo!Def} r#Id*@ 񹂎ۑWY [.c4H,(:VDKSxZCXj)3D!?a뼑`ITr823)5o] ԞZ]ptnqH;LlW{C՛rv^9B ۄY=}R/*<"֭(`s"\K]TRB#x;Pm?l5gbgpm5ΐ[87K:Y>K_=m{TYDQ՝m%OӸm0@ VeA7[xv򦷻z}pZ+/'N`*ɳcI ?~Pݵ:Qmio",|}᧌~f&ܮ#f0߁Z3\n/Clv>r TY"ww+H`xnloMuz%h| YbUÍz5paC263p~75xt.znʢKMU3Iݩ!ZH| {6aGjQ̎Gg:j8T\0bŠZ]g:\y$Sg.ڍ+03tռ7;m&[mU*Q䄃My2׽0/M*YNݗ{h9Kh>KRj0O o)YB,6ߦF"EXB&6m$ ~F\UU? $u`g{$jMVPhۀF,hl[FTȂtkM\ʱN&B9)WòCE͊ɒ#缎^SLz01B_QSKR{•F+q`}kJ'M"tU]RGE@wC 4t鿳@UMMDJmbL?J®pr b)3^9CKJYłC*y5jQN/r6"@%JhB<͂y!T=6Y[#qN)SM,Wa*dK]C [RB$ZJE,HŕdX"Bmٳx(M (S _U稣 *qn 6GZ)1Կuad<㳹cVV}0%+@G \%6 ܒ0^D]}ڰrR/v]<)UTU568D:ԭ*lh8Meg *,CIpUsRw{^L8hXZwH-d|({DEb6ժZK HAaaYi,3jB8'7YYЪ7I :QjYdm_Ypkq+uH[qQ$gRȁ+^  aō˒o@+bE:we*3#!|Q̺?rpsg%JbԇOFȒd 1)9-`. vW0 i8\Q/ 9:Ks''k>5P:T+Y&NdR=\9!,DG^eH`Tz ~cB#lAKstwwQՓ)#;%U%'ֿCBa]'uRjScsc4qmTB'F{iЋN|m,k,Г=z5yo~wY-|:_Cix;adG8Q^" lz %nVZ [j1|=`oUsPy[vޮWKxM]hӀN5 S" mb,-2PGuqNC*4t /MyetԷ+f6ߚQʱK' 'mKƊ(;s](xM hƦr=sEMK aG* F}BS.3,$)٣Y'[ZvSy;K싥00//gl,8̖p Qj+0Y}HKy[BKC_`:rzR.pZk9r5:_*(\x:7Hy$pJtklw|6=:pRw@.muixPS#Ӆa`ԃ5#/]zxW|7Mn9`)Q)"?|BqM`w AE|Cq1w`H%(9 >DkY8dӷT̖5cgpZgrM7֨;6@J{Q$8o]*n{ns{]v0Zxm=ݪحtՊV+ҋ C,f>2BdxueW4rTr*1w_p^ *6)r~Y6M^k٤#oSUKeR`צk-,.X@ k+r6kuhsɷpF2dzr8 x.骐 ]ћtB[JQ=-Q9&9F$&<_ _Ro9<~tGiB>oիXY(,/] hrY?،,*!* }b`6?;twwyQSZM:E3hKژV:WTn39TnV(j+q 5zew4mB?:FchC|i 3p[^ʎ|;1{oqԿO6_Kk7o'iv}mkãK7Q}}滍V.Vb?n_,{0_BG'b0pfDbJ>u_tz HPqs]pKa4բ٬<[XQm.Zh٩ReЩ 18 5)3MSiQ ƃ}:IN 0~ȭww5( iژT,YIGl%ڬ*si4'HGaQ0Sܫg7O<( Q8G/8sxδ/&JhJhxigδ`hr~nA~qf^BfbBI~~Bf%{LxZr6}|*g1-'zRɒmծTJ0$FQ~~~ɞn貛CF݀ \+%`E^:1<8u"<^͜+S+H FWrBfʥtB̯J9N.bcMډ [  _ٱHK}oT3Tc1Q sahEfNE! U8iR(ss%0ɓkœu<L+w'C'^ŗc,(fo,fJ"cj$ڸ}e&˭;oƘ tY6l&\UoTզNxceRAXX̰PBV9c<ϔ 3i 2zˋX9U)B_YJR+ID[ms9ZP{h12$|4I0$lDxnGdz<%K5E< }8")UJ摙yo@ TmMt&g YeMS$\CTUg- |(F}G2Y u1D1ҙnfnfX Hm`{[P V!҉'4 ,:d#-ѨbO[k Iu SײӘ;adfm2XX0,M#W.TR.i0oj`tSDcRQprxS^,* ?<;ih2+Y O4Uhλh]ᾭDg|XS!h֠ 5USOۂ:QkLdyuXd`z2k:w¿dҒJO}M%+uI_1!- aJA c~hOB_b\R OQLNoIR}Z"n[ ${r<a~d g*,fK"eY/nL XRP1#s&ܜ =4en C87Jx.I }OkB.C=!>";#GH,Uj5')*|)ջ9/>J-j62IT8g];GmXƢ4}a`U>Kg37Vg/P_[!ΟM~nvjrwY/I%::U2NiUvϮ3 A}?!'e>'iaG)gA R~Zt$a,MUμoCO<ْy9W 7~[{MX07ۊ ~nFMpíj֟ օtYn)_ѩN LnPОh{plj8Gp'OBk'}>?reJ"9> yR.]\܍,382FoB!?Tz12~@׆(M}*Ul͢=YN4T {܇r#{+5H~E n*c*m! *HntH}l@ŧu\/Q#\Q]7ԌM5 ڄ?a^FiSz[] u4虏B큔fgJc"4arcO/[;jܜVثp;=S gԵ{M(TBL[ukZxWXk[W[ThÝT_w}߷1jz":6cJۨTXȤ8/6)W+tCVƍOR&>6?Ӿ qxWnH}ҖK&٬m-v0VD^C4ْ9d˖c`>ba =MJ,Ev.N7]:C!3CA5]ꛦ_ѥL*Ey.}E'JHh.x L7Ӥ^$M) ?B+dgTi!ʒQJ)%u9~4x;y^/Dpm墸b\DS}?1Q`nTsP^ bV뱁LBdًzO EkCnNNP+N`sѹ# ,{b!>%ffJMDnTXiPrSTCA0%: N΄#lѹһm X2$Q ~iЇjcxj%xV!̢PdfB6ѥpd+9Y#SqaPaӐ T}8c}ڹEW8MLOEFcSCvf#LP-CKLdx0)y-h π~Hf*MǷT_Z=GD:R_9_blm~G/uKlK~3VreSVi fhsS'>su3 tCRZ6QpL]SgWH Mv]ܶ"?>V*+!%@ÃSItycƪD:\)L;DCMַ{<>e-bH8lvݪMm ; @c T~h sL]zsfKPlDЋMCzՊ}g-#L ;Ɗ,Ӡ I;i؆gR ՞Q0 -aHVk+>NLJoZzu8U\`v 89b#ˏ21N%yknsٓLǬgͅ8~hr-*>,E7v ;%s}T"9:jNw9 Pskj֙4 jX3Ql kmjӒ+lfɕ.i͈ބ)؉M` U_=tal]P['r`'; H6 Cva귴t.ORUeI,!@bGx+|dkre9mvSmۧ2{1NFfKI)SAyԶ='m)"e*2[5׻cuo Y9 '2},//fEVG^TG5h3y5.nE ;5S㶰=l,>pWuc`pog'ƚ +BwXyt~ [_9x31̼|UfqRx\`<=Lk x340031Q/(KgYwS?{bzyǵ gBldQQRY V3>ObSE7]Zn * %?9>=50o#}s*~E}fnY-xY[sں~BI8!nB\ɜ[r,9@dӴ=̤%oգ#rmw ''3n,U1 EO4$,za#ju 2<>"E ::bCQ(xA("صWtWlxyj,GG4< #ѫ o$#YD##A]+ŧ+\ b \NY$s̤Dp2t ߕZ(GVW+-ۘ%2`b _$N̓0MTOQ-6 q"X59%;, {Wg8*7$޴d_CI<_ \"B %r",B={uq} #א%b)˶ 2|{]$pML[Bgюaٖ` 6Bż(0C=9@qP CD£HM|`nh4` +K@$ZH%A@ }w)ɼvD:L: RS,}0B>GLcP9 x2OZP8hdkI/E k#ݔ4 S#T9ص>>w:vPCi?3ؖH{bKijp ᱃s5# 5u]+2rK>ݔEoSkDR#VC(MرHH2NSm?4ܞ| $<'pQ#Ly Nud.SqIlO[vpKmhS^㙉.Ut E@rCuei.qVN$$b2( N3lUjV$(;ݭh^֩U(td|3Z< o(Iø`U",Dtq+?i)k<+I:b ސH  u\Ij IU؋!JR cF Bn@G<ogӓ3;קO'7VZ=39Vv9 ·uB}ʯC[H A$0Lh4"Һ]vPU %@7S neTkDR,b4}QG]0uVfɡ\XFV-oAN{'kFcPj0Q$ǵ$x)@zRo{wJ\)]hbJ>dlX6 PNZH)qzym-6b=EƸ4ˀ1Ak)5)$@` g$umտ;eϓ]}u*y}ʳDmx5F+a?-Tτ%"f rKS!` !SO!hn/; "㷕(vVQL†M %J>BB=9UaʂhPߡAOf7/r|K':lb|H';#Ne\tKȴIW\aa G?@2 }hp1M޼T zxxЙ:8N8e?;{`<@G@elܘךX]fm#lf)N婡qUZI|h@AM)3G`:V\u؝l荕9m =mD[ 9[Yޒ;K$uQ5gϚ10\S:{І3an{%9%i$Y5Y#09cE@e'5~JXS*\7[Md 6da?͕Bׯ0Yi[iJ$kгev-w.a9q(1PdBR?/(b;ϓ~8dxFT`oc`OFǙt'[{@̼ k? =;=t3{Y;FH\/R138ПǻLz_5CF8:Y鸽5d1fQk# ַδvkӛ?MO_[7QOmRo!O^)G8n2|n-'^̧rU?gwO_**K$g3{ OIy8i%  Vr]]K#Yг>7HXlUSڼ$WOD:P~% G*BM$>wU[?]>UO]cfGv6fàz{Ϫ'WO#e3fTmS ;jLe: Έ p Y a0Ŕ1Tc &5`}.˸0@Mi5Y@#2K Ou`+LV~yj1Q csf 'V*.oF3BpFh$y{j2s")v٘5gxw0Ed#JqUHVg˦%ߩxX[OJ~N~)M>XR4:P<Iu E3k;Prof:e-r%kõ8M^D~g<|r-{Œ~+L{X&UIЖWo>) L4n> O'2D"b?2x筜df ߒz3 9dB  >FL8@?Ib;xy6Zm&얱5/>MJ%A*n2%U.>t;x, zM ~E^M"XOBh)Mb[t~O@ P;1/ѐ+D1LssFFC%NOz7yHB9| f`?n-.q";' X13Rt5q%L|-:ǚSNA ɱa'$<?B,p4[h }s5.d4fR݉8`~ť[3u%?} %)5~F%2;fmޑbBmnZguWe #M# ݌./ R+{Ur#۴4֌ H)L6H\7q&x-.ħ+ɕt0笏>;Nv+}h37κS8b#a^A)|d;L.*x a< bsa0wP<K8çV)SpgQ)ƶ˙Bou7jbsOЇUpFrXͷ0w6ޔqOR%'ٿRa)%Lӊ pVkLv\"pα}-28UWSa~i nVAb=JY&PQo]i^o"ߜ/2s<{'SSUt|c3\2ImlV\YXΫڜ_ܜM~OMtYmm6_ll ,W\WI{~"]e6m\nY`A+l541^r9P,|S6NGӤ],[+"|?6&e- uUJ޳E4ݛʕ.*7a+o]`.&TJM.S!w/7.Yk2.W9<Ce ;w q&m˕'zGbHmiE@-eodˋf:y?O#s6wNofgdyVmS Y$$% evnnEL&pQ}4-uȽSAa nj6>7v: [7\0wÛ2O_e*U!n[VF6FrA圹=- swOHQk?v.M_g |Z)b}C9pN̘&A89՘AmG1b<@*R% Dln:;btR[40TʈʠDVɧnUǠ3YN*DHD_Awм֔nHqڜ zήUAmN6bH/ն}n%"ȋ\zuc Oq]QAd.W ByoEjIQ#`nd֟L=eiC%+CdKkQH8R`","NAkZåvSh] 1,Iq$r`N6b(MB?7[\'ƚ>JmA`*|TWpCX)QwC@D>` >%ѻ|(P{ ~c7=\НJ?LJr3#sckGq8` ԑrejW#'W DZ'B=yWXT<ܳH2$m'#%EBYh}UttDe> k_Qc$=G1p4(mC2c)= 0wGP w{B갺\U6|G=A2H[$%As_쨎&`xEUB{Ut 7Z:T֯wCM SY@ !zBLHbEQ SU+a؁JdhJoȉnΐ g&7sYteh@Y+]UJPKJ响ALVwpTA}W!ȎͰɮv6ܤvY$늕T@#C}ۂrJ ƌ)Pŏsc,8C| C!A PH6+@*XrꂁHA \5tl_Af=jH0\*sRh`JU "$0 CsQ8:4I  q2B~`Rkޢ> nx6_ˢ[~ګ[*X [z;A$O1߃Ģ PS)VA`ۀB#!(>J =&H1:ye&D:;r` s!?YCY Uzj5$iZPG=hChFZ{ /f;m^DjJ %WK|o3%nHL#i'%z4k)ٺ}u"I Ǿx|BY|d)C3۱ iZ&צioޞO>lzq5Vn2=/y=S\seb| Z"!|N=16FUj`W 9؎o Lf+Ҋ!)u):U;ތgRXjr=\%}6pfĞ/%;BX[lI[;-4L3[+Z0% u) J(4恑f ^ThԌZQV呇}(ՁH``amai/ .3O5--P $p4,奷\"t+ O2* `]_^].i>Kxl*}'U*sE͍6ԌhH⮟P`vaD[RʹO蚊h db{оVKt& +2{d58 3AD)T/"EC*ޱˇЦa4"b!!`M-AѪ\<,ur@Vi!RQlM[#Z[Pܘ\TڂK:O@R{̭L9֨@Hʒbx $wBPr<ɟ?m%?A}@ȸN_fKxķc8 %TN`㡢αϳ4{ִW+~34o&wzu~K!ˋcR*d.z>H*>5!lG`S Ri"P`&,2Dб1aD7Ea",ז[`"TmB97@*9CJ#a&Q]i Ut?o_PO@LweO,1H16ҢhqT( K;E:\9}? :k:s歐e:olsq3,j\]-7u4f^p,UNHD< B鵩bu6%z| I߄H&`3*ozҞCH̠?TgύKjEi $5cl& IZh:LwE6V X3`Ui7 `ᇇB₂/G`k(y)2='c? c2Az%e&+-"0# qF mw>zkn>K Rڔ0@u-& qPi_Y$9ke~,_?WtZ|mrs.uXU#ɭRيDGλ 17+a F4\MBGM0 ~Dğm39_vp,Û YbΖ( zJՊ1}(%Hw LR2yRPLU3,~bW4xo!{1*x&oaHR v#I̓` p I2w=!K`k'soSknIK ?P "Paev=*N?Nr)_o Ch-o**iwq@OCܒ9 Qtvyp/bR~N/p-е@8wDL!aABY 済P <$1$~ ݫ\tXkOj]pUҬ M!qXTE* ĸ-p Qs CRv~Ek̵79Xa3H$~b?B %ê_'J|d4?([LMKl Of5AL)Lᆤ#t.$ z`4ͲF5 _3mtۤnolݚm:4\ cX)OE& bomDth=QH[֜]N_ +l #f|59e |\8֦6kFXMAh/Jڄmضgn$;(5oi*oRč(!*'ϐeop=&+6tT_0ˈP#f:azGOi‘`k#%4R7= H|\QJD 8OIv,Mh(h) svK?jd 8PCfspx"]xYnFm=ŔS)'q7\[i]$a+[, ## a8#)k`bpdϹC$1E:;NQ7w:ټWN›>£)ft_fޗwu~6d_3F䥩ΎƫR|jV]=$b񩞛fn:Μ/9@s:ő} 8`;&O9 B_e.TzTx2~Q Wۭ=*7 i+ Zj=6Y_metQ@cUمª&),x}tϿt.Y ,teҾ86^8t8g3Gy5«SPy4L$܄h-M^Uu˳%r=EG1:DCIeٛ𢯜Uy=Fp`x |T-vvo|=x9+8 1Z(pE%-,#4Ս 1)Ac@6 ƹbBte ?oc>g[͋:s%|R'&ݨjC_4\gw؅ gSۤ &&ҴBז8(RS!_祿Q[mAcbu"_1`32LPecvʖN#pb~#j-1y Wv҄~,_(Fs_`5O"Vڳ)RCAms˃[ٌ&E }e 3 ^*Iq CҡgnXS?>'OTWwCz@iPSlV=lA4*,śkR»*(BZC=TSLEG/0^cxOɥ:=S5eNGG#e:Kֳʀop{cM&h]y=h*89a[/{L :PU ᙠ;Q T4@7K8o]VaS[L(`qn۽Kcf% t+8 b؏0Ck 0d@5-b9 :`3bgQZ}XK><K:90"~rt%R5V2S.ch!|4 wf_ G(aԺKth "b:6 EcS%xm|x~QмĢgDY \xW]o6}+ y΂b/)&`,MY #-:f+H%;R6`@:"yy?ι2/Nt,qͬG|͝^9QCq|rtzxyr,l 5B'•R/3 NXb-Gh?P[\EδSɾ))Y* 2'V/rdO{Tr}!M f ITPs0 HQK.V҉MB!5ۣBI.mnT] (A{ ɦuB^W( x[afMngO.6E5^,d"frPIڃT%tuȔ_ؤOBXGCr0!}kS!NpXiBHQTLc=D$v{+!"`qlV0%ՌF6,-U}.Q`VJ+ s2V[©5]Ε(P̡|sU5P@~vGT:r^֙: _w~ GiR$nНfV[{aNR+Gƨ\ 1R. :ߠQOE~1BtPQآG;eaw k}PPv;z^qm(QeQ"9qy:xUuM3xS}bo?)jsaDF;׮mxP>;`%:VZgOj%:Zx X$BEgI[) \hv} -I T0U! nRp?bxnh&88I4k:Vx|vanlX5vN**ρJQsxDM!ZEV:W-BPeѯCM[#4"VBkB ~ЋNx |@Qs pLx^lӎghC Վ6RÛiQ e ;lh tDP/Oحgljei" kKe ;f>8ڇ=N3J nS+*dY*wܼKFw|Ze2su 'EY?DTzhqM⓼ղڕXj l"@, +q#Ğz a+7B"Z[c;~wtEF@JVl7Q砇:܄;эo],"Wև xch6ŒEbűa AP \K9XSEt&Qq@ e$/ke~g(u J=$_2c ЫsS ej땈ڦو$C Kk s'=>m܍ߩ0Tv,8/j#XO|Z)s0 }=B5j:6>C6bIY )rǩ숯&f<1QƯ( io${kpa6*DZbAX6鮰'Y:%W3adbM6G@XCQٽ˳#9ZJ 41p  O1:1|f(Vם_]S+f>YK|d3T{ZT;*_p|mKzbx IpX 'e5f<9tB6}& x opackage zip_test // Documentation is filed in ONE map for a whole process, and an address is // unique only within the app that serves it. Two chains in one node both answer // GET /height, so before the key carried the declaring package, whichever init() // ran last published its prose for the other's route — in the document and in // the MCP tool alike. Nothing failed; only the sentence was wrong, which is why // it survived every test until someone read the output. import ( "context" "encoding/json" "testing" "github.com/zap-proto/zip" ) type heightOut struct { Height uint64 `json:"height"` } func aHeight(_ context.Context, _ *struct{}) (*heightOut, error) { return &heightOut{}, nil } // bHeight is a SECOND handler at the same address, standing in for the second // chain. Both are declared in this package, so this test cannot show the // package doing the separating — TestTwoAppsKeepTheirOwnProse does that with // the real thing. What it shows is the key being read at all. func bHeight(_ context.Context, _ *struct{}) (*heightOut, error) { return &heightOut{}, nil } func descriptionOf(t *testing.T, app *zip.App, path string) string { t.Helper() raw, err := json.Marshal(app.OpenAPISpec()) if err != nil { t.Fatal(err) } var spec struct { Paths map[string]map[string]struct { Description string `json:"description"` } `json:"paths"` } if err := json.Unmarshal(raw, &spec); err != nil { t.Fatal(err) } return spec.Paths[path]["get"].Description } // TestProseIsFiledUnderItsPackage: two apps registering the same address each // publish their OWN sentence, because the key names who declared it. func TestProseIsFiledUnderItsPackage(t *testing.T) { const here = "github.com/zap-proto/zip_test" zip.Describe(zip.DocKey(here, "GET", "/height"), zip.Doc{Description: "The height this package means."}) zip.Describe(zip.DocKey("some/other/chain", "GET", "/height"), zip.Doc{Description: "A different chain's height."}) a := zip.New(zip.Config{AppName: "a", DisableStartupMessage: true}) zip.Get(a, "/height", aHeight) if got := descriptionOf(t, a, "/height"); got != "The height this package means." { t.Errorf("got %q, want this package's own sentence", got) } b := zip.New(zip.Config{AppName: "b", DisableStartupMessage: true}) zip.Get(b, "/height", bHeight) if got := descriptionOf(t, b, "/height"); got != "The height this package means." { t.Errorf("got %q — a handler declared here must read this package's key", got) } } // TestAnUnqualifiedKeyIsStillRead: a generated file written before the key // carried a package is still correct for a process serving one app, which is // most of them. It keeps working, and a qualified key wins where both exist. func TestAnUnqualifiedKeyIsStillRead(t *testing.T) { zip.Describe("GET /legacy", zip.Doc{Description: "Filed the old way."}) a := zip.New(zip.Config{AppName: "legacy", DisableStartupMessage: true}) zip.Get(a, "/legacy", aHeight) if got := descriptionOf(t, a, "/legacy"); got != "Filed the old way." { t.Errorf("got %q, want the unqualified entry", got) } zip.Describe(zip.DocKey("github.com/zap-proto/zip_test", "GET", "/legacy"), zip.Doc{Description: "Filed under its package."}) b := zip.New(zip.Config{AppName: "legacy2", DisableStartupMessage: true}) zip.Get(b, "/legacy", aHeight) if got := descriptionOf(t, b, "/legacy"); got != "Filed under its package." { t.Errorf("got %q, want the qualified entry to win", got) } } # x340031Qtqq w rMa~bh¦m5<]:+*9xԽ8ޱ,c S47(zxogC]$ȭpEE(Y.(O|agvI]Ed-gwrΙzlr+;RMCma2[7SStض-Pn ͙zBʨuYiTfsM3N28N%W3-i::Znovu]ї??+xCδښjٮLʔl]TW&Te9Q&ILhӺu-wj߻*b:7s8sԸ ڸb؁T0K[3/9V:RR^hkk)w.=iS.`2e2Ҳn$IZfFK'?]颱óh4됺vvbф]F)2ƿ]=}G_[NL[XW.\覑k'u0a7C[ 0,V,uuz޾i\`O{GI } >NSDu!O t&iW8Хp%Yo;hv4 t:c^NzkjT/XY`s^[ru7Ijpæ>R3kvܢb0>IKNkpgKksx ֏ <k[\AlP@?`:LMuiq籜3؃*x;fCKp`?QJD⋠ D$+z1z^_?Kh]7A-qI¦J\ >"&q&N؞yw`s;w`Mn+!G6!˫c*C˃㡭&7 +N(w#Hw_> Re'ժܞ~gv+~t  x˃hPoJ7Hr&6A_kSP 39M&j]t2tOtCk-z{BQ51h53ilgps'qy8B!3G"F/QJxo'5$;~@𝫧"dlyQr*B:qו^2HB4ztfK ,_7ZOP,89mN-LGƝcO,Ow1X;aR g[OC 3Nq67pf?IIP}|@96u k,y9 :ѫhTpYq` ƃ}qEwݗ9_lu}hy CG21A+t^NOՂH~9Xb54tOOP]vϩR0(73RO+fCy &88ksK$~ۏ6 1m-N腴aI(xcVR;A h .7dA]76x#Z!TSʜ,,R;H A/!cupp^UOVZ~ .2p!Ȝx$Җ^e̽%{'E/z(;!KY3+E9'Fx8`%G?vXezGXeM*4Wft'B)g'!ȱ4lfL.TҼ{$2 [͋SQf9^xx*N FڔB9&g5aqxZ,a>%)R -zVg/VXsyoEA&ح"ZsL)z,S>c\ڬe5I uW21}x;iD:)*!CM#&vYY4Q:RmG?ff0ܸ؟qI2`b""BسtSkaol2[#֌Hd T=+F1ԭGQYyZ3VrcE!ǎ7!!+Fb-`Gu#vP[7Oo?n}AhљƾYBv >gDTʸLDqjؾoI=߷k )">?I,oc#9f28Pj.DH=vIfFev%& i>„G1ټYZ/t$ܓ֯{|rS 75oZ}S4-tȘ}֖,L%QgwF"m?Z]O'}V\Axii"rb-:kV/pmUş}`wq&뗖Q~/~"C(Ij,>d-1#Y:k39@6/`~uLf6{(y,K Rn&˨rnx| ̢rs'!woeO_J7*6dRqcMN3hg7=gۍ46)2kissuu'x31Ԋb<ݪmG>ٻk?kX¾US4+Hgo gh}K \7@s3ӋKRuӊsuRS fme-w>^=c;o,32Hĝ쓇M 'j(MchsxS?ˋ\zd UR[_ZZ̰"'aKΙv8~Z=V>RA(NMYSu57zNA&f31Uh'}\]ܭUWT\Y\_W°&..봲"+oLn~oQYTZͱR˹39J]C{J]J,-,HMa/ck3G o<Bgx0O"local-service7i:7峳P\Sx340031QH,(+)fe*nݝ}rنyz = o! fj_لHJKRK@_嘡E?g-).̰xXێ}}qˑZc 2`b2d nuSnC5## *ؑb]N:d"mgscT'~¯1KTڊY\e'kq伲DK]7 kJ(T-YQ~-~]VXe wRv]ȯC1KUS{W]I.?#sLe42t(&lF:|8 zۈt2iLU6kIq4fpk1ŝm6,*~!4*2z-Ns94{pDdūV=bvr'J*RK-a˰k*HdjEȇVVVV$` G$ @O툾Hk !nJlBiYƪ(8TyrI-; oĢX`\kGf5* P~eKzz}q/V5n܅Xq\1}- T N2Э'lnjScVy sx+P(*N>dI=0H6YnseA`8@VfNslJKoXlяTQ'}Ovږj@q!#D6ayn!`+[R1Mg3|%WQx鼨J-j6D*K\\cQ^ŐI l"JsKП`*DQP|B\RN50 zLX.b^ N;(>!Ң,vl0猎vogÁ'/LYK;eɼFx6gXȰJ? 'jgЪ!O,gX!k7/";pl{đXrX!BB{%o.W!<{ҘfG?n  JKv+س͓s"4˖ִ!9Xd`A@/⽘Gg(TxIALLH RCDFRвĸU.U%oPEf"S$+tL;Uc\]܀6uEףh-E^v8vC !O k>,Κ&L Nvs~FPx̋ ћ={e`s%4Ix8 5M8 a ʥEp,_SY(F-2}Lb`$ej،rW\03&vr_yXN̛\5'=n+YTɇ4)CY>Ķ&X̳#p:ڦJ'wH*v412Ai^ 9zX7Z-Ϊ'5Cy &0TLi@ՍhBbӜZ-Le<*4=U;Q5c'0YHL cą [.ReB2hJi[ rG=ªU;e]+M *?Nn'l7kiop-Nƒ/--УDFK`r5;{rƓqiW0D Ý#0!2|1P'wHi%@eEH{Tif< ҇@ |0&&Bnʦg9e&#T)&-{ #d&\>'o^!U7rm`֠{DaYJfn"Wnqˠ[htW jF|ob:Ƚ *^ 2U7[v9z Y!{C \IAmIDw=Loɵ]?ѺϮ:Z1 U.lB]שMНj#R<8}$og+BTW;iE4 ] Ì17)5vaEԦF+QqduOߑ皮((5X8Ḋqo/1+ܼ++]F{:]񑱮8w9upɱ~H?9P(\Y*>#ܛp(Y0aySZ`K֥eb/Lb*kk |\H OCrz#0B4#⃯(>Vz@m ZJr1xF<^TN' -,tQ+jqUq J%k݉'OD%{y_qGG+cɼN+D? 2CR4Oׄr'XRPM-Tbtϸh]3hۗ Mq9z1| ;Wи0-&Tws+qQ6, Mvc"+-V>AFe =F&#EC|LӝgKǘ&u2^x{G ZV +*>Mś5[yx<{M[uTgipLm`S:V8}ήzs)xyR9}b? C1+F:yUx~S[ily =NXMqEHNFN-.(X `fVn]8LZ͠8|Pp Y4 ?>6[W= Kep M7UYxw // Command local-service is a zip service with one operation, backed by SQLite. // // The operation is declared once, in New, and every interface below is derived // from that declaration: // // go run . serve # REST, MCP and OpenAPI on 127.0.0.1:8080 // go run . notes create --text "buy milk" # the same operation as a command // go run . openapi openapi.json # the OpenAPI document, written to a file // // Notes are stored in notes.db in the working directory. package main //go:generate go tool zipdoc import ( "context" "database/sql" "fmt" "os" "github.com/hanzoai/sqlite" "github.com/zap-proto/zip" ) // Note is one stored note. type Note struct { // ID is the row id SQLite assigned. ID int64 `json:"id"` // Text is the note as written. Text string `json:"text"` } // AddIn is a note to store. type AddIn struct { // Text is the note body. Text string `json:"text" validate:"required"` } // Store keeps notes in one SQLite file. type Store struct { db *sql.DB } // Open opens the SQLite file at path, creating it and its table if needed. func (s *Store) Open(path string) error { db, err := sqlite.OpenDB(path, nil) if err != nil { return err } if _, err := db.Exec(`CREATE TABLE IF NOT EXISTS notes (id INTEGER PRIMARY KEY, text TEXT NOT NULL)`); err != nil { db.Close() return err } s.db = db return nil } // Add stores a note and returns it with its id. // // Example: {"text": "buy milk"} // Response: {"id": 1, "text": "buy milk"} func (s *Store) Add(ctx context.Context, in *AddIn) (*Note, error) { res, err := s.db.ExecContext(ctx, `INSERT INTO notes (text) VALUES (?)`, in.Text) if err != nil { return nil, err } id, err := res.LastInsertId() if err != nil { return nil, err } return &Note{ID: id, Text: in.Text}, nil } // New declares the service's operations. It does not touch the database, so the // OpenAPI document can be written by a build step that has none. func New(s *Store) *zip.App { app := zip.New(zip.Config{AppName: "notes"}) zip.Post(app, "/v1/notes", s.Add) return app } func main() { if err := run(); err != nil { fmt.Fprintln(os.Stderr, err) os.Exit(1) } } func run() error { s := &Store{} app := New(s) // `local-service openapi ` and `local-service declare ` write a // projection and stop here, before the database is opened. if done, err := app.Described(); done { return err } if err := s.Open("notes.db"); err != nil { return err } if len(os.Args) > 1 && os.Args[1] == "serve" { return app.Listen("http://127.0.0.1:8080") } cli := app.CLI() cli.Out = os.Stdout return cli.Run(context.Background(), os.Args[1:]) } @Lx340031QMKgx%>gݧWǫֽ]2Sxn0Ư8U2NT@bMJ\L&YbiUO'8IU49Y,8ZY݌p'0Yjk)PE620-kc gţ\7Fx1q]_hNBbq $[y, $T7hZsS h'H6>jdݶQЮf\;fd:# L^nY[ZH:/U9(ƄUPKBmoZrK#3rfLzC?5 j,E~5=:`!GϤ׸ҥvXT=І8O.$h Rdiqs.Ӂ -!ȯE!պdq,byoaqo h}=6]ZC?< K6=~D%t¯-:66|9QB-hYQ o/N+ehEPqr~\mYeMH)(`CR׀?lRB!@5v&][~v_th#$BZmY-Eh<>99M_-#x|1h/#~h OEZp .ra ?}yGD+rѡD$&1⹪+fxEn0COᠡpABVh 4fHi OQ#p] 2]>]zmtu<})h[UYUe jk݂<"zk)| v=Oب@ ֡) X.PL S Fu*bO|n|>YA@*M?oRh N %\`Kh,`^~{ˮnྮy>-|$ʄ7XCp(յ{$%0Z25tlRݏѫo~r6۷QEL/[-$&;L !\} L0./RrY$*(:>IBIⷼLg=E>=#sev mg,Y{ +[gH7:]mh2+({x֜a=Ɏn+#icz^|?zax340031QMKg(8ȇG/W½u[xuTQk0~a%` 2F6Ҏ=)9fK$KCƞ~aNrBB|V,8n'yk ZrplxɍG˒w"y8~Յ(*՝KZh6w@EjEy0Xi}lsK_^cZ*Fp*N.<_n[y??;`\%Z(3܋PT(]:%}}=K_j^5Oǐrc)=Z_Vi>A"pf}ަtmye1,0> \mύv3Hw^tc^ԭ=?Q 10^*Ӣsdb&K*3 8tZJ,*yl:[2ئ2w6 oyLH’sBq}D:EC1|(iŖpahupoIoJ~ wC!@~eqJAn)6rA!+)ߌAi?vXXM$6ҵԄdHcmiΛNHqmm%w N2daЎDagE1{1}1M;4xR@U15(JN J "QP]Nt_njs'h<;yޛף_`z5)Kզd5R r˭f@m ҨwedC6vhm R7XπU`FEdH;%0x{$ fb(%*vz 4bKPWsR5 0${"*A&0Zh5X!8zDܒCR! db w@ZDk5*%ބoAx340031QMKgt'=.;JǏ 3xVn7}bd+O>vHmvQEQSԊ.!#@?_/e $^rfTҫWՇTTuV䪢HnEp0^-(:ll8/R24sRml |x4ka67hJQ iŸe{pJۑ|k-OـX}Zy@9%kUD©B/UдlM@a`J|6>js)[Ӧ! [*c k21S#+)/Bz>cz]k!Ny4>JȐ{^bn6lTQ2v84x8IFZr4g > ܝ}8L͠ |k{h-4N|_XREYY3_ӭ)n9]QhKl(1/ v4w+)|x!³Hj=4P`)O 4pve{i|0b,f؍Z{W8v 12P7 uA94 ӴW1E^@BGc7&%&>ZB#x؃x0Ѕd)eýҥw/xA0MH{/QEU%Gl6uh& pA+KuQ'K&.Iv\s_dMŰW.-Ƀ 2Y$X^a $O[_CBaBuۗtSԿ~I{`5U]g1:U+A <(?| alxx-a*ma,"zx340031QrutuMaX8fUo>쓎&@jucI_1E"#m;չs)j<(3*AnxKK$Rq{^qM x,W.b 'x340031QMKgۺFu%o׮*UɲxuUnF}bG dNFh܇"rInLK+` /.)AmfΜ33Z,QԵ}MAdž+>Dѿ_!csz٨eh})+-ł'@F9E:P}Pk's$A0ZYl'W]:%9|jِX@+qO .4-) 1k'SjGJJ7'mx j>G~߈aԜnWG[d9Qɠ-@ }wf*Ę&wmM"18Q}GqtT^:},!7N!cؒADuBb ~2@,MI. Sȱlmg:4MEL]vlE-͝RfE)m/}p &g f2&'ap# Cy ? ޽mstf-tJ5Uκ~uł^t*gW[vuKW:^CxJ*.7(X=`!.sv G['pŠ{hp}s t'Z]SUU(;N ,$ܣ`oJw5"z#cNg'YqSXSzsu%7m+@Nk0S;\ ׋m%̣c̒%z0I v}bB䭼Uaߪ2;:yЩ]U4hf+߳IłkHdh4֍mY-V&olle]Y\>qoM0D-3Qǡ?e>͞y;*:]o5j@J:,iX9y 0+u60QۖlNQJ[ዃ9^{ly~$ Vû}6?H7bɯisq Eި@C+ۛTbk|+5K7Ԧ$,w Bãx340031QMKg`9fpSEogb xVn6L]8RnEiuҴH JIGgHʎC`}}4(6YFji¶IQ͚#mȳIwM[j 8U˴a/YW҈䂏{3y/9vXSN4NšW!Ʈ)S}PQl%T̪A%ӶVal.-;Nî6\_N. '͊Y&>~me!۱SA[$I1'cIc!>x{TqU)fZzusbK33C8[Kؔl -ǡwƓ5Lax8 sض8JcڀP͎"e:E%R (x}qZF]bP +UTcr(u,*-cV9ʿ(Et`c{-MXo!K8Tc^F^KD(ADvk(F]BJBaҍI>|,Hh32i@{B:ZP H 4ٽ䘪pb.&t=yI]'dt3|O; bu|FR9og+ϡkkHi:(Rn' H*w,8ΧB3:.`0;MrAdhFoy[yر*j.c(+v۔^ۍU,+e(lo{BTʬ-ުlzj4Bk\UζP95Bp:ilmj`H Y)X.n"1]A`}]!g9c<(so1t<ȿ~=>;qfy<ȕdplx>JV(TzqJ]C1ncbA4 ŮM;x}w9=B"o_\|\f"NKj/8NkO}C*R[!z)q+( MR-1\3ESlHW\A lFp ּ[_Tr%*e< ئqE (Ĩ4xy|eږ>~B>!ْ:unXUzoƒ + #_)>!Y`I[ 'BRfγ,DuYhm48~-6…">OvVæq\oKQ tWDF,[`Q@W"eog%ON_q|rr̿R|)3. Ċ`)8^Ky"iL3UTg ax;p +q"eQlEDVvm{,&76G ogɍKڍsCGE ƭa& >:˺⻙$8]̒G?> '9n zx]QJ@%Şô%'A zTw'ʹ]nƠE<śЫ_Ep73o{p2%lDM4Z\gCn4<%@ʅ 5L+ąPSxxIRӁH~VI^h5]}g")AB]Q Bk Oa $H(7õsp]Big-HТYzJB`t)浅˯z#N} !<o^sŤp[.+8?;kQ"%|VzY`U`*i)j@) fkxCDcLi&U!G9ȪCer05{%p i gU&Xy,7KOx340031QMKg~rDr.@es,z. ، fxmTn8=[_1b9$wO "q(hidH8E=~Ig(Ev Eͼyސe cCIU t{tu={KUA;&d@W$e 7NW0C0w=qގ1A΀5ėrH;,jrG@xpX`{g34*Q@zpr׆ t_+ }AZ25@jۇw0B ܮ/@/ IÔ-R|/T\a|hxyh0 6Fp5!+5VARƢ0UD׊ ZƣC+l6pY7?hZ8T[IL_ CR->u 4ܜ|In)bث:[QMSLޏP#sBK$aQZHRgﮠ6UѤ.HX8E!VTjYAR r8'v;q~pE{d46 -nQ)SX+jiFbR{b:B̞Ή`=c ƙ}Fnnװ5a욋>ycX]PF'NYdnFM̎Av&ؑPLW>`J.MI>'3a-Nk(э}>vMZ }vGw Y, `쬂Q[Tf7RIT!H\JKއ1s3s+Idq(9B28fh6cs$|CϷ/_g N(.:4@kYGy̐ KÀCqzf7qSRM׸~lqQRr '7nRϱ,:EQ\gғY::N1[ux340031QMKgmPy#$f(upbxVnF}bV4dy)yp_'}WژewQd@?_/]Ҍդ( 3眙anliOhZ_I'oDΩKI4Y+-^iےrT5NG },Rފs0z-x P+;QI\ E||t1⣣HJˀVZkl*]NBr`o-d^leqg:ԯu ^Z=}E-tK2n1Fa;2zpQE(ͺk誕zE)Fj?kT+I蒃q.kBNf)FYYᾴr巤g4&S!6]f7K:`~v`Cc[dgA6ٙ.)+sl6>̒P:ILg=͒ɔ-%?)M5MB6:%h[ka>󵽼QeY&i¸N&{8F9H]J]i-*o9gGѺSu"̹kmjKiFojg OӋ9rq3pLqNgݹ霜EjLR8S\dre°"\Y j,:'c+SD']ie:7 mFCeřE'srgFZh-l3WeD'Or6fZIgbm '€plalG })Sy➞8 a l)r͵vڍC.,>žuҊnB zn 񝇨(+nAa@Phjy8G:4 z|;bͦ'z!/] EY2qqvM =+MGOIiv\x 1fhܖ1GSc .#Yj+`j,CKtѼ+n|lj ]#c2Tз a\@l-@> \\mS~qNZ1MTa7S=`?|U r$S>c:=؉[l45wӯ<j@d|URf Mp|\B;2A8Ah RtNVCZ-g)& >B_j?Zk6~ovSx340031QMKgXt 7l,nʱ-HMއ Ux}TۊH|BRy0Yr\!mjFtф|Dpd<l:UǮkxls͑FϏ*nB䦷c_uOvGCU}* EШH6jm_<2qvܒ5FlXc!aRc%}^L2mH%5-)cymcL:zΚL$= q5D7p aSΫ#,pVEJX )@!,D5vgRAƶŻ!-$}`IGt ]4M/pS?#j1KࢺTO拁HYOd0K 'Q|vm揎-~^I:yVpu9t]3X6iةaU(-+ <YɒLaUS͵BGr}tG*<{WVMGnaܤhjT DB1db%}%xs=~a)w+BXg0}J {J+ StW _yMXWMp. T lNEStoR`O\ ?kۇd/4;C13aȰpJ@yE#p8&,|JXO cXI4)=t$ɋ) ^ՇVچi~`87VM|{zi5 T~\6Gz.l"UlF)(Y!?x[Ľ{N +}XRƵxUMo6=[bV@Z)QmEK8 z((LjIʎ__7dŢC%͛Q+QKzSmEk$ą^8&zZyf1}O5LCl>Ą,~{N^4{XB> 3$?J$ez{;Xh4jxZ@< \\F` 6Z7u=Ug7?|JiN03J).YiZrʣ[=rMW+;"glXJ4ͶcerI wjb*<,_3 "tqi?#vҨB蔒Y/tS]}gh鯨FEk+9GG mLGPڈDq8$hX>'N զMzʁÇux% x2h0ޫ }XD (xxUaoD 町/Ak =wRH=Wuvu}?_/J%$ޝ}޼VjQoDoʒIj8!lӃ+(ڬd$tBkBqz&IT ReÝr1[uFs0J 5PChNڶ@Hv,Nh4z'υ:zԍ&Qjr=D} VoPQRNyA;;_^y}~TYwulRwnT$4F |JU3 Uٗ5Ycj}; uVPAl߱w3aX@S}Q<Ts6;42$'|P;?]"y{O\Qe OQ'g7w^̂yJ`﷫:E^%RW;6૊ciiv➂kΓ5S]I,BniDu٩5^?in^B˂kq@.2I4|p+* ҟ-tJ%i qN*4H:喍%d9Ԗ,'c@9ABf`)W/ GmQ9=Q]O)٭B}O~lHzz7P)⚱:&/@߆xt 2$ 7Sq?8^cϚE;ϛŷҦr)ꦑxoC̑c}oxZn9|vb`!;vv{ꦤ޴Hٲ؏//٪CŲdo&cI&ϥN 3'=1b>j v ;C|y8 k51T.UW˩L2^+gE2|!+SSzʔ+5&US㍚KrsSvj^.&}|tV/tYTn^9Lm+Շf&?Y?1G\5W:-đu P5/|n`\Mu9^j1Y=Ny-}mJ35RLn+FI7<_R]EQ,_dS!y,_s;}\@屫TCd;pjxu|fFMixa3ܙijz v&ʼn(L u~NÛCu_$SOo*鋪L+ѾewM&^'e$|R~{rlQRܝ:}kxHVG/pkW+1:'BVY*}"tY ]t3}G?%x!ږ'o?' u lSef^Շh'X'/÷gת8!eU<hs9D9 '.a҈% q /kp@FVK EZ{]p8W!a'W6tXTk* RC$,͑&dS̀11/w H`D=!7\;2+ObP|ݔ>{^x(Ĝi|HS4E-U L)zBTQ3=1cAzxv@gVdR-|9C ̀b6emZ4.34f 2E؇#3`DVlX>t~&Vk2SM*Jds؃q=0oE>f n'`tT- 3b#].yAjisJJe%H6$Cird رZYn==li;RlLͶ#P}Qg.lR{otn9W$*!ңS%-^9r' /xJ߅"*ɤ27?Qu0 q'A(BͻH$H=,]ڻhܯD|F N_2Ue7Su3׫7n21Whɠ(!|z̍ RУQxv27Htuau6 pX`@ࡴ"O4ȕm$ZF=-7 o?}"x<}=2'c@7ƞ%OHߢ9=Qc!RIaqp<\"w, A S9!A8SŤBgj ...eBӻ#,-@lT=)O -ϲ-BTT+X:0C݂r5+P#K*8F[5!&E)1XZ4²EB-Gfe-t1,az5-㠵}uâ)e M$ٔA Bs }&k><`W@D@n &)e~P1?aR$ɾrĤ6M&B> N<3 }_MFLtɞ1U7-ڰ 2a4;:RpZU`:`pqKIHBOH Ϣ7(]M*LUxQyB>*@?MYvM0# Fv@MG%%0mA:Kٍc#)Nexw+F͈ EF&"'y}1ML1x=ϻ&6ݨaptC!O؋~hf x"2 Cl cDw|W;Wk x.,hd3dz{h_HC(l@& v `|ǭUݹKν$HgLM`!0᝶:Vbuӛ{ nGtR{lR-Pn.a{__vyLWloaon:IXwmvC"ȻXLGNlzuƑSc0"Y&0`[:7Ӷx/=\VE X 8MS!4?,k)+p qIK!)1m<.}`fSP1v 3d 0 ,a4`~@fr(gfr2pLޙyE1Ti&|; U3|.}M:q/!?Qo8ڲ0]јbCCbpeʼ+5h9&%\W6)'3dTmxvC3ainOPlUo=Gp}oˢ~B )p<7z2I%lY`P`n2RDpgn12X@0^#pEV)h9mXY[X,H0:{{6a#ൎ;w(2̸1D78,TXv}un?BgIC WFH p/6_50EqYL/s='8ONXUոP +P?ې[jMSY?  #kz)_rCTáqWwuheҼǂ M}}|Ģ|J"r897s !xXaoLnIL]d-9|hy$WۥvD#)n `ݛ}-Tzfa)G[Il1?v>:˹4Wf/HѩW)s](2O.F?9wظ&Fmtif=L3?En@ބH2hr@rn9˹5yl2:ZxwH^aœ+K26<fRo8["ؖf^~W MHJ _$Ab:|g09/t"oׯ"qu>Tn2 4^-#ԍ~bq-!ا-U~M9/ŢUe^(nh٩=`ә*p&=:F'GcnH~#=J^> q 4S >0{ B.u7_bw9ĖױP=<&oM#|wvtqYʯ:ɹ 4Y"ԏ..[ Jd"ߩi'zy"Nn 2ؐJe\~,_BIq 9 V?Q2[1mܱY*Bhs97i7W^+r9eͤ W 鎩sSh]< Cp%\pjgiz~afx λGK3ـ"^!dWR)}M־]sBE&*W;hq# (^4TiL{8AF~uvgNIW .-Uӈ6p> @&\jD t64wKdSa b]1y`K'aX ¦[J' Maa e.(*{|u\܃άD*qC\q~rwz\IyQ4Thunm{*lu[ShQѧ/>@&O0r"gdc(1Ch5\^Bc {@U#rmYhx畦\*d([젏ik%%اcLXX;i Ҵ̱`gv²ÏG@Dd]-bV_WH7"H:Uj$:ePg.3YMvhvU2 5 O0!CS(ZZЋt $6:L;hܩ Wvr1L4zb ˲IѬ⬃p j JZֱbwZU]S65Y q >VʹI]j_ `Q.e鳞Z<&tڌLl.7=[:rӂvd= [B ԟ4PC0^FтC063SR(;u gvCX0CquSHnX+U$x-9Z?dcńu;P2 g.١Fls&lS՛J(SFsʈ?ɷ*úoBNڀ~p/Ϭd >P_XF(jvXOoj)T֣rMK"n1*m& 5vŤkDԲk@޳e YKMw %|I>Gn7Om5B ?ۊ{xuUnF}&b@]PiU|IjM$2R027vݥЏKzfIɲ̙sfF,E&M.P&&A2-y8aCP>HiEAiĐ-=<OБUJʍtn>M>˕"z``0ʹ yMo#%نR{zlF_ }/s0 ih4V . Mfև /C''Cݮ?wJ(;Ӎ.fJ 3t}#睖!] ա6Inzr&@ r h*2P m|u yTʩDpNBl|ࣗݘ)lDL̦W4)tGc4-z60rnӺ yk7` ~K]`Emjd.ELVM- RuttRIlBy|s:\}.76V#faps(-B&ݠ 0yOJs", k(xj@ECS#L1)aYK]uw ~D_ҙp@ ƋF;V_ՎôYfyY6a( քjDeHڤ 5n֋TIS(O96:[bÊkRVݮƔ/u`65OA!)[g(p( +yZN!]%. {O48NS-Ʌ2w&)!Vmҿ!Pi,i1e*hع!rJ_lkQMnWgϮc"bd*iȯV\"ӳ:pI_>#p|FF<ӓ8$BcWC 3>7!ș6DvI?Ґi>Od>N:zzcU? P"kI[u b"=.N{&j^lz*{p/?_z)"3 ;H[:9OxY]o}&ŔҥK =Hv p,#R PCrfw4c//9wI- ̝;sKQ::vQ*d! (uOmaˎu 'EX7va}<0o&iǿiYqޠ?ú4JSu,ީ.~~lOn[/Y쮭E\}|NUVx_*[lnrofs|u~{V2ijZܦ4UXˏ2lj5HiGF,\4HFyWJ)0uPvQ!2򕭒aK$X&@0^}#xRY܅CS3+һ}<-wȁfp{UH]#9gD6:dD#PosX5[c37n֢|úI !ALՍIv (f1-tC䨈BiИ%C<=WO{,:N6"Bɛ~h{mW/LfرƔI跈y@PklO}%0x)11 sockDir(tr sockDir(t&`d@̱~xpackage zip_test import ( "net/http" "net/http/httptest" "testing" "github.com/zap-proto/zip" ) // THE HOST A CHILD SEES IS THE HOST THE CALLER ASKED FOR — through a REAL // mount, not a stubbed client. The unit test for forward() passes a request it // built itself; this one goes through the server path, where fasthttp has // already parsed the URI in order to route, which is the condition under which // Request.Write re-derives the Host header from the URI. func TestMountedChildSeesTheCallersHost(t *testing.T) { seen := make(chan string, 4) child := zip.New(zip.Config{AppName: "child", DisableStartupMessage: true}) child.Get("/v1/child/who", func(c *zip.Ctx) error { seen <- c.Host() return c.String(200, "ok") }) dir := sockDir(t) sock := dir + "/child.sock" go func() { _ = child.Listen(sock) }() waitSock(t, sock) host := zip.New(zip.Config{AppName: "host", DisableStartupMessage: true}) loaded, err := zip.Load(zip.Plugin{Name: "child", Addr: sock}, "/v1/child") if err != nil { t.Fatalf("load: %v", err) } host.Use(loaded) // First establish what the HOST sees: if the harness does not deliver a Host, // the child cannot be blamed for not receiving one. host.Get("/echo-host", func(c *zip.Ctx) error { return c.String(200, "["+c.Host()+"]") }) er := httptest.NewRequest(http.MethodGet, "/echo-host", nil) er.Host = "lux.id" eresp, eerr := host.Test(er) if eerr != nil { t.Fatalf("echo: %v", eerr) } ebuf := make([]byte, 64) en, _ := eresp.Body.Read(ebuf) _ = eresp.Body.Close() t.Logf("HOST saw: %s", string(ebuf[:en])) req := httptest.NewRequest(http.MethodGet, "/v1/child/who", nil) req.Host = "lux.id" resp, err := host.Test(req) if err != nil { t.Fatalf("Test: %v", err) } _ = resp.Body.Close() select { case got := <-seen: if got != "lux.id" { t.Fatalf("child saw Host %q, want \"lux.id\" — a brand-resolving child cannot answer as the brand it was asked as", got) } default: t.Fatal("the child never served the request") } } x$x[&40000 attributionGO28mmifʆq&1'@|?i.0YѤIB<lJT4)xB40000 bucketsGdƼ G\b40000 meterqlo Fd#6x&100644 buckets.goYvZqmFx340031QMKgZ,]néE>bg. 翃xWao7l.JUr藪hrF4 v)#A@DCXI ͼ)Zنkd)Zk֪O|ŕ&[ҪP8N)h9ۮP|4v)KnY Q;DN*Rk5E 9Vvhz mHٰW l{G+lU9 +A|°Qvjr,}c:5&yUꎑMtSY#>t6V-?˦U~V0Dq@zA6ZRZބ1I(981SQ\ԫ=BGj:Y*:8BPM5&W00, uJ{A#ָI] jcj[Peӷ`wދPb x kYp* )Cd1wD[g|>XP]zu9%Ó_吏ۂŘə1Jc% -7 r-?A;k&G/ǃk7Z2{(xAJAE ­ (d+p:53Ew誘 ^].n==_|Br2Z,L\ %@6Fm6вjMRrԻ*RJ&{V0d޳^S]HS7r5Qԇw܍J4Ǜ|>!;W_EZ6=wa6=DK xh100644 emit.goWV۩#૴n976100644 extract.go NL*y\5l$${^100644 extract_test.go1GOE,P|y1Q~40000 testdataNOOcٝ n:2^xuRMo@SbWԤX!uJR*"DA ZU&ئm@QEˍ#'8% q?Bp׮|۷ffeIl===}cSJ/ȰG\.XPq̟la'8t1V}(1dɟb6 ,m g?;Ga*e. S~b{Fc#S11aiV+$lB OY18vG)r.u MP`@R޾*VW' L\)8@åPN:BC"`!6ؗD7. s4ɮ,MӮ"mHm-mѤ.GfGKb#~&P$(jt#G\1Vg'wNߞ,xJAAH*/½.B`)enw3 !M !O`/"ݻ4Y7X}3o5[Oz)7zI`E8@VA1PfeP@ϺwqZרش1Q]"bs(|ϝcH+z$Ko囎7 ?>T;N3mց .ǯ| fdogXoZ x31ĔԊ܂TY)}O%aOL78%d3^f=gbiZZQYQRZ 0J3kG.Q!s,M(IKeXԵtϷGkN\[yl#Ԕd{'\+X~Նgc QAay8vI,x삪ɚE!Wޥ#iբx340031QHJLKgxo-Ky.jW8  )xeRn0 =W_Ð]0hVf-6It4ȿOGRu{mOhlGvѻ" ;tN#F84l1]޹h,6wSꄱ*Z7 NK4)tj JScVE&jV;x5Hw@HUׄ1n sUJZtJ=/AT 4 gTEc!:Ɉlνbؾ+ H]JzE\ˊa?̐ڕc'ν8373:^ob獪ݨuui&xC4T\U%ʕjnt|:[ Z^C|r֨yW7QͷlkgU\nIUeZmVmq]\a%ڪ65d 7Qm겎*n[C_vkc# DƓSuץ[N z4vt䊸26twhT[:b:?.c(/Ft3la&mIokxb~-pktDFe}WFu;:7~6+8q' LT>BKYP׺+bVxkW+VCT۠VnnKh+ 1Yf 5(m5bǬ۸M|pk ̻ot ouk*lVS@-b% . 7K4j9B]-BkJlSQڅeE!L5 qtCM%>4Hfp߾K?ibil =0])qmF:G(]X*e|4p;2v{?A!3B *z}mrj/OOٓ5N6N_J;&["\mSDꉁC+9li-ĀT v9Xqm'aÙ &8~qp:%$+4Tuh'] OU> A2\CCӗW`1{n*p)qO01RrRhK U>T]Xl*7JUT9pPl2JQ鍜O/._^)g͖DU6k* 2Y ъ:=7!Lg:stt<(R߫Tꧯ_gcu yڃqCxǙd|H^tv\tBb $ L9;JyL* ݇o2UR3r%Br5=|DTA9''Tn]7$yG%(U:d(q}9N 9 Tc4m` ҇p~kRIY2mDJ+zvntBǩES7W\@10`G p˜ԓWf,D^p=;omx8c%LT *K8~AEwGn`#DK^<|™y cf̐y<ɴ׫ YLՅc m[O*24t\eT™ʄsCoMkƊ%iao9觗]:WpESGX?3]ƛ[R{/3+ZER*pP* 3YOszI`ԕnwKረQ(Y2ex*/oqXrxЛ&>ys@#5 Ja 0PoWxy,Di MC9]ؓM=- #bOÙeם gEyJC A(#WCnr aJ!U ҷnm$^֋7N@L Z/;S/ gj@޽c ]Ɉ LLydҧ۬l_ޞ 7r;p]0/}+OxPH}JOr΀l}K C.撵̳{N]omFdɭ-,kLv1G p-X50gƥkenVir2V(t[16J:Ew#2}vdp~Dp?scwkN-l0-&ӹԏ hϱ%+7C37<*`qCKTz (1l[־( 4sa0lCeT692/kܿHq?fo9˨5>kx'100644 accounts.goũ?fayVptdx;{___! 19;1=U89`"8+N,h *\ʦFIX63D}fMCH$ч1;ɛL߯A`2[l~7[yR-ʱ# I\( iIDʷ;pU)T#?EA TU4k d/2 YyRas87S6:?$Ӌq:gWA#Yȯ.FP"{X=d&줓줓B ɮ@MJG5>H^srTgVB䧛+ m(Qt!Ag@lȖg?"'=Kg&-k*ErL@NGɍ?qKG/WI<qGaM3k W-O_'0Ϯ\WdG;iK7},_v7*k麶S3h"5`):aON|fIuWn( &P7aƭXmue2 _+u%•|ŵ܌Z:;z,+7 wh#vY<$.>YzOv/jR#g#|p4=mP]`&颰EA+f(odҬuêĩ)Bk>wb% dMU _oYtXI\#bڤ|Z%k%D?F=#x:}ڥ98~~z?A,`qN`}>fBzAH2Ӵ©fl+tLb0\z\v&J6LB,}Ypx. C"u>ehJ]L[(@2,Jnv(hlB  mY5Yf9<7!Qg$ { 7d=IG-wed˶S#CA[% JOPͨe߷ QD#wvXK&2-ym-rᅓ S |^S!<Y&X0?9鿑^-#Ͻ1aP-X/I>!P>cȻp* )xuj@Veɧx_lZT6\ )|Yô'S6Y zɊ)7/,:tq3J%4K( ʛ+I@  t+z5܋g^^7KHxY (v  :ajPJ[524U! B З4UW((n bo^؏KF=RY DC(ORpw1mM10mP&beRQlF~fU$fp=Ve{9V̡+m]ݣ)鎎ק`=u=6:^Ƅ,ML/TʃZx^rzhaya[#tJKRg-SrE {GؖTUdi ;jw]6(!oR7Y0ve- zu0Izq =if#J 7_=jH3zڢ]F|g6Kv]E A?5~2þmf+MmR89e8 [I%n3I:G(`}pt@O>h*Йڅ (iuu]d%!hWtu.x85hRD1P&yƈ6cfv܄of0sE^YCu2)O_/ a+d %_Sx{9:rP[bPmAˊw?VZ8k Ϲ4"Q`M|ry\-=:p\LFdj*xz"=?$=ǜS3.mKĭWfl+h`~-u$dDounET6覧<\>KP!ӴC1BΓ!mj8R+pGH<8(Vǐd}oTK8*,-K ̳M" htQl-گ:Cꎆ# Cjlw{U[x)=kDUF;7\]kQX N| K9ϗ"ϥhYѐm1t"%h]RB`=)*e%D&9f` u@2(aȃD (dehg`^1 ]3ڙT@#LsdK[=HW5;`Z\vl7vUU1BgA(XLTD%ЬIvf'6[⳯O /+|I[0w=sΙxz h=kK:L{`c\EY_ oyRec:dY4,fƭ8#.xAɈh0+Ujp!+`ZP8 N_m[$Mn 14<ԹP]_N-B"aqn, 2:~Uy6_-\q oB5CF&,Q,ݤBWi!Y WD8Wwe$npabLQ`VvHZp% Y’A %޾GӰ647B\/Zuh\GYm .![3scBf}L>8h.;²|罓3#V\8 ΠKxs '0[XF12mP ߥQVci@q6H^ c2jQMqM ?*E;拳,x$lvPuiʡFmqVު4_Vߖ & QH숼uyxB[t}T94\Z WD7yM/0 Z;hFi^;KnƂnZm"k >0c@JɯP%Yj-i2h*G/ReM𑼘@J\X"m@[*Bɠ AH,gikii6[Yㄽ[phw9;,x:{Dik/<rb'e|{ 'GzIvHr/aw>^O>W3:;cbc(<>%;;bY?H>FBuXCÆMcM6$jwV\8[byGܳň'x&|Ex#gq~rKfF0|$yVv ŷxXr8=K_* adkN3&+T!S # KuhIfkN~̮LE=2NAUک[_*/lﳭ4}ЊE`:u: ^df74{60 GޞxpzPi1KϪdRH?G\R]*DˆjyM^dQW'UVyUaQ9-VٵrXaX15rl%2iL,Ltj)WBZqEuu( JrwdY*# :KS|* dN4E?wvc*Vy4TyU*+-mF6=xBD-rbvt"u+3rg߻tL7oOaK'0IV"8+&˔ cd'UDl)WMbp,*JG2 'S&8WtU*>Qgn-|=:S˴EN$F3@j~rJK0ooAd)m [иkFe3]mʌƖwpA̶0-%+@p|\]Z+ pڲl9;t,p[ιM֛pLĽ8'$݊w$..)J8KLi(=1᠘ |ZD@(ͰktMS# h~'x3JD+&1IvltB׍;j!1gp!33md> !Pk&ⓠ~n$beLeFC!^#oO>AT2@aGo⍟xCǙ?})\̱x ̈htG$lH]ˆzD&v۹(V^mUVK$AoxIzl:]Igt@ҷh8PB>t}7c\穸aa)Μ4|Kh1b\ m^M/t5ك˄{EtG5>DWR(ÞV~{`1 |$~tG|Ѩ/rOaQJؼfԴDM+CmSйMDeSHhؽ I¨Z_ 1Q3-KJjAPrOs~a0li;"1-[*&[IE+VIR&v#bhDT/ P蔎iy2& Q$_eykB\%:AApuhu}PPa[)êElW9lh^"Uê&8q\ZHȑPߚ b̵犙ÄzLMpP|BA-' qK:JAjQ560@QдȲ6RNu48@Ѷa RMqx(X[̎)5~*$IQU\> Bz?kyǝ=RA`xˆtIԃ,+"S(%L~K'!MI/wuIǹ~7Ci,V`?ݥGKY4 ?Dko04ȃ.%P|'M4Į gh' MٓL`PV+(ED-. ? WiߖP2RT98?:9Gw[ݷmiJ}Rw^]k!Fq+1I }A"~bF_#J(]@m(:iA+זgH6Jm<>30~` |n{FȬ3)B0='c>5{qF `Vym=dLu#.HlH`nq;cߟƌ[F$.byG y14$ni ̮gTL0rx 巔60!{U=g}X82bA Bg_2jz!wUVOEz-q=pBWHKi|IEOsKe9f~፸xE iЅ1{ 4cmJ>ۑABc{ :V'8qwb v~!(Xg8ZsTy5xKĪI7>S s7ҏp!|$pnhӋ첗r)Ea-y˅M OѢwyfUf^E!nrǏ;:-!;BDJg=f eu 3Ůp:^WRfoAs`BöFBtqА/qt5 vAJ Ir'UjJrshm.St8M:ǥ6OFlמVʒiレ @VUy]S]8KYW~ w&YoaR]vN2.K_W"zp :>iG<) lޘ#舮aOaN*}= "VU' m4a/ٺDSf NTTf ReIӕ0S2rJ cACr0N?EkgyYQBLϕ)6eyܒ63D™Պ`QCa?1YXr*00+DZ ,U+K A`kUJ7.J]\JĽ!BMA " UUfx9#Ld?(%S!`'$GXr1?5$>=zmgU\_9A]~"ðU!p8Os =]KsšgU= @Kc] T})P;*(>hw4SIu*I-B *YhE1_F Ģxu+f#ڊWUNw}/{0+H~pA%nXvEE |F-!~_#铹gT6n|cd ày5n eҟ0.fs_8UҡJ9hP["0{!لsCb%, +;nWdTE+QC$} 7wPXct#evjWҩ1QC~24R .l-vt`o"Nѭf7jm z&?Xo-=?t2m_ɿￓ} H'ǜK~W^F-H/4>1SLhpwl8ߴ$;VpwA|oضv˜vg`]S͌%;6$~ܼo-4_Sޘ }8V >5|%}!)Ք3$D f۬6NSe{"j)[` oMo'{u|(oxyWO?őv7Yj&9?nr:'av[OO\J<q?̗2حg wYiV\[ Z~̤2˂67Gd ֠̈́=;}V7}#n, Z.i%x*iR-`^:3yxlt7] 3^cv 7^?HrtK:?[u]Őڰ2h4o޼.u.BSƟIz8P3& N~)Ưs~ֱoa >0):xT?/s}}fM6xugp53X]S+tI ő0 ]v& ".6 $->L( Չ-7e eeꩯ [!r@'^Ù]bY1rն45jy3Khai@v_ > $WSY=gM"BrvcZ>Y,Sy̻}ᕽ?žgT~~dcJh5~?^hk9p vfo-6PP!f:VgEשf S^TT|W)JBn˃̌}77?Vf:Oo A$v*⛛BU?___~`H>뵸,z9 Dtfzp唫-lڝ&E*Dn)¥Qch+KN ا:VoÁe{lf);s0XxZrF}&b*gAĕڢ#'8Kb6CA0Cъ|D0_$Dr%EKOӗqs=5ꗼyek~/JmGOS6OΖ|0KiJ~y5&8we~jo|H $?3-Βw㪶ʻ݋/UQo{fHt1Qv<g։S2ʝB K,l(]f\/0E;uv c7.?TW,/r֬풳,-4 rFUy%;Y?SL+omvaxOE",Jo ,gFV+*޲VO&^j \@gF.;'JDEptKʔ4PzS]BG<&Gl^H6< c[&}SEU(K8hze^2]Ե)(}m?8dV@I/j#Mj;W_>SS[h fAV5m<0QYQ+/jy[g/Tj$^8@u|zꔢ%Gzq>ٿ'2USV1#D'Mpn:@$x{]^Rg.,=4T1}g.I&c\ς^PQuzހ-9*",@D΢2:|*(PXjs7OsfψzݠC1ܿq ltA$`a s輺 f^yb_o3K.}@b*чԵ2 S6rɷڽ &QN![C]''ϠE87R:֭51v 5frpU Wx ;Rs:x:Tł I`J灘"ӓĥd nd@`gYaY+Qb5A.FzDI'>ch8Ke o+ :$u }툿8#.|}H~p&&cĩz ɱ!?'pɏҖCXX`䰞ƃoMF%XĿo!> ?([6+crcL11.|~xj uJ"{܇s\\fF 2n*A%(ZH߈rapa A nݰ" E!Cq~gTy2Aj} @AbF(ȥzt3@slCC:Ædɚ |J{_qD]'"!0p `\:G(Aβܩ w|K ^M{cuR=xn (,faH2d) LdDcnmV-dDB!3S_\$Os٢*TfR$fҢd6 u}OԤ0pZ$XCp9oC‹[V&%NR~ f9oNXFק`F[1]]4z]]t:Pz$hb5IF$[3(1˃E&6|aꆖ % &!6 [iN?CHBFãe$$B| @PFwme*$E#mf yr'JHk-J@ڝT025^}ʸQ#C4b nX=%^ Ҝ}NPڍgȾF_l"4/,wk;ik&-3{\F&CM֗vvbSOz [FYfJ0]jo"deQԏ[Ma]D2$ѺuϦ"*hF&4,+75uȢܤP¿C ƣ3of]-"E|DOF' z [R)12wۖ+c*GoCngk.{Ԇ)g0%_/$R54| n?$< f%t/!m؀5D,ֺ.v悒qjM=@!+ f xcEvF ';p8g))X*$9fhhZm2s89KKs4*T˔t@48k7grPŠG"`{2xYr}UAуײJֶʔh]X3*/̗tπHRþX\{NΌ+~TSMiz|^QۋRS:dy9jMi[>zn֜'/TTNu3ϪzTƙ!z^-+MZkwT5/jl(*14rzS:>.;b4#當|U܏pH'8իgg/ Ębj(:_urS`L=2 4^j7<6֝f ]"٥hqPN1k$iX"k o^8鹢7.Qc@FF~kꦴMl[ rg4j4TرƺZ䩪ɵ*-MzL1v DMrg`?8 zg/O?H\h@U;U A}/=Ɛ:hxPb'[Ql D\m H׵=k'G3]"zA {92/z{cjqtD츙U޶B쩯Ym 0iyyL0W(hQro5xu¢B=~܂ʮ U )_R5tQ?OmƦtUw?}<]MUW!0EݘT6}sWty)`,xk-G~jW"az}8t6ÊKBc`c?wD^?F'>Z;*0fզΘKr\BMJy@]rSp P=l9|ㅀSju{']iQ?^㿿#`cs ;ԕq3[Lqd+9aredRd^+2Ʈ8 ORNz 3٦|rGtyH`xz(39Jo(o=׻k?Z֏KͶ#0v-?to(&B;'ؼC,^t \bW4- <0ζ)2Վ_&}*㳗evyS$wRr׍*r-TOPMR!?ዷHP}.\%]^-Ű5 yS!uSefw)fyV;\WBHnrUgumЬ;Xu_HX+}<VES`׫13X]_Ar反rUrq|\BJV`'Eyy%?>XA2Mᒼ.F؉8,^ͪ^ǀU+3w CҀNyqj~0t;w%P3U{5 ،ҐqR"kF OSyx?5WjDuqN튷ʮ@ kVIڅޓ< n@~%Y\㶖>o]LH1sH 48uJϡ Hj ]TFW+Lĸ{}8$g:طH'u6S7o9 >| ݚ- ޻`VN|cz@:mnq2 :64s2?3 \g RxZr=_1FKAʁ^hI^k˖MZ (Ҳ*oȇK^π(JV%Tgzz_wn8᥾0&xgEv 2ו& (N/v~+F~?;ʔ0xg' H(kk[7:.j<a6ȪlxNc,N+T/qW(,ҕ.VSW;f^WQVfk" 4xB'DM3`{WZt\_[eQWȊ)L5-R!q[kq)O{?-qSgD.=sYټjaF<񪷍C/Y1Ȥ0Ay67甠zE{!@r˰]@^e PA@B&0u 11\.3 * Tf, 8(¦@+!(I<3w #Ȥfƒ}*I'p +܂zD{4UXd3A"R཮t2DRkOm]a=$9VY\QsD*0RÕ}iP@n] ]3vjdF*t?I;jଂt]َo8 ySt/WBHԄq[HI& *G/:g@f%wS , ˈ9$d>jV) Ԯ3; @,`v `!hdu% &A2#0Q18 $@q[ )ȯK4b|\N6Dl4ڒPs n1C~^t@#(d4qz1`1d1 wv /dBjJx:OZ.cŇ̷j+jOEgt(rܓMTF*g9[˨fIJD~0W#qcZWPc$||r:US+VTL{2%ZzbDx$uC,tr<LyH4ݺRVٱ魫 h bןMWuX(F3%X*It ݼyG@S_C P88Ғ,,U_04ekcl6z.//J]GZ xPQy ÏU #NtQ/t^W+"PT}ޏouo(oh;nH~Jrف5+8q3$%1| &y* fYej+h:!Xa޴OyBH';p@!x@Cz,t"sulBsd'Ulg r.n% D>!<а緞 W_b:s,-|lidmu9Vi5Wf7Gqx=|aBNW $If/M& F\ j 5/7)k$ t kF]~˘`Ҝp6y7`g6Ұ8-}Dsz =w5Fn}6ɓÑsrbp=eВV?nZ҆%DWKd݅$:1(xYidȻA׉ NI:vp8PeTo\PN,@H֝].Q"^貘IUh7w+&fуL"$O2i,6Ga n.4@@RObD﷕hDNm<(Sֻ+$dž5zwBKDzK~t,nP\-lcZo&\VI6gZ$H G)P |W<2gЬ4UEqvs``{2:! a,w-PeF,ǠOͽ6hV-#6AH_l eDQ=.() l# Vp&?}VOK%ԟE=U1_&#}p06uUzKmKB9,õ4ցN]|tER!k %-N}lR7h``gcժB(d0G rPo\1h580%y!Ѝp~G@wbA:e l$aYnxۙ.&H[&BiqE_[DcE"_zq^u=k<=[e0 w)%~]~v,8CSJ voC3;}מfYT͇$#*2VI<1lo Jk}^@7ACEc;BD@_g tcT\ߟ-BzE#Z'2[zc~v]*kDI7j!6ˬK2Mp1Vu$=ّN=u\GjDt((D#Ao~_B<}$c 'ܵuUcBկ 6>|.0E\c8:&z";JŻ?8_2yw2)\s/ԩfn3iz,)[sW֜ ll%%xQܧjX m> ǖHX~%>^89{av03a8,.U8RMr\FgJH Iw0F3Vfmr" dT : SEڵ%E& _QMY:8I|qUطi!n_9գ62hgd<3d N7$sx)HH, sockDir(tKg sockDir(tK C}8xYn-=ŭd"1pQ>P ,E9gC\C`}sgHɺ@0Eܹ;MlөUI4mv4N<,+4V\+F Z.4m;SF\)]n%-LۺTkWnQ}~Mi?uʔ}u.7x绦ڗV%rCBi_xY\JWUlj'o[+翨QJ2ƖXr-ԋD$ֵmZyyŕ<IvcyԄb?ʼnL6Y7LF^swW7R5zain|! 5ʼnXt/]?fv46mӪL-R"6QMe2xAjN+Z' e vqN<.rI4޲^HaF\.\M׫]ۘUH39PVY %6\򅩇i9I[mpڌ4|]m WSEG7Wn纙\n^ɛ'>` .?cD狫[ʚ!Z\</k}o8E |9bWl_=4gQ@ަfN Q T6kvB{26%26:NzAml]XK M`g}͉(+2O\~jV#JS#Bu ":zJy𑧙{ F{F: zC1cJ^ŒhˁOcĕwanЖӆgG4G}M~&+sgO!WmT S*\9YUС8I $ԍ:GzVϟdb_!0e"?]6j4.p@BZabQ{CCەؿӜRے~}a2CS{ !B&}*0,'#(pLcbF ZU%n9q ^ǜU _C~e}޵RU0S4:\.| baB̈|xf 6!}@Ihp>:e"Om/{sʿ6dҵsoy}Ԙn9+a= cAQY;+Nk1'ݨNu7jE3, s}g}'Rݻ6{!ERoqǖ0rG],! U?: jy;HK*}8787d=z Dx .+xep蝮 ymȮđB=ިTX.o0aGU H\ /_Cmߩex~ꭶTVGq=oJ,Cak?Gv`c/oRx{j]{'Ͳ\̒%: zEyŚzzz+Ok _OI d@)> K3o$㒚ZSQGjb i[0Yb<<WuB((Ok0#c]¶L j&Iex340031QrutuMalɆ?we:ܬ>aQTZֽtGӯ ]޲"ڗ>Y[ءNJs3SRrRRA 33= 뮕@ن6 Ɩ]rW]oꂢ<\le ft/lBQ<%sVIڳ^r!ĒԜLU+j31v{N F$K x;tiN=>_]I\&1l=߄xXnF}b" Ȕ/S?jܠ"v0(r$-Lܥ\ #.ER%MӇEsgr쬲(s$).o jyrAe;Y~vߦaBvC$?b~:Cy21_r3&p`fc'4D, $VRc\q0DZvd;z<=`I!X eSȵ8JSmXJ5 QU;Ir!1't;Ó$ [rPڠ\BhEtLjc@js[~_X3"Q1BRF7kZ6"̟vZVHi^֖H_5ǰL3}Wt'ѲD5b98F;CS9qE*|R{zVy[/V(iJyT||^FQO:E]hgՈ*ʲEf5JbGSX%n^TäHË7䪘ZfhMz6$t4NMaPl`"| A[-VE>o537T-Y'}lm|/ϙdGٕ69zML?HG>8x8X//ɠK}Jl&y{v*l?d)8+rrbMYbo7 WV~c3agSp2>`UCL޷ly|3N&BwLHٻXgKrK؊_NC&lWBq70w/=/., = m$e݈D;c,Z, Fj}ragu,V{f∀Gm5eQezrg{~o^/0{ $Gn(L KU9~z4(ҙ."JN%ֶo 02n7Gyo7ꠎ_Qkjf3(Ai7Ï*(?t7[nw8d2],ly6?ONoW3O 2,O~lJEBcM(L](I9JsP>d .hnZAIgb#|Ls#g(ea8%RdҲKQT+kjC+Ի~Vj\U禀U䥴ה+T&]ҽtJK;-Χ[]kM ɲG7NNUMX;9}ٕʍߝP$}m cO)۴BOJ 9>B>lڲ݇-M6nElk/:p#|V^^6R#\VH]AWRxim JJ#HNiJWQ9b@q4NSAfYP98IP'Skh0f`>Фwq`ث=]Xr5` 5nC7T"KPqݶOЪoO^MT9) R(]rr7r]\h}W‡Qe2ԇRضgUChOFp\=]2y!?#i3(" o+Ђo=mYcr䁀 ,kPT\ XaOofK"c05F-aMɫL^TVxe48ɼ\!]-4.R$ck2;'ӿtpU{ j!ީ*gGzּh #‚_vi  W/~;Yë>|psjZx-J@/&w4Xh!$BU< UϺ1Kqwc(R {??V6|2-KPW脇#I06`M"&!y!HEZIc ;NI(G`+,k2l%<+IQ)M65+2^fp7ܰw{[Xsi=rO4Q51Sdv-MP\ t58ζMMc,GXt/$ۦ:DMI(xXn8;~ v#idH6m:X( Zm"T75pOxOr3CR V$r8o,xr'dfbKm:9+TiX|{cZBU2s,CUw~b\gE''.mاr_>_p=cyA=G&Ja25Z , EQQ%T#85 E ig*bF3<0Q`v6oe)S@4`Fۇ7ٜ%ʨ%ːq]0 D,8sr;&IC$5^|,oOaO1∱ b_;Ȳᥩ BHa+peſhmxQo wz}u v+scՄ3$! >3-[GJaߟ%vƀQ5*$fZ) 7I Db |M>ah$EtvE|~?8@h:dh%aG8~.Gh5`G;9,sóq7az_l6hzOf{Mbr8o#,fH_.|@5u8 5M̀h7deSV7 m$Cjqns>$DgS^JE41s%A!2ɨgP0ks뼿'sV }eB|i4& 0`W6Āif "Qioh|_}yq*nː5bfH|-7zg1kƜfUXm(1lEIHjhJ{s..&i6~ʼn1Oބ'O=5 čKiɿD2N2hDx5.r=bZQը㸎a"Gg|t8D:h;Y >)6 g |3MgNN. 8kmԞ>DϞ2;ˉ5a|ɇ[,N+Yx~w5[[ IaPqoFܲ5j*ΫfhT R#rpb`ٞ! t!L} k\V` 2m/ʞ\7h4ڥ^<.0g m(Z*-sh3ۺ~%E% Ťq}x}Q8m If$_'3maqs 誹7ES5AM`0QX 0~( p\|s ;n /{VlKcHL-"z"3MHI=BnMh\qV[߉=(VVˡ;p|zm!qy'R|ESwP]r[sb;5\PpILЫԧ]䡢mpvٍ'u'u9a.*-re܌ 2Laˬ0e' 1  C  [Nu%35QrH,q5.*V3&ne`d2~ m92 ( ,B"<址wJ'aގ}>}lnO8_m"*5<;FΌҏd˚6[lzXw2p#Go8؈ώ) CV ? 18tloFlt S |M\t0! < :{3mu4Va^vf sџbltc|±}fݷ#'^D}G4ϥ1u.ޟLoHx`(-LءhW4*BSK6>%"ڕ۵~./RrZEc3 sq+wk8|cïFxڵHk=-;/3dn^lx6d [Uf\ 2jN^,X;΁ xxWn6?ŭbvq^t8Hn0DǬeR%)^`'ܓ\Jd+E*J8\$ q#Ow:j9J߸^:t%y+rxeRzZ+2f鐔X^ :\闳]\O~_ŰGdHR{7[’YkGNTFiOVJG7 Vpg;(=0> ̲Å:UR1^ 瑅4EylhYd^V[r%^a64ҹzn2I)vj@c ǔ.c:1JQcC")ʗrl ӳcj)]T2gs4S+I&I k%L8vQ2v59 `9YBdY԰LH)\8QhFtx9@J? x]W-n1vNAŮxڣwd4<(I.)j9[ek$ y0·!$I]t 2[p[c(zu8aU?|ϚsyTU΂qs&)) CyN,>B:v+3¢K_B[f|`.ǣ=qLBx-[ZKNZaW,f*eIWᮁ~ FdmU[9q0dm95X}0|9LAASڶU4(eF wW>@wڴzoRkzے~_jfQjZZz-W''~ ýUE`: 7=WRZ^}X,(3[5E`.}Wᵂ-bA҂[13Emm_MO; ۛ J Ovs;nhZ6wnвĩ d( YLV:*aT#܈fx ݙLlCAߎ4vjsX+)?S7{Zb"{X{˷L,9[农y1y9~ >E[A\ 55u .`2rUT<>iGR#9bZ 㺣F(/h+oPJfwޱyw)n, JX&-jY [)jq[3{CI L$ZeEq5tڭ \Ƽ˽a|beѭ_("*N5:w:|. .Ӹ~̠v{A+qΗgi(`b#͞>mt| 3\ۥ0 \׎OKAf\khZ%&0їqRj- ;pu$liSϼ.pL,[PA:9ǻy.o-"WrSpY(QQ:+ȱĢFVRl7\̇&B[_'iD*V! KBcKFHMK1U"PEGFnf8^%}@ ^E1RЁ7,INMw),T\̚!H~'Վͣ?G9 D}!ڦ1ۂd4}E#fvSx+;sSjC L0V w- 1[Mޯ)%'}0Ӹ~v𑍳`'EVWUx">.dMV 5k737z҈SB! MRKFUim-XV9/FDI;;[lnBp0`آP')VW`sjoz][NsϤb8 q3֯0KY B$Oo6[~z632P;:hx>ЏmL؄Tk j$M}|6f$g%Ӫfp䒯1.:}_4,?kU"+ou=4꒑6_ed4.fۿ$yY6葫~Π̓ƽm;MXKrF'Yf'uVJK˴x\ܹH.]4k.̀e0ы*-rr]pT./ip=N۸3v;ȧPc4;P1e&tYLӣ:)G68",iX "wƝܸqflz{jcw8M=_F=78Me^֋2w(~pSM}J.+wN#˦iL ;3&CO보~iaG,)/i0N.Ѩ=q62{|d~}@Gl GG&o߇W<<91;#^$'qs&uA:`|zV~N$)cpm(ЍۅMu}Z3Xk|i)k!Ƚ}Dd\.-/mv ټ w3d ߀l Bo6oܙ+!dɌGMوVx~^Fcx:a#JDeظx~)y~2E/?61dV͊ $hĝΗa%Ǐe3~=' "&v*}=|q؜P_!~7{F szɦ_䗰ߌ̡nL8/=l)X|I-yDn? `g`Sכ|+\m> E |$˫V`e{(y;U|B+8jsR>8W 隆}$jagcpYߓ̜"& [_>~zӞ>oimkyQr;?q{9y>Ѽ"$&(ӷ8ּ$Phbec0>0$%q%)+1pd.)x#=ƝӢt 2ɐ W8v#CZtGldԠwV v@3ISE <?dNdR9y~}=ڒV_E9 8㜭@|;2< /ظR@qH#@ 4׮G3flVd)zgH"tZpRGsƢ݃܂]Rshcq"fՃzB* 1 gW=&2aAhCz_aaEOSlaMO1_ԑK7ݧ~2HB)xj,=<SlX36G#'_LK@[25yI]1{rW7 Gj" dj R̪>Z8Y}hs0eNL|&z QҢj{*B`wZ9D؞0{0b|:uWCih&|&%V91MR~JH# fWHxi$*jHz;τ5Tisg dA):-NvQ@)qgD$͡f5Ja(c eMmb y'ٟ9 R}+22;[&:&6C|!BWiޝgag!"vYut*%̢* j4KLizfWa pY.'ým6&ccZ6˖gԄAłΤ$ m!oF3w6Ri6tz$ISXe|"3z.yO= $pK5(_ B1m,k\o x=s$Sƻq{ C|AլmNy2$Aƿs71܏qg=™Ph)[j?I|M\s'RYWyM%?#FI<7`yڛe~BZν^D,~ogJu3:[uJn*l:y>,^׍-H!n6+UQߒ*dC"~S ,j3z3!(G"Ͳ7=z$iTPgqCͬdz5yFfRN'=z`B[t~@CX2_wDx^zw= X"˷MGHȒR.j?T=Re#)]5)I#dvd 4I$ofԳ]$ 8+!f.4U`VI^3[Q ,'G,gO~QƊYҒoqis;Gkj RkLנ{]mݣ"t$ABiE'SaUwYIsp$ŭ?*l.^>{]O[%ZȨ:i,=‹k!tW>yCmY3<@ p"0% !&ꅉ7Z RKr*wq춛: c۷ەt1lJ~ʞ븩 4N`XEwN _WqZX0u2@>F9/IJG؇hEꥦT ;ɀ~ڵ2&to(P[@_oI+%@T eqDڎ B Hҳ'VNH,YQg_u=VCx[#!.b*"]̼8 y^P؈ˊ+FYp4'|4[2{i\mǝMGv߄nQD]``JbWN`#"V7Ht$6rGC ZV aPU%S!q nqz/%SvS!sk*ߢVQn ZEYL*:W,BFa ܟҞ)(q}̰߷7RjT>7υ(o@hD" t~7DPF!MtBЫZ 7b*V9d!ߟa?!Vi KfyXv ([u0Qacx2G ^?b>Y0OUC౷p'`FdN8/E$.0;=j+MGnZde\rڂ&.8W]uVwhv{KdcVa%-?^vCtoB= U]a(~{ G jY:9+i{JEfI>U߷ܴ17q[ȗ`bc3cAش5\+P" e 9IqI#[B== T43f5?egHm7kF{A\R(+a_IK^wソ-߷d"AOK4 =$Ȫ;_lV!zW~vnO]G}<pM Ν>K3tK ğ\`oYg+A@mے W/G9ZF∗wWtj8عOcm֠`DS- m -LJ iU (UCΎu }p['c78gP3*G]#66N){nӢ~X&%|MNX ^N X G㗯ZNaq')@ n9~!&WW-HN}o;8xAB9Q+`jl[iM1"pq[!>{rx@ro9qk|ao.PۺExdP@]j#Mͩ rvXD{sv<ؚbI*ZO|ʅDY "tcT` MswOŇ3|ex1_݉896A>%~>]ҞYtũK͉a,jg8EJ]п2 'PrB;bkʷJ2|GO7ۤ cj5&)pm `-NG/xJD8`G-[h8) 5CϽ? kk͢O4X~`qSs̄i:酪m"zZWR@S5vo]YFHԠm5B7?1>Ԫѵƣ^VR8 76c@/9W(aM:mѼ tyEH6Wei4rIF vF)^{. ⓮~t4KBl/Y~ZYi:L.{]',1Jd#9b Mq~TX-U𺛐"ɟY)ER21T` )HSM"[R!})97@4F,REGW; xsz~pI+!6v{9;V߳IHi ЗnT*7g/-h~䃹fZgR`|Q:kL. "kW5阵`2*J{htcFywT$Ҥ}=Y FֶHr?TeCuh[GN?>\$ʑ¡J@:j-MDOY42^A~o| WɃ9轃%؄8 u_~А39a͜[!^*ǀ_ߤ5 XaRY?4y s-QbTة'^ ٢m@5wndز2$4nnq_ldo±b2}ct,aKa#Ȇ]&a za-Wf9O~yWQۨ{ə(JI$ͭ{Sl.P|Ձx˳K =1ͯq} _5 'm]ꖴz>e0z2V)4dk]G'sb0vp?^[Azl>TO+~k;Q SӒzKi)UԿi7Ƅ{Ov?'i'0Dx qa yJW8v4rSy]oS+7\&x7`7W(yŴir"Ye>R-S.If.ۯx1,\x="&R"/6yhbNhDc{6`U,e;[cݺk7Os=+P}.䖿Ճm9J2* eQ az$`7z-Y]ya)u\#%OĜ szk/^`L?NZlRQ, s~_+΃~h_8d9Hk#PRÀ+t4ȐVUÖX2ϯJtXKsli5}:1CA)dژ5#Dic0WXD^i^7arM\c_{9P<n5xH'@Lka+\ ?y+:բc CԈ*:ISn w28EנXtG 9k!xLES-;Fv8WXTc/ORǕ1]"tFT(F{B~\:KmUxWю7}^fmafiMJADQE,@f~D_s6U}b\s=ǦPɍf]^tlDt+u~mѱuxF+z_FWɨ;Srsk@iԸ9ddרܮ1JE1ٹ. N[xRnڤ&`ZύȖ6eS֥RiM,YQ9R2莮z13Jا__U3*G\JzwV. a6dCL9#e46JXT9Y4-N;$J@$1q򴘳3 ~kӺ1 ək$tR-xmZq9UwD:KomO)rΡCnPVD*z(7KG[dF W7N<֒U0Ehl#%Q $霷jBo[H!<\Im? 4&GBa `XضUč2O꫚-:C_mDQ>,5f$0.4ۨMSE\[$eNI~MQ̝^pԢ;D֨]=ቚfӎ}ߣ'%LYF ߙҋ#H>N ar2'<$?Gы=@-B95EM4\b3Вnsצ\gn>,84k׌U4M2=x|fv94qߎBMZt-O؊Ta@4P7B9=4!LlKʂ;$sNn+ |yV,K/"P :"3Tj4MGg[O/̲^Syor?3Q55H~œ&Ԓ./R.~ \4|,|EɅXxEDϮy9^,$>X+wAy8O4dKm6Ӡ}TVK+n wpb{K|6xBUYW 4բMP_4=DAbTeN =ǧ:t§^d AXbַCyڭ P ECkg%$$K+WF}4zrNbu84;a.`v'Cl'[EbWIM,*,u H?TʊBG.F&[()̭.q8_ͣq ĩO^*H[$x+n%tt> ߓ4Mw|1&!e<4徆6:J:ރH ﻃ쁯޷P~Ƌ:UK.__~]}TeM@ȶuh%^}h%7`N+~9vpkfￋ;܍g:V.ݷ{͢on`ߐre~U*ol0YSd>bGQ ﷝{KZA\t"G.m;j\_m0sV۵܄d_{9 Vսl#G״^5WxYnm=,r Zc;X(#0E2ekw{Q$=IQċ-Rmiq>^:3>3u:" Rg\8F ɺ"Ng܏砃YfG$t::VٲШ*LJoT[gRS{{/Կ:uV 7Veөrsrġ=G‰{ԇҔƪxUuN7;2 9vb~:ҵn:[bᾚƌ Et\lejߕ(.˞Yxg9t+溷f)tpA 3T `렇GՓČ.\1¡C59tp0{ Лu )͏u!\O˽o8Xq ݕ,=ꁶ'ď(BlUWusZ̆* n{*CtB8KOﹿ]Ghk&e^.\վ}nYrn̻YtQL;?4ªݝꍢɖ:vF](ᾇ k7i7Y{Jb)_}Zݬ/ygttͽ7>-cq+'AVg~NJqn_=ݕT-L$GLp޺ſUF[!R&&բ'\j{[N6oJ@5ťtGeuB`A+@BF??*灻U;bnY 2t^"*Ԑ D`g_0æ0D}Ud [803@ ^cE[*ؤSbiHgI$FhOkފghQI\{Lg59! xzRwUqjV:Ԗ\tgSBhE@倵`M&ԥeBP lTĆ?TU5?juQNLb"ߨ ܔasRPrtz-LbM_;]^R؉ős*94 8hɠqق+P`bn@Y>2S]&n iR7Jӫ ~<>SlQ n%)ۉGsD)8lH% +B4 lɳGO?yUhLd}'~鳽ϟ>ǵnW=~]P0T(p\ܩȨIx7ꔄm{߄` OoiQf&ҽ&), 1tUlSdZl8 “53֩9,f(]#K(džG҆մimAYӯV6oח/):AoQ!`V'}$FE=Ѐ>5ɔvJ)Җ!z&q 5-(V_!(Py"k%AQV}k8HE .h0Ax3NU@SCO7*U䀞x ^B!6i"+>l(.ܾX'7,BQHܨ(X V7ח<jGX\:DL-JCR.N>nbe!BO}k}o~ߺ.}-x mA /6۲ӷ+|D,GBe; 2T $+p@8s+*`,vM2^D&71@djqI+]#թPm"^ht5dX[ `u#!}ШG??=蒛3h@3)uAPkuFGww U2  ɩ_U"b6Lj);rJ)X[5m݂)9)tbi@8FrRƚ"ilc̱? *NDq Zǔ ,3ȐFc. n~ƌ1GYlGrˌWNCG=x7< TQ0Tr8K A|y:O: - ~x iq Tr'X&4Yߞ]g.RڊB +]Xt0Tc$k?K5]u-ji"NHSq*ML`T>ޔmy9ѕ6:Zi}X*lx-Pt~>CȀUN̪Wqe|$” T呞\blKƜ$_ne0`Gr>-y dLb!\&\5HZ߀7z[ ,#C:[>+w2!(>d0)Oޯȍ߱1:00V i4wDs53ygr[-FlK2t&5Dĭ|3[R} >cK$>%6_h\C`EjA ϯ)2rct5w~]*S+%OZTY$#u "uFRA 'ؾQ]?fTSF7IJI' $6VO4J{5ASlFx ;;.0潱x package zip import ( "context" "testing" ) type prefixIn struct{} type prefixOut struct{ OK bool } func prefixHandler(context.Context, *prefixIn) (*prefixOut, error) { return &prefixOut{true}, nil } // TestTypedOpOnGroupIsServedAtTheComposedAddress pins the guarantee that matters // to every consumer: whatever address the router serves, the declaration names. // // The two are computed by DIFFERENT code paths — materialise walks the // composition tree, composeOps recomputes each op's absolute path with o.abs — // and nothing in the type system forces them to agree. This is the assertion that // does. func TestTypedOpOnGroupIsServedAtTheComposedAddress(t *testing.T) { app := New(Config{DisableStartupMessage: true}) billing := app.Group("/v1").Group("/billing") Post(billing, "/deposit", prefixHandler) var patterns []string for _, r := range app.Declaration().Routes { if r.Op != "" { patterns = append(patterns, r.Method+" "+r.Pattern) } } want := "POST /v1/billing/deposit" for _, p := range patterns { if p == want { return } } t.Fatalf("typed op routes = %v, want one to be %q", patterns, want) } // TestOpScopePrefixIsNotAnAbsoluteAddress documents WHY a decorator cannot ask a // Router "what is your prefix?" and get a URL back — the question has no answer // at registration time. // // zip's model is composition: the same definition can be included at more than // one site, so a group has no single absolute prefix until a build resolves the // tree. OpScope is a REGISTRATION-time value, so its Prefix is the local join // only; the absolute address is recomputed per occurrence at compose time // (composeOps → o.abs). // // This is the fact that broke hanzoai/commerce's groupPrefix, which read // r.Fiber().(*fiber.Group).Prefix. That worked only because fiber flattened a // group into one prefix at declaration — an approximation that silently becomes // wrong the moment a definition is composed twice. A consumer that needs the // address a route is SERVED at must read it from the declaration, after // composition, not from the router it registered on. func TestOpScopePrefixIsNotAnAbsoluteAddress(t *testing.T) { app := New(Config{DisableStartupMessage: true}) if got := app.OpScope().Prefix; got != "" { t.Errorf("root scope prefix = %q, want empty", got) } // A group knows the leaf it was declared with, not where it will be served. billing := app.Group("/v1").Group("/billing") Post(billing, "/deposit", prefixHandler) // …and the served address is nonetheless correct, because composition — not // the scope — is what resolves it. found := false for _, r := range app.Declaration().Routes { if r.Pattern == "/v1/billing/deposit" { found = true } } if !found { t.Fatal("the composed route should be served at /v1/billing/deposit") } } lxYNI̚8h`fÎb8FrwwܮTucibaldsndof N:;\^)KV\ʕv(-E݊KuSFtbL_~vFWZ|us竬U81_d񢰦4w]1)JYVNH$QM\BH:9QHa"+88NF] 5 KUKRa(!~VISkƪ ߊ<+-gYܩXSScX.D,q%{Ao*wr*f2ڈkIuniq++{% :ru~8J$4ߒT8W#yS+ji윏u V(E,o&fLjr &`TyJIҥp2K]o!q[6{YxHnmb~e[%kЛ/ ?{ƣ}s6v 6g_=t \]iv++բ+̜$1>Njq NQ2v"$^g_o $޷[bHp2NXiqD_JM"WCvwo V[+ndR`Zӎ'2h̲Xc"bWLLzKưR_i3 zʵT E8@8p*BKfa测S >!~ q!IkP-;!6ͮ2 =*I@q=Wm<1Ȯv_r)abAh=4^"A(6?vyd// SIp.qCߦXtG!NJczvWW\F`":MDnE1` 4Wo_+oQ)q2>zMk=oׄ;8>p_2$dIڷ\d>+ZWH.XKa^R * :5& #¢4N ]%I' 9y8e$XMV7乯!sR7:)5<7Akam$'% K%0OV$FΉȢMJ#`(fV:!ٟǁ_1,υEF_d)qLpEo{r18RFP3˄g[ { ϫúq$"Iפ"NJ,eDoY6E"͠?2_C#JVP9!ϕ*|L DJ(f2ĈSCTwjK)r!/I8r2A`jeD}6b{_Uma>3~`u| 'rb_ G6[2Qߜ:(韰azl^x-e%\6@&p[ AQWT2iN~]{C=`Sۑ1G)7؏+ `GH 9W 0UYRГF"쇋irH A-Lsq/`e7CF<]/pjT+ߍy-P'QuW7P&iT_g'H5J{kI@Z [~x:wb&Jrp/&!@Tl /ÔR F T\, iL ZW|MOFQLCcE\VoevqzԎ=ByL6l؛|z Тx}Cx|Ix^77Qdelete(resp, "default") // the refusal every op publishes; this reads the success#:xXn7[zReeFPqFCRrCRU==a 8xM7nUy~3e>fZ(6A߄ Y-L3=5a~S`GОhDSgQC^{0yZ4vLVanQ(Zze>{l6,a뮿xX;պy`c),t98R1C2 =KiP?Ԑs 8F5ap犣!q  15(vKU/@RI! /vHsfRlHc[Rp4p!U|ŏnR9rdlVQg&WeqѫtuqH$B{E(in9~dPUA9G\П3;Xg&E-q{TK$ȟ('g3}ns9*'fz}Pstr66WZ.,`F0܍y6Z2v5=,wn+.bK`;v9@r*Pm~Cth"[3@-^%ҾX(&bʻ7g܎b]q=sl&;I&/DL\/eA2$V"I>ѶC೧=p>d \K׏vÀ^L0waV5XӜz٠SF*J$;)ڙw Xzfk@xCP5WyL a9`rP|Ny̩?/@,aZ:+q_D p0;I$g%vyl,S#}|'ROHJ$WjsQ4 g\RUqk<7r p ce1ݚ.ا'؏ܮlrr о3*8 ^lG`Nvtȃ?=x&2,zefb+.鸘ԙ[{Px򬑉>+% mChY\p^c-1`c|wAS@6W+Q!3y":-/8: Gkd+x{k+Ӏ(  ̱R( +z /ˎh;wh-;{\Gw]o|b :tmUIÛ].` $!]&! ԍј=xD/-#K(P[x}TGP9rIHH dAI8Xj8WQLδn{]V |_q8 nTXz+ޛd2B|lP"RXsDP>^I( "! RP ^UփІ&Yh f=׆x2 NUQU lt(1r$ݕ̷28;"r@ĉ F/P+9ǿa 47Oq "%: 6A/"6jFm}К؝\&Wf!9JrکCmmeH ۽JVIrNQg8 /aEO)ۆ%uGf`*N|}N\)YV ᢇPz{1S*8 `4U kԁ0{2?}pt a¹3??TC`јĘ W`[s"N` 0M%iV ښ8ݭZNR:ZBhB(2Uv 9„D`<R1> v D" k?~|9L;Bu1on>SFGxZn->ddL-mQF!R,4KF(5-gWC1"їsM$=rIщh@^.g܏sϽR'ʨ3IYTN{kQRXg~tM4WEV5n4vs* HIxzxxz'd.7ʪpEA7\jߪV:|ڨ3*m,5eUj7]^yyQwqݕf.;&NgTP [Qwyo@OZ|W`{u;:]NmL2.ވU0QM5:jT:P Pqʪ/@|y/ m,OCEg>#?alS!/e,N}L Wr\ůM^?iYb=U# ի9vrk閂p7PEg#7rchK: Э¤#oԥQpC)nJ sdvh.jVWRY5:5Uo-xz\ԋ >Wh4un*L|xxTxO; \skr1,Yq"]yhEl a'vqI%2udEmTT@c\Bφ=4X)LŜ% ~g'8u0̀iS|KOvmovO’cXj)CU-na~*1+ʃ_沨<Щx1SS6r^O*ԭΧFiҕ/e-5ܐEPƫp(:,KqF~yS=pӮ^Qti4q frᜰ,ʈD~Y^MmXsI4_`"C?zZd]o;w^O̭lzڃ( zS{vPX}ߣ퓝׿{0V4?'3ӃhK^R4WLf?(?:yv;uhw[u1#i;RW{{owNBwoU)H֞!*z x>#1UhV֪8D{)zt=K6üU`Js『рFcAq@ DR@2>4tC ]NTm+B$F6 @W|ҧfP1k[e6R B 3ְQ'.s7 g6.rq*!tO|gt)ĂϹ іޜf5X3RR乁A K;vP4['#G2#*.Se,Lx_EPtlk_ge H-`jFi(-Ŀ'ǞF&:Rdbt/Q0'yX-R}0dsT5j@s%e_0XCѐvv[uOHP qQDgNtD^8^xJUXc-b!fU&Pҁ\/+ʸ UΦb!~Sxx&E$$xH|!|^iJ#,NS?X&26^f6WResd]>%qiQm8ʅzf /B6@MAP{w6Qz] 0~C=hxB)]cMS"KE2%z1Bx ߯G{R.88{ `'2\셔 gM4׉Y1 [⵩Aa6|u {i*ˈo^"XO!p0o"BXE@ y? y|$5 ,.[ (O =H}A}Mꥴ d|$ؗ߀G쀒FcD&dl&804JFX_F;µ2V߂P TԌ L< _:C.Z\ Fo"n|a(pYa/H1i!e^Ma"N&f `]s x7\@1AK/89N|qiAAg• Y@x.#??u1W\{IF0-'4 j oz:8a`V'qiNrK0Tha+xCU ZX #Ht%.pU .*:5SA}jwa܌<@9A:r7aY0x*9$l\hD3G4Wt?Ajެ|HP,GjiC8jW.<#ʂCcZv@[ܖã*w3tSv[\ Ew{݈ȳ¦ax1vfkȐm4QX=\XEL@` }/N32ӧn TF /'VmPS'ʏYCŏA%Vϻ}'lwѓ$z_ J  l| 8tnv4G!,RJOb14 "ex\OJl[gP<R8$PHt^y*Ǐ~\`F` Ad0;rq@жBiOBfm.߆ý6R1^$/Z~V_Hvc>%zK:=k ˟Xwk;+QV0!(؍ nX=VbQeG7%⛠,$)u 7qD$86Zyv<Uab@|F'|bW Zlj_xI{v/fk-b> `qx-1 x `+ŤFY$ a%uVi@KxJs&neR ơ§e\;_No< Mk{9=Vdn| 8`FԲ_њ[,j_PiC8!jE~K=DQD$PE >gʼnv$[2ᄨPYY5gگ5. yM'vHB0fL % zà x/0!F:'?913O4 U,8*Q_*f(i*Tsqr)At82E7DY*T];Emr.tE,6e`3>xWMo6=Kbm"F4HPW$Pכ@DaIߐZv[9x ť%}V]S&;e~?o/{wttǷ0޶/,+k.޿BވmVU9SIY˒B8%aH^˶c#$Nx^nU)/i(-I5Egh#zR*YoIQ4c~"/Wl)aC)s1*^bzP|=ῑlq $kt$VyȉM;QWζtN߱:S@4Lsv KVn_`X-1ЧN5V08#`دp9(|0ࡱCi<("ʬ5~%_a+o(iӹd8~mKjE)'5Q+J ^n >X`d(X H^"ûAEA0G$`2i0 vm'̹Z0ZjONCaE+In,Cbl F[ ,O_pcK& sxL%}2X{ z_/I:g}~p}P'OV't; AGݣc2Js Ͽ^*[]w8 7i f19RBh$$pIJYGIH]nQ mLM%Bޡ:k"bP30 &(WcwD#:(hzE˳(a]* 5ke, `;|lt,,H.*ym7L!G_X2}`o8DS&ٱSi!zj.'Ը+>"XǼ80=Y34A'ֲĒQdbs3APvQ0e)YgqRI07 ?~a_ν ُU–:gwz)ZRD`Jg8  mɳ-2b-4@wl\ޣy?+ OY p#VBsE˱hYxKUzq)IVurj34 PmoDlkf![|`*>ģGz:8 l7=z]+~{uiOJ8`㲙 U<*]"iegq׸\CԡH̞6ʽa[)]/1u09:< #̅|cqy&$F:?یAޣ&Lo4 WIQH6)w-7 s6FY7b?#Rb*4s*tkWYSpCZL\5 1\0bgJxד8cufR>oRFD+$;ۉ^${r [dHeGIh,ؾIj x;+XzC;FBF~q.v)V%<' 6xuVmnF-b*0H)d8u-lƒ wiY1 WO;=JN7R.z9͛7#Uk|LK<)j~ yG-w1b$7F5"ww`R4bP궔[[qr cyp^u^)iq#ΊJukvSٖVC+(gSTn@o2E_1]-ޜQg{76 |u;0:?'kPL Us'X6\oC? -*T<9@UT`f}Q^l}%JrPV@تJWW;v߄W^Kr.Tw H[*ХkX71Œ" kT]Z+me{5m,4Gx[mhqښc"4h{{0ppo|pCO^f{1%"- c+[ڮsZ]Y\~w5%׋,ItS <> L߫vUb7 Q OqEp0B s5W<㌉n2ZZxԮU&TmRó(;C``M>mvWթSnp_u{)3Q  ~[Lgɪ7gpv0p'lC2BI1,4;BR]CO؎ ;ո A*k"='FQRHWqj,w0!frZve`.xZt4Gd߲Oӻiɍ$I4I :h밴c=>RW?\_fcjT;-zAGdw2+-L!٢,S  Q y i]j3Gb_p/N:0ϳ[ݮa>.(.dP2*tC;BWUK|6·$,s v[/|i)0E]-=< c;>a31UٓCh,eQ׶ptw_c}a$J͎I7gxx<0ŸϪJH ox;-+ oF~q^hqFniq{lV+ uxYmnG-1؈-X$Hf`5gX!)1C{(9ɾWMmo =U^. V:6jowzwVNLp.ϏUҙ'')|z_>RgjTtj%>;U*[7隺Siin3ǦVݻIjgwzRնCmwH]:T?^\]SuXp^.N.v3wg_PS([K\O-MT^+ĸ03t>Ñռ+^1dVͪ*T7-o-*u;u˅?o |[f43΋[ۼeU1wj9ՍY A9wk2wP:\ENکR^wƔx08S/WWH:ùImg47}i9lT)M67 .}&IpK;Z9X7jefaTc՘-5kdfT@0XZxfATDPųoo~)8FH41e&GyVmR{:Odƥu.~蠙6oeϟaǽ+P|K'iW[WgBzL)dQR w,QǀJWvZڈqBlD)B2b vQ|ָi;A r嬄ugyRT(),O5^Ih0iyNZ,äQr›8[}-wX3QhMſO&3GS) ršU.˳S5:='" [@D`Jߒb[nhčVPHRnNƞc"\9Ԋ$ėBI`lhtXT#-w2+0k0v,4@w${q];vܨYף+"<*}RJS#˺(< T5Acž3,A%jnVUoTS3|iZl[KeEJ:;vcOl@ !LK#'#/%4Յk* OIQt_$WhL`PZg.TFWQeA'E"5,wU!( 8>rIg2/S3OTHzkDơNu?ߐFwvزým:@ʞID?C jW@Pwڢu8h7̢0Xf*ܳ0ch4b2,`ׅv*0@c&G~ƳsogLMạށ*gU*.2A6PA|O$]˨tE! ]CcE+}ɬxgE._Hx|jZk7 ?yKhe-ש;Q[rJ Vsh2q) |u p/oÚ/p ]yQ.H@~6BvwI-#)Y5?Z+yTi%R L#!7SgG0t>R- gkκ^ͦ%CA-@9 (O xdQF lDNzS@`aG/!5ҖEζV-ж(̠D|职>NGF{3--%<:XCUjAWp2MֵIѠC*7P`,m}Oj橿QԵj*QtKTq5c"F*m)Eyʖ :.½4Bg@ "WqNPo|@ $iѡ̞!q&yq 2BިM"=\uO)42'p죛u}@>P_řyѴWD!nX!$hU)E)t* Tb"+%RW%hLy^4@B`'W7v87TB)V4h=tsT Ak!r^UF^7'14Ve^PnoTvxA=b@sӐ'~[[1\%E/iW ^620dFM#Vxv F)n\k}8M.^?97iKț@<|m, j^?romxk J240&|NbLDu8HH )61@:fG` F^zJ +jN+S 2GD\n=vk|ϳpI< U P긺dj/{pBF.g<})pŁrj hEb8r {-< 0.p!~= +z?hnNfj>$83Lŷ`pqquG@{A4 ?n 1 kov.qw^J hk`;4_* 6&TÎ+Q ^wx:C9Dʾ?X9%o j+yL6"̵B@'h  @N~YQ q=](wc!Vwk *uo&-O}@^FU#7`\M"j!z"_^$m/4n˴wl=.8i~:6.lfIؠ ԳZ34Ȉ؝/>"h[ȈazR`7ĸ#sxK/׺!R$Fx_a[\7Ei1 zp,XY)? E"H7iT: (vy1!`N B{VW_gՕq}D%-MsGU1Kqe }C[>yz TuY[ k q.QGD+Qq[ lI7Hȏq8:m l0^p>A i&M "Cfi$La٬ܺQfC!K`@(1{OI}QTs` A6w<1cR|a,}lq{j*Im3ow]Yf[3to4JM!S`Єǃ!X\R"jx=1kAyX) 1"J$ (}ss%{;,W=?]KYG/m??~}} <,= 8}Z|~'Q' &GKhh)ÃӓSq9܇P *J 5w @㍽ ~V}p=ƨR11fB/0ӇtYb5Tc Ceʼ3b͡C} uEX1HY:C KEroNX.wekv4c 98,Ցc,+ gLo-JJx1IV0äqJv -wP"?_^TLj pm_L';]ugݏ[_x7xF package zip_test import ( "encoding/json" "os" "os/exec" "path/filepath" "strings" "testing" ) // TestProseReachesAServiceInPackageMain runs cmd/zipdoc over a service whose // handler is in package main, then asks the built program for its OpenAPI // document. A test binary names package main by its import path, so only a real // program shows whether the prose zipdoc filed is found at run time. func TestProseReachesAServiceInPackageMain(t *testing.T) { if testing.Short() { t.Skip("compiles a program with the go toolchain") } zipDir, err := filepath.Abs(".") if err != nil { t.Fatal(err) } sum, err := os.ReadFile("go.sum") if err != nil { t.Fatal(err) } mod, err := os.ReadFile("go.mod") if err != nil { t.Fatal(err) } directive := "" for _, line := range strings.Split(string(mod), "\n") { if strings.HasPrefix(line, "go ") { directive = line break } } dir := t.TempDir() write := func(name, body string) { if err := os.WriteFile(filepath.Join(dir, name), []byte(body), 0o644); err != nil { t.Fatal(err) } } write("go.mod", "module example.com/prose\n\n"+directive+ "\n\nrequire github.com/zap-proto/zip v1.36.47\n\nreplace github.com/zap-proto/zip => "+zipDir+"\n") write("go.sum", string(sum)) write("main.go", proseMain) run := func(args ...string) { t.Helper() cmd := exec.Command("go", args...) cmd.Dir = dir cmd.Env = append(os.Environ(), "GOFLAGS=-mod=mod", "GOPROXY=off") out, err := cmd.CombinedOutput() if err != nil { if strings.Contains(string(out), "missing go.sum entry") || strings.Contains(string(out), "cannot find module") { t.Skipf("module cache does not hold zip's dependencies: %s", out) } t.Fatalf("go %s: %v\n%s", strings.Join(args, " "), err, out) } } run("run", "github.com/zap-proto/zip/cmd/zipdoc") run("run", ".", "openapi", "openapi.json") raw, err := os.ReadFile(filepath.Join(dir, "openapi.json")) if err != nil { t.Fatal(err) } var doc struct { Paths map[string]map[string]struct { Description string `json:"description"` } `json:"paths"` } if err := json.Unmarshal(raw, &doc); err != nil { t.Fatal(err) } if got := doc.Paths["/v1/hello"]["get"].Description; got != "Greets whoever asks." { t.Errorf("description = %q, want the doc comment zipdoc read", got) } } const proseMain = `package main import ( "context" "os" "github.com/zap-proto/zip" ) // Greeting is what Hello answers. type Greeting struct { Message string ` + "`json:\"message\"`" + ` } // Empty takes nothing. type Empty struct{} // Hello greets whoever asks. func Hello(context.Context, *Empty) (*Greeting, error) { return &Greeting{Message: "hello"}, nil } func main() { app := zip.New(zip.Config{AppName: "prose", DisableStartupMessage: true}) zip.Get(app, "/v1/hello", Hello) if done, err := app.Described(); done && err != nil { os.Exit(1) } } ` G-xB package zip_test // [zip.Query] and the URL binder are two halves of one rule, and a test that // only checked one half is how they drifted: the client wrote `?ids=["a","b"]` // and the binder read a list of one nonsense element, so the op answered 200 // about an argument nobody sent. These hold the halves together — what Query // writes is what the binder reads, checked by sending it. import ( "context" "encoding/hex" "net/http/httptest" "testing" "github.com/zap-proto/zip" ) type cursor struct { Address string `json:"address"` UTXO string `json:"utxo"` } type pageIn struct { IDs []hash `json:"ids"` Names []string `json:"names"` Limit uint32 `json:"limit"` Start cursor `json:"start"` } // TestQueryWritesWhatTheBinderReads is a ROUND TRIP, not two assertions about a // string: the In goes out as a query and comes back off a live op, so a change // to either half that breaks the other fails here. func TestQueryWritesWhatTheBinderReads(t *testing.T) { one, two := hash{0x11}, hash{0x22} sent := &pageIn{ IDs: []hash{one, two}, Names: []string{"a", "b"}, Limit: 25, Start: cursor{Address: "P-lux1abc", UTXO: "2Qouv"}, } query, err := zip.Query(sent) if err != nil { t.Fatal(err) } a := zip.New(zip.Config{AppName: "page", DisableStartupMessage: true}) var got *pageIn zip.Get(a, "/v1/page/things", func(_ context.Context, in *pageIn) (*pageIn, error) { got = in return in, nil }) if _, err := a.Test(httptest.NewRequest("GET", "/v1/page/things?"+query, nil)); err != nil { t.Fatal(err) } if got == nil { t.Fatal("the op did not run") } if len(got.IDs) != 2 || got.IDs[0] != one || got.IDs[1] != two { t.Errorf("ids: got %x, want the two sent (query was %q)", got.IDs, query) } if len(got.Names) != 2 || got.Names[1] != "b" { t.Errorf("names: got %v", got.Names) } if got.Limit != 25 { t.Errorf("limit: got %d", got.Limit) } if got.Start != sent.Start { t.Errorf("start: got %+v, want %+v", got.Start, sent.Start) } } // An absent value is written by leaving the key out, not by sending "null" — // which the binder would read as the four characters. func TestQueryLeavesOutWhatIsAbsent(t *testing.T) { type optional struct { Name *string `json:"name"` Other string `json:"other"` } got, err := zip.Query(&optional{Other: "here"}) if err != nil { t.Fatal(err) } if got != "other=here" { t.Errorf("got %q, want just the value that was set", got) } } // A hash is one word in the query, because that is its written form — the same // word the binder reads back. func TestQueryWritesAValueByItsWrittenForm(t *testing.T) { type one struct { ID hash `json:"id"` } var h hash h[0] = 0xab got, err := zip.Query(&one{ID: h}) if err != nil { t.Fatal(err) } if want := "id=" + hex.EncodeToString(h[:]); got != want { t.Errorf("got %q, want %q", got, want) } } zжxZn7z vR* M%q8wMR+rQ$͐Zɲ Po)dr.ϔ5+NGS%.*U.ueDfT/BTTe- STy*J%SPsp v,1;bx ~p 3f3\<8WDxX(9L<*Ĥ43uL2[%LLB&JJ]NU5˩4 TerI4tYaJ'P]Gb;Xi 3[+3ugGQgV81_e(3;Ju:J'A?^Uvmx~L\{W:|+uY5*Y&ZL29#",T=69h>M3pv*K0\7s;Lr#zQ66&߸|JDy$,7( ~Je^aV3iveS3Y<_`3cm&lh\SK *U稀󯒩y`wOD94~}z{Q qYGz a1oM_0O}|Ƒ/.৾ T"G3\f^:q?8'''poΖ!E1rz] d&H_ D"YUKe-@p5мʾv{;nNjK7ҙ جϛ&XΔ 6ІQ覆<3c}v,88pː&WCEDUj(zM^*(] U5т3ά]L:w1nX]]@\Z7~ Dl=8+x,e`||; LYE/䷬$` 6Qf)λ\mLZéui69bda ǀ{YNn LzIMRͨSTY~.se2S5\<˷/[sNcʺU_zf Y,[q\[ˣ-dnU"+*ؐ[\ 'TQ V}tdc-X }K/گŐj5WOW6HQ?#ОioOZXVUi)񉙷5%o֒ۏ%(zx@2nZ^͐{9EQW`IA &e6nPf2J~mLhYZ&A%9ߗ'ӒeWBO,Owu!bqo:jB|Xs9ZYnäݝzѦ ͹ /bwyנbhD;x$:N)VoQt> "1,#OQ*+쉲>i)StIhQ1ʡyZ0bĝ>SKruZ\wpdՉ(N'Rڃ4_`TWtD (ywEh.1&RwoeqAn\̧ M'v;t@FnEA+kx".k[kvH=6r6% ET{y%%:D↧g(/l9^SnWc3BN6Zj.fvkү>,Ho!_@,ܾkz,S_6hYRpףu9] e }"h׏0DW> (N.gʜKMFyV rV؈nF{'VƜz(s߭̏1A3d)h6pNn\|fsSFyג~]֗FO z8E>npt<^8aqL>~uH kC(͂?TX߭Z"x3ouw5Ǫ`uwC xrǕ&*'`L֩MVA$%1HIɦR3@4jbaced9=\ms9}\si,* gzQunn &E^>He6OA+Wߝ.3ZU#ͭ͝0~H*)dt EY<}Ľ .̧pLf^_(I%Z7eVi|:쑊ig[ϒ:LeŽq;2 YPշT&bdyRqUZۃ24\CV,K^$yZ'OHG|tz$|n+e"j,0ۆO?`+|^|L0KcCas#0lnld&ӴzV Ϟ@46*OH^ OYh2[<〚pŏL=O䞌޻߇pz6~}ptpzLΐt~Y,oiu6Kx­Ny!=./̐$Lt,&iU=ɦi8h#\N-HDADrMQ\0L4uymYTv|9MO%-9VU2V&e1_Aʺ5 bJӂŸ],r4E𕖦"bDGai!YVn2Mgp}. -BCeDO y|$Mޞ%ӐK6\'lrUjll^rܘ piiBl1akcN.C]+gӰ?c-d&}z8=0zk;`ۭ ވOr3\l?g&W)54шį S7!}|wJFk 4L*cDdNǻ4ti1ix\/ ,ȨmTLҵ7{up*'WiR2UM3 n2}yp6m1rӎ-yk\ɳ!6X^$u2*Lbe3񡥰8E*ո.P.] ug9\C$1V(SׂpQŸyYIm9OE #Gw4ZsM^yS4\=dCPy .w9'\ヨU𘛘y`1 2,eusӝ%ˤۀof*UF\l{.nP|/xz4S7Nup/A-jR,nF`d8Ker\wnR0;̂N.fLj0G:Y.4Xjo@XkmD>Cz3pӎ,:9 ϡ^tF2<>$eT7IVܸ>ŘJg1._e l)#TE'o4wdE3#׍ T>drￅ'/omLtWlL"!|E2̶:nml|QFQ,Y8PdGF|) hfV *.L/ Iy'YL"Y1Hl,{2zۈ l.12V Z8%F[>XĄOatwvx|N_~>M8< GgQZϋDYhۨiSX @؁֮|`?i fD!B^^b8dY;ٲ07(ܛ40ycl{8tfEI3<fRcAj k 73=(&?%UjfQYmcI+HT韗8hC4) <1e$ *f[+#dwXl%}yPЗf t)h/Xf?_\sw?Aot6oVrehr d,xfcw[pr$Hmܐǐ(i@#sZ.ӣV]~GRΫL9}\ V,7눞0f૒7ɄGj\9QCyh͙`L,pr)@A|.\ks >y39^Vcv/0O-PA-eʁoT2|[Werݨ8FxF5軘 @Y1+ōD&O;9UF@#JM3-vU\kl3ţE|Z/Mȵ3u5j`A0o@LLdik)Igȉ"Sda5$V4n3rhku!h?)ّIjo›Z1SԜIL8KP7&CU?':%;uBG5Y›(&eU32Tɜ lFYnmc6-C|o_[N >wQ죷L} !6zBTϕt4nhӕT8ގ|j.hbߨ^lĚ 8 ~vo #kFkLܔv܊[8p'˄D\4(Pjhs@L16bp3ˍ blnk@KX/PIYP" 6*/- ISE(45Q7r6%:2zV_eM,nuQq-HSZ;8;;O1+DKZna`pD)j7\YHƘC+;WX;şvkecvD(*PmTXMK(`PC;;X4!haޓ]ɃU2IѨvstzIZc:6?ZDp 'a. FVR)!LF*RYTFzy.*wG:Lj.=0A>\ J.ӾAXh =lY[DqF TlR)s~BuCI#?lz5Ai*he]q𷚾]%isnAJ1G6}+&=ARcAhe(i`t.7'b1H'#~%jQd^J-(0UDE0D¨.zT6 ra6 <` -wh|`jqαsr#?ęX]ꮱQ@2 4YGmiLJ(Dqjp`.c`un@D:劅$޼=}Hr]|0 ŃZ91dM 0nu!3b4T3֠X pL)U1>A"Š^ 8Lc؅ZS䛢0}-huNjV Z˹j "[~{Oi/ tDE?N=tvIxCu3w޽hQu=ffC )AFM"u/jTb!%FH ] ١jTj\rٞ,d#tQt8\ge!b ZT Ra$aK@}LŇ1=h9Z~!h7}#)ԔgQ 1┮RRYlISPbc9s6BE Ω"GKϛ>t/1+P'YRi"6mfW% 4 ڙ&IPW*TJ~/ȢkToU Wy4vv3.8qF|^Ͼpy=w4‹"J2pPc˲'3l.筼'3lZt,fiHYx#L#A݁bY†uKm:aFȦƍ{EAX( ݻ=MTtR.Uݾ5,BW2CHy(=8-4!% C>RFW:$:鳞4o!dJ&u&rPyAn^J6%ѭ;>$0v uan:?cκ qxd!/sAit&^V锿Mx(0Id9]ͽcNzYd"L 7%(̉Y@ J@CXtc0ݾ![0R}M/ -)flkkR$ *Vh?)gJbmJ$)@I:"R?e8;(le)zm`Q>1ݳ$|6xb]~(yYTF!:fxnx>pM4XY;B'&*1PTv=C9&:!|Kߒ#1&W$!SP1ʄvݺ-,^KvJgY$=kTQtX隔ի=1]8}ړ4.VO>;7Onmz4%{-Xi~|ŽY7a5QqkiqnQy<֊FI1[um耠m%(5hśo>D`r<Xc,NMpJmؿVt nDP=FrۦNhx^44;lxA_]mnNcazH7(Bɇ=sI(NMM8R?KAjhFήsUL5M,':/zNkk+dI>N_zBEOeW̋ckuIK8`+j'\Yc#'XCG̘VTXQ)aK-V[(-&$_iR(j(̋[EHli;Yl)hT"/4>(^Ӡ0Q_1M& f0K1WPr,œJE_=fM8)N%&9gih9EeY]OFوL#YD LUm '6u-䘫Z}0V=fsK 8,Z\=(Sjd S3}粶Zu/%tR0N}:IZ1eSrCbIi`hQMwWydEwMh^kj:q׋Q!;hRBZgy`|Gtc<[q~^r6^Z@TLQ{IF畉a;8HŦȽ>ˡU*e}$;c}${kϵQ.jb}ZjPғ2SЪkCӳ/2TeXVt 7(%b ߌOt.1vgD\[ۜN;^ߎPtjPJ eFε h FOT,CeqzMϻG0kƻZ Zr}T9m1XsU5n8!rޕNI|p̙FzdSǼT=,-w6ٕۗo.u3\]:'!lj1R QJ⚢ߵbf5:LӨog,ݲ~Qzuk^U:;FC,0(lvYI1Cζf N 1\,-Ai돓N|?lX=3;;q΢kx^9(B Îx x+ d"[TONkL0GKEAgWJ§ Z ڢE~_qHGӌYS{(0ʯ3/ՅthHT)oejf !*Y4/+θيi3@}9"ZmV'ͅ==hk5@*a , Dw_YIiFFXWiuVa~O|Zç3c}\+Ԕg%ENlOO8bww6<0rBr /EX`,Q񓮖qɰ'7OiUbo#Cz j0a2Oru;:v+󫸶IvϹ@?ëx ܄?fnv̽r= +g7-"9wuYVn;//ް,wK]@mPۇsX^!.`V]K 5vZFcVmm4C5b`S-)붘*LbEGa] cرGY\{HIM20fTϳDg*d50?w)^n=)I&V_-Wֹɉi64Ad-C^{^㯍ᙜǰ l41Rσ9i\\G&\wfs5.mXV6iM|[e }h",-6;(,T-W UWIuIہ 2#GB{~f OiF@g윛 4Jnt@2$SV kaR?鸳Y: |vtH"j'JH#r$ahΔWO3<+9Ϝ]-k~+Uf{Wڌ`9rH`KSYi5^nf̓mWq ~sO[V =ե3HH9,钾JO OdGX멆5'y@&x&N*l`IC9kzrAů4{ ]Ju{]v:tR߲1OdQ/8}pIڜ?n_oXaxUTAoEUȆ\h#T 'Bd5 Ubx[ef֮"+r?fl'ao{7yq~6}d9hrX.~|8.nvƟla;< Cwal/&f|4EYW4S- uСy0r5e2>E<>ւ N"KUNB'~xcYrliR Ii]* v1EDYS \Hs5z'RX$ uoi.U`(܌-Y(1쀩ҥ͔Kad<>>N`(ɮ, }OX: |6$[|1?Ufw>f帚MUtnכj3uΖḚݦ}Z{Ӵigmpl^Yh6g!oB^ʪmV<_lIh0BUgmXhQ5yWfzGYJҢ$,:gM3 _%Ku:yZ4,ByZs]"+'Z,,o2>qlPi7fUZY#w_FMz֓a8fzll;BZRVBvIYXM_L6ڜufi͛q'aRlwsZl_Ȭs iu?.8-(R5)r81.TgȪݛ#jYֻkBg@Rna$p/'ٸHl"+dOvv͉= @Lg5aK4/MZ%.v\j'$읅Udy ^E40E|TMST+дݓdT+t{g՘d= (>g%laS@/89:rll M@ZtSiGyB |> (dR]2)orb*q vnd #}fp_ {Gߔ@Ey|ʢ,](ydfdpnVg.##Rne)Yd+$xrzrurvj&,^ W0C1Ud Y]gJaCS$>0OYZR wܐwP+= e^6b>>\:Dm x?(:(+kH} Mw5.нA~R<4/=yaC yˏ*A!'k&8=:24HPg/#ut*6+?o^u d"űaI>c&,fS즛W3h|\lCZ(Y޻,(DZ`'؎]=f7 OEh¿~0j6*#-v,Ǿv¸R=SʏMxK݃H\\@潷jL[ÌIAۻ&JLw}\J`EJ1g,MwKSW ),2(T뢢F qJN‚MaY&@5U ƛ;jJj1{xIkC{xk ᘛ|llA{ xЅ#$$,Y//>mY{6ϙE*RRkj8hn,TA檒<=u(\?b7"U4U+:8BCR5J NZhGVnY&UB*Htή5Q|'1vPA8 F W'/>[oJ&'ͽҗFۥҺ1ġ>QXZNHfSIÎnƃWm44ɢ&hH%@f'$_R}XMT;mZ ȺVSdebOsxǶ&UD 22[êF T-\aه]pQMw?l~6`v}o6W3[s(R6'?Vu"ؾU+vumXg ci'O(.:.YǐXXӈ*NWMo% W_-vdkr[; 8T/xR(Ӡ:8bz$v4^6 8M׬t.ⵤK:i][:V{IjǔL$cQ1aͯTӓÿ$ݕ(HZjDY!2(D,hr5S&b菑%v O|IMl:\e{T/]P^Ϡ!a4VB%fn! Enf-Q d)ڐh'!;(|$Bqh`MΡ̜!Q:#F g`lJ- BBwb/X%6}p/tnU$/P&g s̖C^pGܳt?ݽ%Gf֞_z_V/ݼn( \u 'v)4lCȎ^4M.Ys)53\ǗW1 H^鬇@ O'] b+$Uω^̝W1,ɀk˫WWeJ!r, f/!ֹU@Z@ 1bبm^C4/T0`ʹβo|X/7.RniJÚ^X6&wz߄,ī:7Ψu9֨,fm&+IiY[7ђ(3]jmϞCw%Xސ|/x64 77>-ݛ1r4o.%o0+:H?~ɷԉTam\\茤D&KX1ɤlk\EMZ]7,04W2"uPwĤ 8f?EJ ?=4s*%r9.E6o<,8Kk;}3*l,14UUSqP "j$+ݘ))KX됊_ٔߌ[ %zÒ~{UwGeWNW'Z ۺmb9foW}X]wj7 <_IAGC:zGuu? Wz{hXc%QnT}˘ZZ_}ϼi^W` 9D.!! W[0o٫+P׌p\lSE,@6UuҊ̳ UՌI$=-UL^2?<>%XirPMvmMnu* pӤNH4S^<}>5tqsC::dP{0[domqɐ /9)nu A˺Kods1R=PB5oaw-gÇg!{7\k^c]۶z1ZvRT1xv~3mlc0$N,ċ-0B6!]ϝVq"_/S3܀8tWW圪R)9S⇼|v>/nEZ`\=WQ>&qb[Y,e!S|}I6^ ~i7` !TڿU[Fy )Q|sEU2f:2MrNLY,I͋p*1:.\xM$ڱt4H^} -2N6Rbq )L"JIYE"3 FqYu=AvK\sr!<;} kdҫ~*D$/9˰>)ܸ=tV+wx\;5v.+F'k뎏ռ7zNV8˝jUy",[n#/RN45y$е:x7]5nвWf_^t\ qqg!lJ]D̄`JԞ$ݡ{w}+`PD8\ PAR-iR5E`;BYSB~!=>2qbp Lo|J"a>۲3DN ^Něm3GF!r=11Dӭ`җ/m.[-(_ՐDe] }㺵gT,(>'g=s.~fR|O o0džLUz `VG ޼;ܗTH"s2S|M|zL|¾v-@gNDT7dz?/St@KxǏB3<?'0(0&z9(A2Q Ѐp<eיZ&9QGa,K" id NX`3lyh{lI5! ADDer'U^V,̒$zJ <oS 3xf5Ӿ7}|4X" *I-ì3]?=&3S¸Feѥ@aYKL2qPL ?nFݰTlAdی  DE,.?l.6`a1im3:[lܯ}pfD,mYkgAuN?wZ"IP9ruh %>ƿh>&}7woS<чUu||V8øt!x VN9o`ȥ_g\I@:A!Ukg-kghh^(ީuQ;Tn$^q@2ɻ+ Zn//M[4Wqª+p%7>]Pr W/n{bQ)E3JBrlJCz;@ mN `2hQm3jjUBc討*=UeIM[/#4)[˫_^]h13s'DrR%4Of;"H(~^D[@v8 e1&UN}1GbITtK *KTr \M) cl}Ž- 4BoOJo\CaW>E@u, P7Hyo>w~W5 +UCO!UC cEP/؅4AHl$NmbBYXm^C.+kuHM׭oǺjBkrDjQ  zʨԝVg"l@pmQb !OAW:ESCM HZ# 6@s-=Өg=y$"pĕL= EL] QޘWԵ^3A넡 \YV]a%K18XaAs[hw#'O54q^|[OqelwF5XtL *=7^R`_` Up'VchL:AC&EEg6J@֦ DeTc3̀ðj}<ɞsow )Ine#p;x|%ob{;/2htU%e<&8٣<E*wTU%=U >h{g{#s2Mxs&Iaz`bU/߼0i2"Ӥ4qf򅩦E<_ε;ã6UbeR⻉rs,2r|n?@ jVi5IiF8 Y<%|c4̽; 8\%dɤ]]-|Q~[bؓ2[{{d{ J'yΚ>ۧyYzz9w/oVjWMbPiU%xLuZs ̋O%y&-(cp1K_IL2+,g⬱;yqy?1  [:- *=˳"h%jx%{tv術]=( lWDDP ҸJ`Dr>^tB*`v0yڿEhu:-6` V%LNx>JL!v`y5A(7 i`e:vȳ_}ATqN{8>D; ꨣd1 $n]@F*wqv$]L/Ѽy[Vbrď^Ք*t\)_߸"T[0 4 e*͏bIĸIk븒q\)m)R\dU2Q=CP6HlW2k(; $e\)c%.bB'WPv!1$@7 u{3!ao}##MIoV}5)Il).kᮁ!/ZeȻVa_iSɕD'͑o8@k4]-w23t {Ė'N6z3lc5'?m wZӚF{ 2Ϫ'i M6tEoHs銰jE*#i ?OG4V,nׇٗ`EeuiRG$fO070X k?e~y,]DҼg3LE2MdfN=7hICvu4:>|ez=\ABWx&VG-pO/:RT@BNr(\Ʉ 9I1=Bp1&C&jbϕ]Wb{H'F|?scnދRϒtÎT!HΕ`Ϣd c.B٢OFM~u`~CTnL?Ar'X!5ؓeq^LJ'(V?D1*xC \Eϗe%ӕ!4g#ԟj@0c_1 UlE,ˀ5XfL3gΓS٣#%, @DC>qitV>Cl4˩ W O}B^PdVM 1 gI1*Q)gܯ]NѭgWBbZJO]ƎAƃ_V9DM$A7İ*)*%[45Ў%~92nQD Bos9_G'ϗPE( /#:}X*q 1 =r4KK-X%2Ly cS'x9/a0?-7$ 4N*`SN9k wBCfnD"|7gngFMsq"6La.{\)#ؤ V S'^ULvB8 ZCK~; !Yt0r@4؆*D,s}Xʰ ft4bZ$.$EiDF$CvK y,\)j3 C˜GGطB_|qGlFE~dhb–\s65: KLB+xR᩺I M w ;HV9j9-  1B3:hf.@@P 7@dl-NPg @X@q@)3.D#.K@ ]4\C_cQɳ8#=M DɰfCe[!u0"> :z`H0]u6¼TZD gB3K,Zqawb6y\?^3g$ЕVk}s2Qrؘ>6 {RW$>E6O#xR5)}8ʁ{]#έ퍲eǪ՛>)VH_.觮UE!t ц{ff֨2d 蟑h1M %2+J2"_,ge%1D3Ћxj 5ژuh6KVUM+xzCq2SCéuƲV4RPF IE55bU9.gЖ*O"Bp@"OڹH%8ӎZ iJ'du=yᑇ%d(2#,{Ga@3јXvyX  ]HPxAjM̨M ʗaj #bXGUcjuvfPbYS :?N(Dyut*%a7Ǚ Vc9FqS`ý=b H*;͚A6M%%qHJ8h'V:ͥnM%Ե}/>4㘤guW)nbB m}%. "%*& t`1OŤpbIRU_lD[Z yr$ M]+?H=rꮮe57]#15E]֒[ˬ>41x%Z fzabmw1]ݛSoi \5O7cqnJ)\9n롃X8XC Qk.+Z>&нWyR_X~X7|XX] i7LTe_1RDô՗+*N*{.6E"M>NyZUUF~ს&kP W9L<*YF/: l!/EF3,4dZN[#I$L&Ɠ#M4G8h:!H3~%c(B7"$[“.p")˂+Sb ta%)і]%pl p|V7Zo5.+kw&W +@'ŤV*ɪ 2hQaBU,Rv2Iֿw|,.B=' 3$P/ ,PjU|1)Z$FolćN2"eU"R"RyFJû/+r? |߫ z+#7>F'fw sV ="ӱJ ,:vʫّTvKJs[KK>2iH۷HP'$?$Y+,ٴP{r+#S8 6zv$]v>/3fw}L]QXv4znmфawё oweҳ xML*K7:2~ eKftJmԄ|r̒^U?oj1B+kCeMbFHZ`]_'ݐ\GЋvrTt!؅B1Mi h /0%Hp ~_,𣎃aX(n-}mOPx3Q :n;QyFBZ) t;rU8 pRd|T3ǐ_+t|?$lu iht-3a_Ǩ¢+ Q@Ď|OK/X;kqUFp$3gEs%$ҧߖL*AyڎaWְ ;zIP8dqnQƓ UP"r܏'Ih| g0iuFyZ C +>0h ${ %+C6H2 6~vbBOl:2WH]\ӳ'P%`B@TmITi3n= #VyZ qQue]rƕ0Y|3>a1jVXcIz-i3?FI%v,np5[UUO`)m/GK/h-94f T%pt/\ռaDŽFU{4}玘 cUBӵp 檥 9wᜱLHiJ#B~TxDR6H_. kU|ƚbzsGIz=/j`/AW*E^tyRFc^pB' c mjsMΚ PjeFl/Uyz.9! #">Z`dRtµNpGxZ=k\(OQz.v뭧 e~ϐ{*lKňk  <ǜ'xNPvL0 x[Jd}t<p& k7#̪X9ĒQ]Mu@,őO tyqzDʶJ/$PlP#^1$X&AKOtVUyx ՏkۇsE+}H=׍@WС+|u;|z7;A 5gUxt7rl%q!'IA H+={0qPÉId<&{m_p\H\񕖸 zX`%#-w}!6Ey'בh-ȷ[ݼCpB>4k m *z_ul}/Y%dYXl𫔠`U*7uCP霪V\`ΣPǖ\*b;>#itF Aj*+-> V~8Q(}M;zV\Zƕ98˯n0V&8 zarjXSq*Viʅ֞ @H ) ȇѺ:V'1߼`<ܑCZb 8Q'( #jn"GR`B@!d`痰*-p`tfĸ1-C%wb%(^5AQ'=A>h|˝AX!Bg8VcrrFXϙ*X@( -Z4n N15^s+vEoY˽AU[P 5>Z<@5~:KNxѭH{ .C]a<קoLL}d#&mͿ\7l/԰ۅ Y @\qEh芽w ǠHWNz0*ڛFY 1iG.X''v [c(dfO mhOV{?i9.H7a&8^q7B bT3R´lZoVʑAPnR=rP>qyVo.׼m !H& 8m)0hN. V$Ce\lEZu_ :I%\@:C9tw̧/ K3Y0J ,ZR ګYk/mΠ7 C=.EY­uE[8Z!@y >앗aRn ".{/rF8@An۴78сѪg[(F.'D=ť ^ ΐ>q3[!]'X,|EP[`sd_5] '"wBkeF{[j!q2 Y@iT`\O'B“k:e6@UIjϺzqms'M=GߺI^=mOjy CjTʕY8|m)p͠8V{*^X @!QR-+dq't[dm+ԃDb0 딨#DTåzk;L0Wy59Z_B.kuԮLn`EvR,;&q;Fs&nUuR*[[Nx)3$PEC8ƽw.S2]Ԑn0j"VbE6rHU&0g.ۼXLsPM77'߱-:=N#ͣPjsomn`OYtCMNa^fFne#[Vo>"\[݃+ˣV:M ^~۬Ub#&8?S=VL@{JYжR}.~v5b#8_Z #sv;[I{!ހ?%Yɠj *[U HըML*tyG+[x\`ni̡3P$ur C}P0A]q /c544~6>,q6U(ݙa`\-c&ݨqҿy/!#%--{첮Ёx]k v|ڽ,|cZeQar+ye[nmY.vtJ(1XHa~{CB55 *lB' /I86`Oox˨#aLPnf2._O2 2놭٣$OZKV:J1LKPn\omy>\`BsX kf F٨Y0A+S P $Һ\zW@g<~E7x){쏋3[H N x1y#,F3^Bɉ첪Chdj×!XʻE*bt[.(Ԋbil iFӢ1"6㥞#jIYV Kި7O[ou$~":u Vy:43 ɗ3tCcX um&>TCR<6rx/6oc 7sȱv?ƍ&hPc7+k -Y!z`4t.$d[VAQҌT%NžNK0w/;^dkLkv p>T(&m LścB+:ǰgpYec4x kwC&.}ΰUV;<L¼(ұw~xN%T*01-,pXܙHط0QI!Ʃ,\Awg"mz]ëBe2}chXT2|,̰jZ顲C?5ɽ1cOxs[1s|p˩qN;*\s\.G~~ΎNGHmszjl6-KD-{mJe7"+) f'6_0|QhGK>F)xأ|f*:j2!>0S%k >g"#lta&y+DHK$iAD箊cr 3 _ j|er '2Elm> aVqi}E) xO+O?[p2*v:{ެJ鄜}J8ޠ_F13HR3k/L,KFo~amBeRp}QRFHrHx<package zip_test // OnResult is told about every way an op can be reached, including the one no // middleware can wrap. // // Everything a transport middleware records — a trail, a metric, a span — is // recorded about a REQUEST. An in-process invoke is not one: it has no request, // so nothing wraps it, and an operation reached that way leaves no trace of // having run. That is the gap this hook exists for, and it is the row below that // no other mechanism in the package can produce. import ( "bytes" "context" "encoding/json" "errors" "net/http/httptest" "testing" "github.com/zap-proto/zip" ) type resIn struct { Fail bool `json:"fail"` } type resOut struct { OK bool `json:"ok"` } // told is one thing the hook was told. type told struct { op string err error } func resultApp(t *testing.T, seen *[]told) *zip.App { t.Helper() app := zip.New(zip.Config{AppName: "restest", DisableStartupMessage: true}) zip.Post(app, "/v1/things", func(_ context.Context, in *resIn) (*resOut, error) { if in.Fail { return nil, errors.New("the handler said no") } return &resOut{OK: true}, nil }, zip.WithOperationID("createThing")) app.OnResult(func(_ context.Context, op zip.Op, err error) { *seen = append(*seen, told{op: op.OperationID, err: err}) }) if err := app.Build(); err != nil { t.Fatalf("Build: %v", err) } return app } func TestOnResult_IsToldAboutEveryProjection(t *testing.T) { var seen []told app := resultApp(t, &seen) post := func(path string, body any) { t.Helper() b, _ := json.Marshal(body) req := httptest.NewRequest("POST", path, bytes.NewReader(b)) req.Header.Set("Content-Type", "application/json") resp, err := app.Fiber().Test(req) if err != nil { t.Fatalf("%s: %v", path, err) } _ = resp.Body.Close() } post("/v1/things", map[string]any{"fail": false}) post("/mcp", map[string]any{ "jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": map[string]any{"name": "createThing", "arguments": map[string]any{"fail": false}}, }) // The in-process seam: no request, no middleware, and until this hook no // record that it happened at all. if _, err := zip.Here[resIn, resOut](context.Background(), app, "createThing", &resIn{}); err != nil { t.Fatalf("in-process invoke: %v", err) } if len(seen) != 3 { t.Fatalf("the hook was told %d times, want 3 (REST, MCP, in-process): %+v", len(seen), seen) } for i, s := range seen { if s.op != "createThing" { t.Errorf("told %d names operation %q, want createThing", i, s.op) } if s.err != nil { t.Errorf("told %d carries err %v, want nil", i, s.err) } } } // A FAILURE IS AN OUTCOME. A hook told only about successes would record a // surface that never fails, which is the opposite of what a trail is for. func TestOnResult_IsToldWhenTheHandlerFails(t *testing.T) { var seen []told app := resultApp(t, &seen) b, _ := json.Marshal(map[string]any{"fail": true}) req := httptest.NewRequest("POST", "/v1/things", bytes.NewReader(b)) req.Header.Set("Content-Type", "application/json") resp, err := app.Fiber().Test(req) if err != nil { t.Fatalf("REST: %v", err) } _ = resp.Body.Close() if len(seen) != 1 { t.Fatalf("the hook was told %d times, want 1", len(seen)) } if seen[0].err == nil { t.Error("the hook was told nil for a handler that returned an error") } } // A REFUSAL IS AN OUTCOME TOO, and the one a trail most needs: a caller that was // stopped is more interesting than one that was not. func TestOnResult_IsToldWhenTheRuleRefuses(t *testing.T) { var seen []told app := zip.New(zip.Config{AppName: "restest2", DisableStartupMessage: true}) var ran bool zip.Post(app, "/v1/things", func(_ context.Context, in *resIn) (*resOut, error) { ran = true return &resOut{OK: true}, nil }, zip.WithOperationID("createThing")) app.Authorize(func(_ context.Context, _ zip.Op, _ any) (zip.Decision, error) { return zip.Decision{Effect: zip.Deny, Clause: "none", Reason: "no"}, nil }) app.OnResult(func(_ context.Context, op zip.Op, err error) { seen = append(seen, told{op: op.OperationID, err: err}) }) if err := app.Build(); err != nil { t.Fatalf("Build: %v", err) } b, _ := json.Marshal(map[string]any{}) req := httptest.NewRequest("POST", "/v1/things", bytes.NewReader(b)) req.Header.Set("Content-Type", "application/json") resp, err := app.Fiber().Test(req) if err != nil { t.Fatalf("REST: %v", err) } _ = resp.Body.Close() if ran { t.Fatal("the handler ran despite a Deny") } if len(seen) != 1 || seen[0].err == nil { t.Fatalf("a refused op told the hook %+v, want one entry carrying the refusal", seen) } } // NO HOOK, NO COST, NO CHANGE. The default is unchanged for every app that // declares none. func TestOnResult_NilIsSilent(t *testing.T) { app := zip.New(zip.Config{AppName: "restest3", DisableStartupMessage: true}) zip.Post(app, "/v1/things", func(_ context.Context, in *resIn) (*resOut, error) { return &resOut{OK: true}, nil }, zip.WithOperationID("createThing")) if err := app.Build(); err != nil { t.Fatalf("Build: %v", err) } b, _ := json.Marshal(map[string]any{}) req := httptest.NewRequest("POST", "/v1/things", bytes.NewReader(b)) req.Header.Set("Content-Type", "application/json") resp, err := app.Fiber().Test(req) if err != nil { t.Fatalf("REST: %v", err) } if resp.StatusCode != 200 { t.Fatalf("status = %d, want 200", resp.StatusCode) } _ = resp.Body.Close() } yۇxYnbDJe:AȺ٢qv hPbCrвcC`}~ߙJIA,Q3|燝?Qn2:޻]|^T~9\gm?sò6OdrxNvFUZ-3Jv0y)mV8U菔_uu8o{YTzGbK[\t/ULYY0n^l @ 9 8 K&&wȽ4EP! jV[O[Mx@].FOAy;>Fj5dC>1 l][atjZ5FC?"@\F*|&KaVl_"<~s 3&j#* pUf0§wLJْ~H%(3P{QGfWU^ : nPޒ}Sus\߼#ȭMZ Z ҰNKtA^F̨Եft=4VD\p!ťh8xOC8p3O'Oώ/NΡ'MWƴz*5+1}e^h-3BxUj-ۣzc@_ %=aphɼ#w Q<GEj,ǪC!kS ">ӄQFSX享 n_Z`KLZ#piZQV2 IeQ'E 4,@EYBEkЄp){?됅u}'#@acWn^@G]4Iݳ?،IqJlXYfzRgH 1j}ĽP@!TH?LрVHP@#HB@:/{3٫,ˢ=f1*1 @ʗO4۸#8KLk3"er},t%N ~9>ȔxBt.^r껺oYWzfVU U sRJC'F_Uv~Nϗ;P. p'n ~4l\Iˈ!h 9R4fs`R>2rxy2 c?uPM Y}&bn#vktբtlB $9MXqBPmZ=ۺ>SIPVG-1\F*ۈ7l6 BҴɲK2Q0y͊RvdpsGʭu; 6 G~Drw7c+v+NдxBI?Rĝw7#w0Q$G k9{`lzynz"~IG( vSĎ`a5LXQNR l[dܣkuG?U Vi}dD$ICAOC6'g(]"CV>ӱh;@|ĸ`ۚт-Ss39Fq^T.18H,b|TJ6qb91)~'`atT%m?&gM%t/ x~y\k;١k OO[,iaD ~i:KČ+}'C8MuI˯̿PH$KJtI'T)v/fH+,35́oÖ BEcE!t]} |]బDA[*'#b$-6Ԉdbu3%!ıZn&e2ژ/4d>WRXgL!ݪy-xh(*E_%A! (woVGW+@k Ї+H;G!_ ld sM\Dȥx'cd`={dH4.x C5:ȓUdA2,”l#m[HxNX19N<@{"YiT ?x&*15wR:B|SFW7l={^$ [dj΅A_}V[ǎU`Ʌ+~u^S٣-Ym^%Լx =}Pj2 qq*+M= KT& vȗi)*~_D儋G đ7ZyXظKT,y^8#H[]㫎<;7@@YZ Hǐ%ChSP m2P[FC-9 ¢$W _( *_wb[rd *q#V hVb:^Ұ"Ih^/*vF]=',l^IBQ9m!Ú}{]8u}A2FM o$$Ȏez ]ьZ,d'Ha9"X6xD|E F e<9.EL1G?2GxUVnE"%_DX QLbd!RzgjwZtds!9H#|^UϮcɒwz_zzߧro;9T~h6#QecWdF~;?%ل c<k+Z˾eUxecb55(Qq dӮ+2B\zdC~2-DV8io?4ԤL.'6$,ϺKl}4!l[IpBr.*g5kY.}hs!L}B [6L;Lc4H Ҫ60@X /}s 11QJzCΣȠW]p(G+d,yAӴwwt (+:C\r4䴡Q`iAvUA\~U'tpȔ6Pgl5,hP լt}8F fݒ}w[!-)Tk#;6=5%NQWm8bҍnG,iFH3YqAgk(mC ֆd-aaƢ6tv䔅S& KhˍMs MmYg`)&,r6QkԻlT7l|DJ.Ndl$͒ћ')M 6u鷗g þBF@c׼w%1lZ jۼ6j4b[1Wى84![4&4R։]!2Q%b6Lb)G;X4NayQk sD]S)#ueX;j^\cx'xG m(|ÁQ.a D:0j?yz 7,'|3RFӢ :IkfPЯ}1K㔢omCE eKVD{noҏ~K[ul-ux營Yl x{kjCfA;R$LݽxuUn6=[_15ЮuP"."%+I #JvbV$Λ U}Vv( >$Z&uͲ(=iSd#P0*zG1yYZUT"u^?*2`~Lo\RI-" @1aw:T=`JkqR. g*uG(-ᵍ)JHLHGV#[mBFs'c )DwH+5Z2&ϝ`4`iV=YN&㜜۴hr;h57^Ih8Lr֦ {፠H✔JLBG6pL0[zeΏ>V> ;}oBeorj pO홒@~`,>FʁB.]إ ,;Fb{}a@'UhLJkE-ٝ{͚IcPkgL5xT\bqy.2 jn~]|t<ēm'FBcqfpoS$"^ Kior-k8'ds w*4&e44:xYUb1ys%ʊGWѪz_LZ B0΄HeYs@Jm&QUOs@3"N&$9'KmDfvq,9U'S&yvRl#>ImcӢ ,eoFl* gǠ-z .c@x,HxDX#ȥU-hW. [V&mohgնy2܁--O` wݟI44,-CfǢX1 r[=&bY"#_f\C&/*yW Ýʫp,?,qdX\42Ki+ٝq+d+{9v5Y9ɥi#o'$X OxWn7}b" *Q7Nfn4$p! j ɕ&~Iϐ{l7)]Qp93Rdb.UjY)F^^^J]x茟^:p<>yB I^-%&R{ZK(+Z $e ]\(<2 F?˙kyw:sM"rLVffYVpJi)E#9)Gx647TQLEʋi!\''ᐴa,/pVY dgţp$xxzT#p h(tTx8)p,6,]LP+EjiWF'ヸ{^2Hs+@r49歁oOZʥQN؟LZNTv"[txH1ZtZcQU{MH|!'6掠i5:9˻l6 Q]VhLwKQc܇HJ>.i;ݽޗmc57+ J+i[,L)P}B5&8n 5z.шm.[:P"&#^=Y$a_L";Pp7LK̓wm#3ڣuը8b.ɯ ӄ OѴ2inC3 2AZLy0n) " I_{s?7 z8>}9LUߤ7rr@"3g?E0f64AL-ŝW J'f|b%*|0S59AKGJ S=ȅq'ݗi;7ϧ-?x>5g3Ɉ#彠n۪y&JxW5e`tOx@{~]i|o+JKKJc|(Ɇndß3Sǽ-'Aw覇Y^bdx\F]*m-I* c:j1É^LbDcLdtՑlNT[_b-B{5֥N{+[$0cS%f#(Xfp#ҭ Kq+R#g w{ VVaaؕrSXy8+2Z5 *SKEV]OIX]uIMhw#3}!N䊇O 6c4#,8%wldǼ 6wl:ZHZ6#9IpyŸpSMe.8UH&JMINq^—!'V!FIc4wxډ M>pGbЄ7FC9ٺGxՈ`ڳl} j0mzbl]!SrV6d^]4NqY6T^޶THcj=v) WGgbf>!rm 2R= y Oi#xMW&EL{Z^&/̢EC=ĤN׃\vs`6&(I4eKwTr8~ 1y} `cE)w ipnd9!gZ}1չ,ՃYv mٓ}SiFI8SA|˔b^NL%uJ͉*CSHV(Ў7UەwG."O&XLB#$80rͰlaqώWD ; V{$B'>z`t $eoz: Iާ. 8b,[P Hdub ]]<5ybiG.%i$zk4X^vϻD#M!z-gPy;i|h2Wa4qH|#Rx.z:IbHn_lsŲg1u3q>"`޶%ۅkC`T&Ĺu,<:Y t$eX2N{-t6 RmQBMU]4hcׇ:*/hRqh [ պ9Ri7r3NniCJ")s8D2|Nחb G FZojcqCu,%\^GB^ՄL﹨,^Wߑ<J߰0RU)7!qGYM9ppXd NC]l{/K<)m" JkP<α/h_|-A)DBa!bAl|#K ;! M/0eL%I+ ķJtXQRյj Ε4f)O@ (c$mRx(!I]k\6.tXlgĦqMo^D59{P$OV0iJYQ9y)T0:S^SK֕ 9qbK|u9M\i_HZ۫WׯOO0! \eB.H[.Œx\s`7DuAV=1ل0:篡۹.J(D;rZw̱R є2AhkJf|U2_Lѱa;} q\v#g4j*n)whԕޭwmR3 S@!(9a) ӷϨK폁+ߨ5/.WUUQaB$JfZlj"ɗdh}DGXgkQkTHJ\H6yϏ>g 59,IwIUL-){z]X(x P.NOObZTaˆ\/|[ l&-6}Ʃ.DM]_ȑÒ mkzqy"Kx",=a,ϳ &d$T o1%VWW!.&'f;rmIs>R1sAndtl=4#N!DJwKY¢+7("˖RHarYCzM5?, ,şe:ڌK0ɬ7"ǶlE2;=txpR$U3^!ɖ^U{U?~ˍwSg_DipPݫCAt$^4"Է;S< G)2!~$@\rC\u(- lwܩnn 0EKP%Lsda W# { j`qwh{`i"ŕ+w:5,V!#aMryn56!<ߞHìEAeDsf>?-(]$e ~Y&J,Q\i:‚Q`1[^! 8u[GЎwJѴ:*jQQˢcC[/;X^. ^D(N8#5`@qyQM$H)Fʣj@ UmQҁ4f(fdȩ$^NVw680щq e]H&4ɻ*Jdҷy3^*g0ļ6ZH-^KHKbqsq=fdGUaٞvĹ6sqё'Z`I?) Np^t;AE)ܑդ | '˘ .Rt=j6Ri4eO(kE+Au(\"(Y=+]=y[{xvPap=]%v09|[_GjȦ9Ц7S殜By1fGVy|muœo'&nux--1%\x @package zip_test import ( "context" "encoding/json" "net/http/httptest" "strings" "testing" "github.com/zap-proto/zip" ) type acct struct { ID string `json:"id"` Name string `json:"name"` } type acctReq struct { Name string `json:"name"` } // api is the shape a service registers: methods on a value, passed by name. type api struct{ made int } // CreateAccount opens an account. func (a *api) CreateAccount(ctx context.Context, in *acctReq) (*acct, error) { a.made++ return &acct{ID: "acct_1", Name: in.Name}, nil } // GetAccount reads one account. func (a *api) GetAccount(ctx context.Context, in *struct{}) (*acct, error) { return &acct{ID: "acct_1", Name: "held"}, nil } func newApp(t *testing.T) *zip.App { t.Helper() return zip.New(zip.Config{AppName: "scoped", DisableStartupMessage: true}) } // The verb methods are generic METHODS, so In and Out come from the handler and // the declaration carries no type arguments at all. func TestScope_InfersFromTheHandler(t *testing.T) { app, a := newApp(t), &api{} accounts := app.Scope("/v1/accounts").Tag("accounts") accounts.Post("/", a.CreateAccount).ID("accounts.create").Summary("Open an account") accounts.Get("/:id", a.GetAccount) resp, err := app.Fiber().Test(httptest.NewRequest("POST", "/v1/accounts/", strings.NewReader(`{"name":"ada"}`))) if err != nil { t.Fatalf("post: %v", err) } if resp.StatusCode != 200 { t.Fatalf("POST /v1/accounts/ = %d, want 200", resp.StatusCode) } var got acct if err := json.NewDecoder(resp.Body).Decode(&got); err != nil { t.Fatalf("decode: %v", err) } if got.Name != "ada" || a.made != 1 { t.Fatalf("handler ran as %+v (made=%d); the bound method must be what serves", got, a.made) } } // A nested scope composes prefixes, and the route answers at the whole path. func TestScope_Nests(t *testing.T) { app, a := newApp(t), &api{} v1 := app.Scope("/v1") v1.Scope("/accounts").Get("/:id", a.GetAccount) resp, err := app.Fiber().Test(httptest.NewRequest("GET", "/v1/accounts/acct_1", nil)) if err != nil { t.Fatalf("get: %v", err) } if resp.StatusCode != 200 { t.Fatalf("GET /v1/accounts/acct_1 = %d, want 200", resp.StatusCode) } } // The scope's declarations and the operation's chain both reach the one record // every projection reads, so the document says what the code declared. func TestScope_MetadataReachesTheDocument(t *testing.T) { app, a := newApp(t), &api{} app.Scope("/v1/accounts").Tag("accounts"). Post("/", a.CreateAccount).ID("accounts.create").Summary("Open an account").Tag("write") doc, err := json.Marshal(app.OpenAPISpec()) if err != nil { t.Fatalf("openapi: %v", err) } for _, want := range []string{"accounts.create", "Open an account", `"accounts"`, `"write"`} { if !strings.Contains(string(doc), want) { t.Fatalf("document does not carry %s", want) } } } // The low-level form and the scope form are the same registration, so a service // may hold either and both are projected. func TestScope_MatchesThePackageLevelForm(t *testing.T) { a := &api{} viaScope := newApp(t) viaScope.Scope("/v1/accounts").Post("/", a.CreateAccount) viaFunc := newApp(t) zip.Post[acctReq, acct](viaFunc.Group("/v1/accounts"), "/", a.CreateAccount) s, err := json.Marshal(viaScope.OpenAPISpec()) if err != nil { t.Fatal(err) } f, err := json.Marshal(viaFunc.OpenAPISpec()) if err != nil { t.Fatal(err) } if string(s) != string(f) { t.Fatalf("the two forms publish different documents:\n scope: %s\n func: %s", s, f) } } udq` x\rؑ-= uSP#|qy7yOӪl-ZX_lvQaMm<[ünle3ӌ),/̓]arsh [% NuK7 ɋ5:K2s{ HmMfqmF=fg*o[&)#lGy:"gj̊VֻhᨉIGXⷵ'uc4SRG.^o?Mv<0h~g>.HE?,iʪ>k3(+S #vڸ,<0C"XQ āxS*~x`7؝rΥ=ح1VUs-)9ϭtRM]wKcu 2.KJFva.?a.\.pOڛ;];hwR̊ǗS9_(lO7L62WmP*̪|w>rw|ooE).L668w{l)PUl85t|e?8Nr"MU׶j0Cu*8`Veًvr'vGo[ܘ{ws';7Oר)9vEe [$ө--!';ҙӦDf[cTzc[ Y ~dM.w>oa1|8GY鴷a4H\0^9BBwLo hu38nM_ۺa1@+8^GF+Gޔ\H˂gJ1`9x\:)oF4іZ'sSgz˴Ldlb eRNZbJtf02;Y&5ΠN>nygCLr`&0Pa]yfqv21l^ G=)k}'u9<u-H>5?/&`sdZCؖՎT ~|v6bZU4Ę[gDP7~$A/Bs&)S_2|cC܀ y8]C1Q8:@+,7hItlPCoq=H7l^aLG&f@4Awon>DՋRz~(l34M]}'v2ͫ6 §u/y6+ =uqE/eX`+ŽN6&s0Oּ߂3=57t7=leϊH1Tv_a׊F k<TZ`=6um `P?2%Z=?,T̮༜_56̃:c_xN~2/zhK>aAmEܡrNu9C90R:Uhp[h/r-;+p ak71;YY*B3'OGO1ejW7~mFlʹd$Cfj8mrVm8$]=IBk@IgUJ?g ܴlLkpҏpj +]?5':?ޠO 3 }ɤ:ᡌDitȎC# K̭-;$23`OTT A ,O{Eݫ=KۣZ<ylLe޼=_%TTcskv4kQc[G=$; ;_}Pl6tھ4)h9KCL0'0G>( s#0N5vR:G[óBZa|ShV;M+fχ'oޘ?y:`hP‘')o;n`6 bi^)H j g0p@׈&;C-D}S /Ƽg;8>0! =8( ꍓ-% ]Ix։B!nFC:4_Nw.,NDnNԷMBnSVFa#*\.U\D z\wz,zp_D SVd5nwGjXitxڬD|E=Hqo8Qj hX87UA.q0glx6Vnݣ "QBcPGGe8ر, ,Äߚ4zk|[دV4@/_Ƭ8 ҉a(/;^[diI9=h <|h#0gܨ4 +xm [fy䞣gfBb`Fa'Ƒ0 K]> 7uk헇ƾbJbOPHcDcۥ` 3DPd`!c+̈Eg2/q-0yBvr4±Ƨ; oҜ̽jMK|qX<d~p|.$!^&?HNSBJS;LCzK8W)W'C9HR̶O9ԙmF)TL2982e$G[ 13F(@IJ@fECl:;ڌ/s6/VKn a4,OSc |>8KLsr-["ڰ˻zasF~akt?ˏUJaԍD7Iz9(;a*ȣ*ǜ jG4> yl;U6̳%N*AʵOFs[D{$tLi LS!gi0b+@r]a|BiԎ!=/)K͚_f%fx0J^#FLfc !I!A6LUGZF w%wlbR䲋b˜EYOn1ky/M4Ewޡ!;*1n砮ze`{;y!\{6˻{THK][F:p@vPZpGft" bJB>8i2'|D kj"-5ƦP[΄B-CcJ@烁ǻ !{bNe/r;GvV<,$@maspAYWe N +%( 7dǐIP=Lv&Hf7V@<+O2b ¼j C'&/̀~h^ &3`G: xDyy$*9VQpv}n>ZD*&IƭP ]~YQ#x3\9sEi8$x@I: 0"3nic77 ۆ?@NdD'/0 ccl+(a{|D<8D ̍耬O0ջ}BKnA*Teu)fc r[rkKuлEm\%];SH{i_6f5SNt{2t< `C.N0P_x$%k=7#lCӫ ,N1MzoK4ɶ'MDlZ',F$ ,(o6dFF Dye֣`KpҬ=k.  f˘*bw e/ _Y^m VD̏&ƍOFF)aZ7-wҍYQ& 0UqXٟ]ffɌ8{o9mԶ#9K'9_VB ŮHdGD$p CJB\(5;B#!D^>!h8U=fU6:RvM8ggTcu,IAeuIHT)3'HJ~WG\Xׅ:m.]9D Pk¶Re>5i]YQ+'#"WN7;1o: w݈P X]hTHteHlDDo5^gI@@?姸&THsFjOQ #ձ N0?)K,xt]Ee]~/2SZCo9i{\.֝bT.ﺭ H!@Lols0t sؘ;\hU>u'B_H? &6wz-*: h""N}P>%jP٤@Օ#D<0%»Td jA%{\A:V"*]Q(epVq!%h؃G^O??e@;|ݹu&<.r,wwT w74Nߚw=rk!F?/ByLBZzW&$nW_~_[b^u2՜Bm39Ȅ+/$i!RogEIc d Udjd{aaPř8C&xn7ۡD;e[AD"$LV9~TGJPn3}"FWogqr<2? 37Ψz!tƔ^01"SQנ@lv Sqd${UэV/@:=nQ}*t,Ix0rsn4 qt<bܭ^! ,Y"Bgt-]2*Z^4bڱ|j^XB;5B-UǮ̛+xX}pqzA-{jE ANKB ]Jy`QX/(炰/9 ;dAS //3ȹs`(dW ޙE 98%(< K(d,>y,^ yC%{{8p)$po(ik܆g= G-6O!AZ>Q ]JI~K1^NFvϳ֜_4 KF E'H9R b9j!S. <?.d&!(&:o\ ||M1{FH=t2eBhϥ#tyTƌY#;\FF{48 X1j4sȋc R['#+0R9],H592µK0F%u&oiMWDtp臡у6+l^MYoN.?kpl8&Z~8O, 郎n~ض' P s\",@BD܍z%09& ZHo-x[f~OKG* G\ I`PVr $5w›K p#+wsbЫx] \ε,c<'Ode̎Owޡ 6^E+{xCU7N4I`Q`(Ys;*[8Gz@J%@OT!H J;50|iwDZr8ѷ{^ȜF'[+ pQf/<8%_:EԊRI >&Df#`J. TK[ ^>|Hأ% (L`[޶h{:u.@ɓl) q%x[\eFMte-( GpsC[Y*%A7YfkRef8k2BpZU-5AY2W+vL:G .kʌw[;{BO1TplD-s]|ov ^M!P}NܕU|)Ys1| 6%LFy;?T1 EېŬƛi[b}D*'捥 W. ]9vl q7cڗX|T*}7ْu$&U7׃l͔d㖀b@MIQNVcȪ"kb~Csl3C!8`īwS+!~xdu1wnR flщzK%f̅ >O±Fsf=@'4NtNJ?۬.<B[>#+xɌQ73MB^'|Şm炈BWnAMr_de?;S"בSۻTj &/( 2BG ˒@@ 1]^(Cb`9U6gK~]1CB>^g=ãOhemo=}BDiYB93sץsKgt;y RڴIvJ|HMZtڞQȻ ezT(E0 _jjW4LRٽMjcvRqLn"nO+(czALN,U:u |)wTt.y>΁mw0xH@\WDH,GH2 kR1 d;?g*uMQdF!1.?%'@Aؼ Pׅ&7J78!j3\MCԗ2w:[j93A2bC]v;O2y+P 3[ث"yyXУN g_,L. : ;@nJ K~ c12z]Կ y )2@!ЛѬܶ.ZMiwc'֐pDD~?'*xuo->fpSO < 7F j/} / D;n3q w@\dԀt<*Tl$|l %\:*d ~Q|XtazV|7=7s$B_{s̀㬆ZAʗGkK \70.SZڪ-ȈTmGL2G"Vy3=c+jDlANe~ClQLzCtd9Vl2 %ia#`&Tqg=9rWfqIqڌY4Oj07ƵlyUa- rEVPٰ2םf@?6?RYFϨ%ni /n|QQ\AAix ,J+˥ Epr  @4ɠ8irD]GJP"DE'(6MkP P{i+Mۣ M<# $LG$&}2B'_R|,O8OI.rk|%/ad2x-.~eB `5 V ׼cw\`rTNmY)5 hY'slѡZo(w8(ԓ柝|^.yLp["jrTtպ[ VDzJ1*OyU0J/FT%]˂4"0茙gLu2*Jڒ؋rGƙ:40|02]Mu#/<ߧy6JίSݞN0)Aj{UTTsx4)ff^e(sS- BM%r$hF ,&E^P6‹,IvgC@)9 $a=[lo/ρC>*l_U,ttjܻX7 /!|[sat2  ܫfIvɇf{J L[/*Ԗ0F ^A=z#ؖ]@`,P{؁MH /BDŽ8* F9  $Bq.IAK0:bǴu|!-xB4>DHgБkOInL2/(j=0MA%$p" %:ƥ.*:HVx{9B6 qi77.d 9?u` G'D3Ep.{#x}Ġ+z0[4ϣ/Md@ h1KTƀO%:rx"bf\ -VuQpƶݥb5`/x3U>C1{?g(i aeH!K%RX.ɬhTɰ(R5D>rf<3zC>”yeERºQ4+/fx(cOpgǕ36OxL`F9 hSYB"AEnFDGԉ,0 ʻSA(i6V 0NH>$Wc԰;MnR: ǹ&$Rz L$Z/_xebبNXI5(:1EWT72@ I}w"GIW@Y`B~ hO:O*֡f R jFÈOq^T-Qyv38I49Bn?D[e=aHg5 *1WF=mSqN7Q]'a4A!F,Du?-R_ѓ Pm=͇o 彶li~{"Fv$;xͬ)36|\jXk&9U<AVG,U4͐B_C5?Dil}^z}+Wq<#II,1[2TfU$G9X?ۆ`E `tE ҂2= q$VZC _U Lk5gI"/ba.p>OA &Q&K֣ _,kG'J1`Fsa8!@F.^a ~-fDc\6ͱ+*}׋Ty\w͎jdکGd Q"L[O^]*UCF4xMFՒa^t, A/)8khh5prNoK_N@/?|}ZNR!~Z@+ kaN:g̸C'B΃&b Al{Oe4p%( H I):䘠.% g`NHu#oeN|\\ 056MQZ|+O7Jctd^#7+64bOA@>[%1SCPkw7}kC?x(2-ڏ"kgW1PZFA5:8| {8rxCV>q.v_n]yTgBwme}XF0I8Gɱgaa"j䬈b0[TZ:0#gڄceAS'b' %YRy(BWڇstUtJ~H bG[P/QśHW8ƿs^O }ӧ$hO ~D*s/lDy5~)hKQ)Ƞ`"i8r*ő;! Q3$̰ϫl5>+#LkYGva:H,%ZB$v L"*5W+,3^mr^cP˶p!QPU~i8* ˺gM:R"iߔhC6?]\jGcq@dwV%]:}_5Y[J7Ȁ@ IƀDb9@:ye{25kB}7|ZiL0bhA3S=Q@@[V!!Q @:*Wnqn9::{ٲU cy`*mќK\ huTJK5fl~y zWƲ_/{;Y_t8TPWCԢ[Nw;ߎ@|{NV顣{ݘ^}^aA3ӌ5Sh.TWKt&69ep&}EEpD&i2 mAԂmYڭ:{&?Vn(nU 9_(岢 .SSg T%/f..0Z>5Y2 -L,pDxglV\:9lj*:),ש{+t~кlN" %jX`%<ǠkuT[i%X"iUgHj橫=kk ;8wZ{o8/EGЧc6Okp׹;-3Z%o_m}RɅD>Ad3p2Ԏ v**+=^2xUSn@H iJAۨV78Tn6P$UU8mIz]7 {8@u#=fwf{z"=0A8f,{^q9 ] :£ZtaK< @)LAx9DYvw*K|3_YZg Z~E19L?,+Jhf/Z =IJ kVpyk,&vsLMQ*k6FJگp$qd0QHLPSi8A։ R%d!4% 6z%BIZdmz9l~vzZy (g4dԿ[;=%Ks7~ΑZH'`D&"xXnbJ 䈔Q.ru)d{ƈP3}}}>I3CJ$;JMߙ}g({>oЦە\Oa=d crצUvK@fs{+f.MR΂P-x2j^:Z0ZY.32\ndgfwFRx~u<Ak. sG M [pcHZjC?QN9=Î*b}gT!@!Y 7$NQʽ\fAO;Z~$G ANe7fBx\[ ꙋ59q-˸eϟxkɮx2!YE7k#Gx5cVu(ޣocoZԛ`Zf=;p:zQA[kFNgga@ rOTeGRH?=cW$O6# I97<{H=ЍEj`[-ZRꠂ[G<ըw895n3CeXv锬U6xzb rbµ*w@# NT-م&^^ln?_%U})duOO= C'#LncL5uFMļuZͬ)IBѶaF$=Fn]l%]6-;w ZFb3QؑazveN쌀t֜L4Qr ґXej|TF*$4g363c_}O'c{YFTj3s=k] IU}ua8 J"XXpqF޳c@\k^hӳ=i Eqʻ>$-/=·t$fD\81"cK2RV3}#T.KMWXJynp,{s/?c.|3IKɘ4^H܀ra)XQX˫,l? 5@aJ?$am;I?m>3 Ȍ떭+~ >m5u%9ήPT^73mew:o I^KLS+<^L.IUC Wy.^MttDZ-R %3Mƥu.mN_b s& Zh`SdeE:,ݰ"c& +>H=G%/1f4^Tԉn C=ycU-*j4tqt*;날,"` N=@^ӏ龤.n/4yؾ(2*?hy—Pr\%h 8でFxr&p'wD뀞RfYP>-t#}PhXFg y^[, *(E"dx*PC`Ka(YJֹO̓TZ.O &C+ƙ -p΋`)Y8[]t> C8WKD&o%E?!OsX_-/s'? Y1Bl LdwpۋX^ƭ-E :@ 9nZLMGxNxi't}Zcs<مLZx;$JlBl{fĔ"+[TG [Ds n^= %ͩ,w@x=htt?1xVn7}b@Wyp45rqȃb8we"cG %=$q^3gf䕾V+_%i42kB|tig2|ʛlIU([O?+.)x4J7 ʟZ)4:D̔ݞYϞ¹z#{ecu'e!?+:͏)?'!0[ ``&dMM02Nzf훣d,=s]4OIQ3[ĶVRd 9˂#^U"E+hOmm,tج*܈e)%\J8#ӡ g M]̳=z}*4ũ!҄DpȔefŖJ\jKJyv-{nj{E`u #ɑk E Tyi<|>rfqxL~g\!-[vC,z+!KY[_(̂2ꡐ%Qp4VҪUDzKFՒvF01uC5Yh[:ĽJkHnQG7:!T£ r6:f5G[@_6yUĆꬠ PG RJHrI^U4At%2R3]O=PZ)\آ\E:2Dgu=Pld(|2 Im|ξG^T +"b>H o o|s0؛nzHuz?'8ܯU7Z0ێ $[L! D+H4k)YttlulMc eB2P(*O+ns]4#_?ЉjQyR!5%Lj a,X| γgO/hT[O:)o{I VUv08pmB}{;;*^*rC(P+~Yy=gEV~˽OTCgcr8}Q7KZ4@8?φ^tHwO$nv9@^f!mJ =xEG30(wF0eia˾Ln,[ﮤ{|WfC8f̲ۿ %ư[=}gdטRz C1oة"0ocU%U#v=KcļU 0tY H^Я`%WjRjJ xH 0gdA]Nj ɪ2eC}KAZ^jgW\.LbGawWeIl8z`HO.Rd@F42r}4@L&%M'wubg.s; t@xxz0D8*`6H\>P,}[ Ne{ I,c-PrAsO4#bVPRLHN <`1RRDXƘ *u[4`x0˒znvT(gјGЕSF$ qj*]Vuw jYx}9- Az402M# U]t2gqdD'wԭ@23<<^OR3 *xᗖru Jūyg<^94LmUr: F/G+LM`#'ӅcB0 `/ ;2aqƍ&4 L c@d[ K>/cx'9t~<91Qq0&ȗ9А_Ȧg9YHQ<+dȳVYTd.mmQs;zT\6%),GX<Ԝkx .h49#zl32[^YyH٠- gۛy*6M"PR)D҂#Vw]mE6$d@ݟTC6hjGw4*T@DH&,*Rmc+ycVNWlڐY&`뛠>F`% D@ pldQrYӃ4pVgq? wjσT~@j 4Ճ|7`jcq>ؔl<= F=<1(,9KvN%qUV6Fk(Q #4",?Ss?AI ZbqZBм'jk4-ɵUvK"^Dғ.A vIڦfLj`aOD~]U[W^.57Ⱑ}.FZCblҩ̟|߻^d~CelmMͧܢ oE'3:1V|&9D[4TsΧ̣ZĘ7%f(r)qHi|ëp!|'*>gd. 2gZ3QAa0$ziؽ:PΨ_ ʆ~Ŝ+f3GǢH ՜z vZ:P?!Ф {ţN%H82r:!GG>OssfRx@*w_R|zb(rݿp@H{0d) __O|hJ`Œ8_j"J-$gS|I@{ZK97o5ʻk$t[^hcҸ.8='HI\а('q "Ǡ=7Ka:D!RK.z΋BK5vms5T>{3ׇG͑*؂*n(IԓoEc&Se^;DY[&ݚ34+;^%zwm-=SD9v1ςRB#AV?3CJD!˔ Hdߑ˞{Yg3 h|og,G-HCg<^#a=1}W,V$8r9zKWsNܗww;wC8's(vrhʘ!{9Ǣ^52_N&mt a!孤%]H]5w觃n-w%̜ XG7N;z/č[;~~NȾ|ϚG âxĥ}\]Kq*eGW, ޫ#~ͪvZS܁CķX}ÿiKy!;v}ʼnfMo1E/sUõb_t k@ڕkqirW-g$fIꍈA!bLRcsj­[rX'KXe ͼP4#Oqv67;%7)! oW͜$pݕչ&hvz)}4%Y" *5u|6E :$yD<)t`L8@^_14¶B8DV:'c<8hy|kh݌={JWX9^=w!p+z\^^fu]O@'@w`Ńjŀz%G{dZD5޶](wmjQ5W@?€-|_ț80P & M(s҄ppcmPI( j~lCaDw5,#ã׌R 9]eE+C#!$Aऀ>P6P5-@- Bp`"V?O6Թᴀyߖ5)0 ]E"{+FgXHdgвjǯqIKuR==J}oE,oy& lˍ 2 2MA7 qL.=ry0OWt4{r7L\y^!GoB$Xt ,T@X1r6;cs넯sӺW;g=`K?!`o~8x="/ RS wdHz @bٓvr59F%(Ir/ W+,ە!H8!f؍čp`3=Hvo+d)QqpCZZb3tAgnHJj>8M&VJkd5xNHp)',0InEy'&T>Oѕ =b~[Fŝrԧ 7C,Nk]DMO %V@|/?\K/ڥePt!RID|]([diJѐcFb)I ~3]Ҳ3Rd3}R\@U*f扣c1 $=hNs[fTaj*sT8ʇ\җ!6eA}l(b&j(P4κ:j@xP?DME}:)ؖpR_C!1S0'|oI9,ut[\}sD>A0svP tQp:4)&yW>Y 1)r8iڗL5yyiWOZZ#:2'pB^"0.-rL>y2/?R+/yU9җ9+WjJQ=M܃!vQSW *8 (p8(NƉvm=9^Q+~ZDσ!s&綣Eh1Wcc Gi~UBz%dY)M ņ]6lˎb㰞x package zip import ( "context" "net/http" "strings" "testing" ) type doorIn struct{} type doorOut struct{ OK bool } func doorHandler(context.Context, *doorIn) (*doorOut, error) { return &doorOut{true}, nil } // TestTestSeesTheSameSurfaceServingWould is the invariant [App.Test] claims and // did not hold: "it builds the program if nothing is live, exactly as serving // would". // // Serving calls prepare, which installs the deferred projections — /mcp, the // OpenAPI document, the op-call plane, the plugin route. Building does not. So // Test used to answer 404 on all four while production answered 200: a test could // not see the surface it was written to check, and the closer it got to the real // program the more confidently it reported the wrong thing. // // Callers papered over that with an exported Prepare they had to remember to // call, which is why unexporting it broke hanzoai/cloud's MCP tests rather than // fixing them. The projections belong to "run the program", not to the caller's // discipline. func TestTestSeesTheSameSurfaceServingWould(t *testing.T) { app := New(Config{AppName: "door", DisableStartupMessage: true}) Post(app, "/thing", doorHandler) req, _ := http.NewRequest(http.MethodPost, "/mcp", strings.NewReader(`{"jsonrpc":"2.0","id":1,"method":"tools/list"}`)) req.Header.Set("Content-Type", "application/json") resp, err := app.Test(req) if err != nil { t.Fatalf("Test: %v", err) } defer resp.Body.Close() if resp.StatusCode == http.StatusNotFound { t.Fatal("/mcp answered 404 under Test — the door serving installs is missing, " + "so a test cannot see the surface production exposes") } if resp.StatusCode != http.StatusOK { t.Errorf("/mcp = %d, want 200", resp.StatusCode) } } // TestTestPreparesIdempotently: prepare runs at most once, so repeated Test calls // (the normal shape of a table test) must not reinstall the projections and // collide on their own routes. func TestTestPreparesIdempotently(t *testing.T) { app := New(Config{AppName: "door2", DisableStartupMessage: true}) Post(app, "/thing", doorHandler) for i := 0; i < 3; i++ { req, _ := http.NewRequest(http.MethodPost, "/mcp", strings.NewReader(`{"jsonrpc":"2.0","id":1,"method":"tools/list"}`)) req.Header.Set("Content-Type", "application/json") resp, err := app.Test(req) if err != nil { t.Fatalf("Test %d: %v", i, err) } resp.Body.Close() if resp.StatusCode != http.StatusOK { t.Fatalf("Test %d: /mcp = %d, want 200", i, resp.StatusCode) } } } UKxWNG}DNfzVpP;D\, Bwmw%)/̗T셅XNӷ:U[N $$QXOYI RTzy -?tiMMm* }$oLEZ#JI~(aI$ GVxe4_.ߑr4 OB,Ԟv>aY}RT ' Q e11lRRh"vFXs·x5]'C'kgd5Q_qBxXRnne4<]4s,v>s+ӫ6yD*vo+'g,l#)UXxa!B#aa&WZ}P[Kh ?&.ղQ*}vyȱzc],gf$Xuq&emT*[Yq0Ov|-QaZ24UI\G`\@ݖ\sK3_̍ zfڵ؀@Ta;xwC,eA,\KUЋ!fA CV@'L+c ?gvbj">hi ;81f[P()z`'dӵ k&3hK{ih~L!u(-aLctH}H [-BjBx7m[|ڮxpn]^]vx'2;/`(K95cIUXOy9o_/uO/Zu>'Se[(2Zu}IVOBWZӐN%|{if 5xB }R儆+GG&1ˊ8IC92V1wDKw :ar NL% ='X3CRʳ1+bЄ ՗lV;juIzgwH7J架R]u;R6J| sFC%}h֔HA\g ԛ)]5$ocL΃; Ce1BLEa/hcsnSAx@j4)V!,sBjE8Tu[HY@@RN0o` IAFĐ^vt @$TRJox58O J$b*RkzʮLSDI6[&!?8zsŭ0 ;q”\-Q(xf +L|q6@RES$<ZډY^Cf̲nx x>޶ؼ]x*={r5CS>֯oZ:Ŀ[I0L:_s2v"o_O:s9Oj}s\wϼu_yx[r8m?Ug[L8M"!e`H0I>><ɜ{BLWV폔%\"iި麟BF{:%W2e_V&3Lg*LJLq'LNdeA,R}hnz aieT?O <*!XJ$)UU:3xf'*U( -*Q* L'yE@JkyiQ<(k[!JI<:ꋙ,l}_g^ [/6A3):ɥ*`x*HKk<)71lDMYim=C- 1$,)q Xy^7 %)74}փd!xC.cÈX?6+.4oF\L [8) 1*|Sn+%UҸ7Luz;bfWTfa`"h1e<ӕ QUlRCJ'I$^hF_O<8LRM€|Q\f*{0&Q h 9V$y%y66 И:%urCfF?Ǫp0GIhdҌrCO/[ƶCoIkVà 蔧pum%(+YFFb .DL R Te>oτ(be fsݠ(;$)7g:VgoG %04UDB+iZJF&Yv'@q!IJR`I;05r?)A>Nf`TռWwEUt:بD_o7`݂7 0Ar۝ցh[ Mtar#][ B$lP=X$e߈0!'&D}ФdXd@9og UOdמa; {T{SA<Nb(cQXǛ Xl57L_dO`:샅c+|@h=h)U'Go l'@fښX9W Metӗ0<'az_HP<:~Ҍ@!o. SDm(x4/>ƶif6$=KpfԙRJHs^o1bTj xXD{%`i2&By22UYR,/q yHR+$oaAg[čJQR&7^:?9>\e8ԡ=t!ћOi€f. jltQ5& ֨!|'r=2zm6SU<*\V*4;uG+lժv qRR<@4y} %QO!D( H~ޒU7@=6ev'àAw3 CF0gB4 XG!<êWPoØh J9'BF,#$rRw3a"17f# <&HB#'54djL BƆ49Y,8Uؙ;Gm2 F7ݣW)>kʋXv]=ZeYQZgo -R|c*c [)\jG PT:9ʭT u|̖dhaA I>b^TVQQ":0كy*.v %y'M izux&Rc. d*!BҼ*4#7QyvC'BH5g2"Tu+xUŻqNpEsGD*bT6"NaEof ԭO@??::Udv[cߓ1 u-cDSEڳu >Yv@ͨ&`>$z$0w0ː\B ,+Nr̵G,"R7Crɴ;2*{pOkwM}I agd'$2$7\DOϰŃUt1]D[R[x< @VWD=,`՜]cZlVlf&6H+)IaK"M\ ~$Zbj3MVlhW*+TIj G xx߶/NkmQ&"Ui7ֶl9ٟʼp}B^\^:>nN{TGCm!.2kHKzY|́j¸=J'_o5*JVAuh ●'8{s@*X:(P@qN$y1YiNQց1Og#6,U8wىI슟:Qwڎ[oby:UvjY}֐u/bsνufg{uoK,$no?8z@j}qkVp䪿QE#LCmԊL^mw 52n_X_o"eܻ3ZlxD轏 oe^Ыgt-=K+ ۳VL9} A;!8a*q=x2{ N3AyW&''ݓW)9>kӋ؜v]ɹ) VO =J8Xw'[~IaK֫6@2?~M=N\T?ثS;CChM72~9ȁ"3VJk>Wj'.KV_tGTzߪ$4i޸PY}s EHB|Fs_[xM.SC{#Xf̗]r9C_s{FuHQ[ en!|}U|}ari1Z\^Vx2 |OnWIs2W  _~͸e܏4)ZN~VB˥v 1AWNqca"s?ku&7ئߦqQ߭+A})ȗ.ʥ'NLvVn.ޔR&7|-պ_7|ϼm ԭĝ7ʷ]"N7@ d]56~c Ml6E}$hxEJA MZ56*ZJ@ms@>ǯUd \=l 7;}DA%cb>L #RoOmSԘ~Ba%DeY2la,Cl0.5,(!u2PPJ]f΀ʑKDQI jJ (T|2T+^NIQuMgUγl'.aN7fCas}DVulY.R7ᨐf \aL*aXbgqk]9T8Zz }4OӰ[UU/5PPWe}xN;Xg;A|Niz~²+δʣ t{N-AZPEC hN5jJgOSKz*Sv-0??@ Q~؝ҴԕwolJ4`t4[԰`bSM95WTCYy q,n-(nϹ\/R]U>_0q4MOɊqV u.:HeoW+G?'/E:N77ѿ"Ư Gq^u5^oϴߑawp/}&.V?t'6IhIN7(5?8]W4G-o@y+GÛZ^;g*xWnF}bJ h4A|%@"X+qa,@?_/YJ[P]̙Q+Tｮ}kun'(—R{Lf.,Ir0WϽ+=mzQU?Vz;9nw0!^Ltvt ]_MNGS:G M4h|ZSR56+iK ^)W#t8͍N@j_*pȱ2֤)cKZk". [0,vp-+p贴Ma2x}MX@+IhB\S{Iʑ:WWT{`p]iLeJYZ"YOs.Ӆ弄$]슔sϑ Z}xQz]-aU D"p6z *xlt NxXkP؇ W7얈Y`dvu3i%*;=o*E캌LLӳiwlɡ.*^G/Ńb#jT%|d흜U̟#[nXU'} jV PZ{UhpV 1$c%NJ#uDg~vmէe%& 阹\JSxo\Dǥ3^ ]2'{F-TJw.UXM{\И)G3-M 4З2XGyik曱sj|n8*AQb2\ ztG 'G}x?D ?G=į@;_h# ult2tj i_> ĿG3!G%{߂S9|ZyU㈍ӓkeK.j8, T"Syȧd?'I&6GN‘Ľd""Qa1 ND۲sk]#$<0DIhzUt.u:3:cQI&U|x>ɛZcg!_D[kb`_S,aVHLä^ۂX T̵܌p= 6& y)M2U-ǦvH 4 CBd`! L1P6 g}.Ӊ› `;K1N (fYCa& +z6Le=\^0[^*9,Wf2m3zqGfS}ۙЧG. }a|~lu? ƶVNØGw4ΊW5P 0-}6/-G`&(#[*о *B&TT &PRaul)4b\Ұ&pM=Q-LlɵEaTx=KJAWS.$T+š:MV r^+X| !lKPqr #rV(.s$~GP^ 0B m@w`h--&Ä@IqPv3|&7x&z=C@ -rcCh8[ʞ]j* vdY,ԃrn>`L%CVZk~X6?֦;;~ٱߪϺxpackage zip_test // A URL carries one value per name, so a REPEATED argument is written as one // value with commas — `style: form, explode: false`, which is what the document // publishes for it. Until the binder read that spelling, an op taking a list of // ids answered 200 about an empty list. These pin the spelling, and pin the // document to naming exactly what the binder fills. import ( "context" "encoding/hex" "encoding/json" "testing" "github.com/zap-proto/zip" ) type listIn struct { IDs []hash `json:"ids"` Names []string `json:"names"` Sizes []int `json:"sizes"` By map[string]string `json:"by"` } func echoList(_ context.Context, in *listIn) (*listIn, error) { return in, nil } func listApp() *zip.App { a := zip.New(zip.Config{AppName: "list", DisableStartupMessage: true}) zip.Get(a, "/v1/list/things", echoList) return a } func askList(t *testing.T, query string) listIn { t.Helper() code, body := call2(t, listApp(), "GET", "/v1/list/things?"+query, "") if code != 200 { t.Fatalf("status = %d %s", code, body) } var got listIn if err := json.Unmarshal([]byte(body), &got); err != nil { t.Fatalf("body %s: %v", body, err) } return got } // A repeated field arrives, and its elements are read the same way a bare one // would be — so a list of ids says nothing about ids a second time. func TestAURLCarriesARepeatedValue(t *testing.T) { one, two := hash{0x11}, hash{0x22} got := askList(t, "ids="+hex.EncodeToString(one[:])+","+hex.EncodeToString(two[:])+ "&names=a,b&sizes=1,2,3") if len(got.IDs) != 2 || got.IDs[0] != one || got.IDs[1] != two { t.Errorf("ids = %x, want the two named", got.IDs) } if len(got.Names) != 2 || got.Names[0] != "a" || got.Names[1] != "b" { t.Errorf("names = %v", got.Names) } if len(got.Sizes) != 3 || got.Sizes[2] != 3 { t.Errorf("sizes = %v", got.Sizes) } } // One element is still a list. A caller asking about a single id sends one // value, and an op that took a list only when given two would be a trap. func TestOneValueIsAListOfOne(t *testing.T) { if got := askList(t, "names=solo"); len(got.Names) != 1 || got.Names[0] != "solo" { t.Errorf("names = %v, want [solo]", got.Names) } } // A map is not a list with different punctuation. It has no URL spelling, so // the binder leaves it alone and the document does not name it. func TestAMapDoesNotRideAURL(t *testing.T) { if got := askList(t, "by=k:v"); got.By != nil { t.Errorf("by = %v, want nil", got.By) } } // The other half of the same rule: the document names exactly what the binder // fills, so a generated client's arguments and the server's binding cannot // disagree. An id is a STRING there — one word in the URL and the same word in // the JSON beside it, whatever it is made of — and a list of ids is an array of // that string. Describing it by what it is MADE of published an array of // integers for a value nothing spells that way. func TestTheDocumentNamesWhatTheBinderFills(t *testing.T) { type oneIn struct { ID hash `json:"id"` } a := listApp() zip.Get(a, "/v1/list/one", func(_ context.Context, in *oneIn) (*oneIn, error) { return in, nil }) says := func(path string) map[string]string { t.Helper() out := map[string]string{} for _, raw := range paramsOf2(t, a, path, "get") { p, _ := raw.(map[string]any) schema, _ := p["schema"].(map[string]any) kind, _ := schema["type"].(string) if kind == "array" { items, _ := schema["items"].(map[string]any) kind += " of " + items["type"].(string) } out[p["name"].(string)] = kind } return out } list := says("/v1/list/things") for name, want := range map[string]string{ "ids": "array of string", "names": "array of string", "sizes": "array of integer", } { if list[name] != want { t.Errorf("%s: document says %q, want %q", name, list[name], want) } } if _, named := list["by"]; named { t.Errorf("the document names `by`, which the binder cannot fill") } if one := says("/v1/list/one"); one["id"] != "string" { t.Errorf("id: document says %q, want a string", one["id"]) } } ,+xXr7}&]Ť3"-?JѷDUJg@p0@ьª ‹T }88B&rv[/ c[Qbr:;|iyb5%fC5VpՅ?υv[<믍}PA?~5+zR/R!\*k'.G_? yjҍi0 !aqR13Vhў_~b'B_/z`$ wKIUqvST!<䊑!XLuY."nSdAG0vdZ`rj:e|T( ÆY1*X NOܘFR/?B/YF"DY*6p3opR?lSa`BiO|VUiV.܈; z9Z Kދ4$03 XLZm bL^%^<[`e︅7!%'SMm/v ;@pFrwL ^-u~gȮ}w,XB0L?(݄ѹr-m̫oDbM}d-<[(VMuEG?<輩`BYklqZW6?T!DE [E+ހI1.պؙ?gv9bI;9ԍ֯pA"v W_|G"zAGPn]HQJ=|P e2[)[Ix1WޕC]w{ )oy\Unn #cNj7!gnPbI@du ʍ!]DtjMJ "Wfr%Q\hpv;h᫡x-biNtУT %0.Xض[a2:cj?MQN {7`N 9-u:Rg5``8|qj,[DNMZD) wx ҅t\b}47f;Ȭ3wtIpϩ+T[v*A4wU|t}~Bp*N3=@nSEN A9:eb8DqnR'ʍh,48ǒ)7\vB93c+eXש?UbEXq$K2S4tc򠰝(`?JK qUR2Iz_h:AڡWLv} @lg<^ޕX>uz.XkwOO8b>+x3uh *Ө2eYURKJ^߸*2HN!y?2pE s˄l. S0d0'X&X60U)Bq Mnr! /Q:H0Oyn5*6 | o5ud9Z@pp 6MD3!$U]?9`TM;))@iݭcO?2yLK%swL͒K*$ [~qLO4 %*p_P1 (3p,;uKGB%CNr-Zhuh{plrm뻿ַ[Byv/M*r]_i38}ZY悥}x`uo~V&ݽk :h0|F_^݊{?s{xWmOFM J.( {1^gwゐ# K̬}Kzv^yfvSguk}(޿}I֎JY{m]J-ș M㛲^EiQ=='E 9o谥ڑ4 9TMpGװbՒ[# }a-f^jnI'i$ ?(v.͖!|泦v+FlWrkZ^bWm k?Y0n"t3}Yc*Qe nJ*`^_} =dk (eQT_t $V @PnsSq6ݙV656~\y:M>2I&},7㯪f &HxT)W IvBstO| HL(*mNIE;WB}3t29]L?-d =5Iaq4JվԿo/ OQ0AіU 1Hbǚ |  XKob7ںF tX׈rS^E ?"7RJAz0B&jNdGY T/߽ @t{'R[f),fmR]! ?k݅:g\A؄ӠB>QpcȁfB&WC(f>B"rr3DŽθ&q]g϶6Ç۔ I|+;o5$%LT= S0jBVp*VxBt}z<8% _UJϋVNV4EE  >I7 8Z/2&2e}~}u >Nvj֠z8. !JsR{2( 1ńh W?ݾ] )nΡTzuo^ j/]dDc٧[s7x7kaz,~߇Ziw])d*RK0yJ̠{\zlaTZntsK 4yk~#) + yS0= BJy2d쉃a,9:iiL<&'BTLE@qq]Wa?VeQ @32 Id id32 @40 Ratio f64 @72 } interface W { take(req: Wide) } `) in := app.Registry()[0].InType want := []struct { name string kind string }{ {"Flag", "bool"}, {"Small", "uint8"}, {"Mid", "int32"}, {"Big", "uint64"}, {"Name", "string"}, {"Blob", "[]uint8"}, {"Ids", "[]uint64"}, {"Id", "[32]uint8"}, {"Ratio", "float64"}, } if in.NumField() != len(want) { t.Fatalf("got %d fields, want %d", in.NumField(), len(want)) } for i, w := range want { f := in.Field(i) if f.Name != w.name || f.Type.String() != w.kind { t.Errorf("field %d is %s %s, want %s %s", i, f.Name, f.Type, w.name, w.kind) } } // The offsets the schema stated are the offsets LayoutOf derives — checked // by ReadZAP itself, and restated here so a change to either is visible. shape, err := LayoutOf(in) if err != nil { t.Fatalf("LayoutOf: %v", err) } for i, off := range []int{0, 1, 4, 8, 16, 24, 32, 40, 72} { if shape.Slots[i].Offset != off { t.Errorf("%s lays out at @%d, schema says @%d", shape.Slots[i].Name, shape.Slots[i].Offset, off) } } } // A .zap file states an offset and LayoutOf derives one. Where they differ the // schema describes a wire this process does not speak, so it is refused rather // than silently re-laid-out — and the refusal carries both numbers, because the // author needs to know which one moved. // // The case is not contrived: the IDL's own offset assignment PACKS, and this // layout ALIGNS each slot to its own width, so any i32 followed by a wider field // diverges. func TestReadZAP_RefusesAnOffsetItCannotKeep(t *testing.T) { _, err := ReadZAP("packed.zap", []byte(`package p struct Packed { User text @0 Count i32 @8 Rest u64 @12 } interface P { take(req: Packed) } `)) if err == nil { t.Fatal("a packed offset was accepted; an SDK from this schema would encode at the wrong bytes") } for _, want := range []string{"Packed.Rest", "@12", "@16"} { if !strings.Contains(err.Error(), want) { t.Errorf("refusal does not mention %s: %v", want, err) } } } // Every field that disagrees is named. A work list that stopped at the first // understates the change by however many the schema has. func TestReadZAP_NamesEveryOffsetThatDisagrees(t *testing.T) { _, err := ReadZAP("packed.zap", []byte(`package p struct A { N i32 @0 X u64 @4 } struct B { N i32 @0 Y text @4 } interface P { a(req: A) b(req: B) } `)) if err == nil { t.Fatal("accepted two packed structs") } if !strings.Contains(err.Error(), "A.X") || !strings.Contains(err.Error(), "B.Y") { t.Errorf("refusal names only some of the disagreements: %v", err) } } // A schema that declares data and no service is a good schema with nothing to // project. Answering with an empty registry instead is the failure this whole // path exists to end. func TestReadZAP_RefusesASchemaWithNoInterface(t *testing.T) { _, err := ReadZAP("data.zap", []byte("package d\nstruct D {\n X u64 @0\n}\n")) if err == nil || !strings.Contains(err.Error(), "no interface") { t.Fatalf("want a refusal naming the absent interface, got %v", err) } } // One app per interface, which is exactly what ZAPSchema takes on the way out. func TestReadZAP_OneAppPerInterface(t *testing.T) { apps, err := ReadZAP("two.zap", []byte(`package t struct X { N u64 @0 } interface A { one(req: X) } interface B { two(req: X) } `)) if err != nil { t.Fatalf("ReadZAP: %v", err) } if len(apps) != 2 || apps[0].Name() != "A" || apps[1].Name() != "B" { t.Fatalf("want apps A and B, got %d", len(apps)) } if n := len(apps[0].Registry()); n != 1 { t.Errorf("A has %d ops, want 1", n) } } func TestReadZAP_Refusals(t *testing.T) { cases := map[string]struct{ src, says string }{ "a struct that is not declared": { src: "package p\ninterface P {\n f(req: Nope)\n}\n", says: "not declared", }, "a struct that reaches itself": { src: "package p\nstruct S {\n Me S @0\n}\ninterface P {\n f(req: S)\n}\n", says: "contains itself", }, "two methods of one name": { src: "package p\nstruct X { N u64 @0 }\ninterface P {\n f(req: X)\n f(req: X)\n}\n", says: "declared twice", }, "two fields that are one Go name": { src: "package p\nstruct X {\n my_id u64 @0\n myId u64 @8\n}\ninterface P {\n f(req: X)\n}\n", says: "MyId", }, "a list of lists": { src: "package p\nstruct X {\n N list> @0\n}\ninterface P {\n f(req: X)\n}\n", says: "slice of slices", }, } for name, c := range cases { t.Run(name, func(t *testing.T) { if _, err := ReadZAP("t.zap", []byte(c.src)); err == nil { t.Fatal("accepted") } else if !strings.Contains(err.Error(), c.says) { t.Errorf("refusal does not say %q: %v", c.says, err) } }) } } // A schema states what an op takes and answers, never what it does. Every way // into a declared op refuses the same way, so nothing can reach a handler that // was never written. func TestReadZAP_ADeclaredOpDoesNotRun(t *testing.T) { app := readOne(t, "echo.zap", echoZAP) var op *registeredOp for _, o := range app.Registry() { if opName(o) == "ping" { op = o } } if _, err := op.direct(context.Background(), nil); err == nil { t.Error("a declared op ran") } else if !strings.Contains(err.Error(), "no implementation") { t.Errorf("refusal does not say why: %v", err) } if _, err := op.invoke(context.Background(), nil, nil, nil, nil, nil); err == nil { t.Error("a declared op ran over a transport") } } // ---- the loop -------------------------------------------------------------- type rtHeight struct { Height uint64 Name string } type rtRange struct { From uint64 To uint64 Blocks []uint64 Memo []byte } // The inverse is exact. An app projected to a schema, read back and projected // again is the same text: same structs, same offsets, same interface, same // method names. Anything this file decided that the forward projection did not // would show up here as a difference. func TestReadZAP_ProjectsBackToTheSameSchema(t *testing.T) { a := New(Config{AppName: "probe"}) Get(a, "/v1/height", nop[rtHeight, rtHeight]) Post(a, "/v1/range", nop[rtRange, rtRange]) Delete(a, "/v1/range", nop[rtRange, rtRange]) first := ZAPSchema("probe", a).String() apps, err := ReadZAP("probe.zap", []byte(first)) if err != nil { t.Fatalf("reading back what this package just wrote: %v", err) } if len(apps) != 1 { t.Fatalf("want 1 app, got %d", len(apps)) } second := ZAPSchema("probe", apps[0]).String() if first != second { t.Errorf("the loop does not close:\n--- written ---\n%s\n--- read and written again ---\n%s", first, second) } // And the structs really are named — a loop that closed on two anonymous // spellings would prove nothing. if !strings.Contains(second, "struct rtHeight {") || !strings.Contains(second, "struct rtRange {") { t.Errorf("the round trip lost the struct names:\n%s", second) } } // The SDK is the point: a schema in, a client with one method per declared // method and one struct per declared struct out. func TestReadZAP_ProjectsAnSDK(t *testing.T) { app := readOne(t, "echo.zap", echoZAP) res, err := app.RustSDK("demo") if err != nil { t.Fatalf("RustSDK: %v", err) } src := string(res.Source) for _, want := range []string{ "pub struct Ping {", "pub struct Pong {", "pub async fn ping(&self, input: &Ping, ) -> Result", "pub async fn notify(&self, input: &Ping) -> Result<(), Error>", "pub async fn health(&self, ) -> Result", "pub async fn shutdown(&self, ) -> Result<(), Error>", } { if !strings.Contains(src, want) { t.Errorf("the SDK is missing %q:\n%s", want, src) } } } func keysOf[V any](m map[string]V) []string { out := make([]string, 0, len(m)) for k := range m { out = append(out, k) } return out } $^z x\ksF,6SXIRx+DܑHēըlI @dF 9vM_xs}4]0 _Ѽшf4+LI~(3L(J&ӄpCZyh66=Lg YZՃgI2o6v}gihGnfL\ilY?6:kMYY:Zj@׏o ]Qapwgpm)/xfV`~xssLr6?bè/;Z)'cM>}L!* N8beĤIh&dϭ(AQ B՗QռsDS-lO=@iYXLӑI Ph$ۊF /l)JfTѯYVۺ٧r 9lz+nl܇ l z`4\>z0lB SxQzsl J"v sߙ!4 L: 4 GQn|g\)D;jmXҵÅOwsa}d>N͔HAyܩIPDUaF'V˚̈́[?d~}H1g q$x7=h/l.mpot/[;Vs9ڍsG&=] No>؈ءVc aۼ24wiK Y1fbhE !h"a Zv`482Xϲj~̪5- }(VDD.yrM*qiG?YP L8gQ{v1ӗ]3x{zb:]߇?=5)N̫;/wOVe1c+*S#h#w M,s;rRJ!lb,$o>wJ- &Y6ka8VCbi0DZ(1K'94NK"%Sz2ˁN1u5:S uϖ"ǕXH@a)POCv+#zsXH ^: Zِ4qkw"l- s5:{wOޓG̙ΟΒ Wid : k ĭi^ ƭ; =$YWvg/ujgOe1uo\Yk{ &ww-10 ՜ho$A*۲P~svwuXǵx?1: h !&vIZy{;=*gDd :1mc:(NP.8$K/ՐU1?+)0*|Yų%|h9q 0#`"MkT{eJx/[XyTﵗ7z^ %ko Aw ᴳ{t808`r# B=n:h㡙/xy1 Ty;wXP/]0+~{+R-EB5Q v<9Pݣs+%EdX*PH .%_ ;f4>2f}GgsfPI@BiCbj ӆ@|èF`aC]jc 0n)i|OeĚ8 ̏s.Q-5a *8>?~Zz尹+JW%sCt8s B (x79t9h :`xlsY38\N^K( ;ɨ!}vHhpI,5ɇ炾D6}aB&.pcU~ dmrfKW*/,ΆVgߟq4\  Q*`/"07ռ]!BJD,bUhS$l0:zFpqBJixDuQ࠼g8Z "*"ʖeدピ#H4Bj Pex$Moo:c4@LyO 6qm>ʩN a` yC9cw.=PBӘ KЧm4+5-=^͎+Ნϗy@^t{[J̆.It⚷]t`erk1X1!;gŐb_ϙV\L)r_M~{ 6 #apTk$D@W~}|L0? 4}JSBtH*[!{U]{2Js),ojk`vSezUT H;Q(r,&WQF߽}< /b1P\;.Rc!46qwp|=0>.k[b?|}F) ց(tB ap0c$DZtV+w:$ N8^~lkr DIaD_|sˋ\NX4: ? /e< Afj@؉'8dt QlmtFZH3tSu3|XTΈQ 2 (g"=FZL̯PlcZA2-j dԌV>4epbU,(cTQO>)DI oWQK ap}ǂTNW̩$x)C43)tT8v8!"`  j^He[MPCn:d"L0} 0E#bK8jq$d] ~ZtXML2(5JP@f{??ӭo|#GYJQ,^y~ƊHs)\T&p)\u׈{uɍ"@)vLT^s0d9Q $n%X͚l:~໭?*Gpk(Zp[_ ( N#*IϓA[?ndK/ jІEmPH (ܖYr/.=P\\$uOD\XמQiVj\%S"I<Ɋ9I,g4 Q&ĽQ^rP# +R&H6@mґzNGtq(D[esE\U#Z;pC&!5*Xm9oK<]Ǿjm8UBf]$&0//a/*зimʀj)}-b~Lvmh1Ɇ肴i<\҃ =Ͳc S*"0ysՁn̨V {Ƞuh_Q|3=tIZF(֫&eX=+M-bFYBZ!̞-ٔJQkVo @Y;G\Y3$?uGux_ NҏGu|J;weoo9k2ЪY>"mU`mU],K3o J؉}HZC1(vR[IQGm *ʙuOl!1Gu3'^KlKϗ)T 6[F5w>l7,^R ug\1@vNaxGMc) 1ö4+]SXl\u3!9QR'U95K?\j9BEv[x:PV6l)W@X 8Y"fZGϘd@ƨরM06mХ\*<30H{"sY@LoN}m%*(WI67uz4[%QC s12=0I|CmNnA( mCqb6i[Mcꉾyf5ydw} P15,CG i @WY-))*I٨;Pgp0Q5OÐb6)Sws@ܰ?X$EVJ;<4{˟lU VKEN?^Kg5b=]'қo"c2}5RS &RC.T_.β 8j=@η^\`op>)BwIļ!y۩顊92#S]KF[PP)kq L 7O0 Q<~A ںu%rf(7`:P`Blb@`ẍ9&60Lq@<ȑf 8ґC0JWM@"^>MbDi ^N7l|B~X+-5 tݣv%+pH-c>]\G`+sH( fLfVg` 7 lK eq\a?:@E7v45Zd_\u 9Zfg5dAk5"2UމQi|T1Vqߊ ˆ dPV&fb0<}Qn $O8@; G@\KUΡtiP m 2$aJ12[PU=]FS7hߛ}B"`5)DpL\tW(H>A %Ug}/8hB}KRؿxkP`f͇Vs  kkuWjuSe^W3{d:sU $vlU :UNQdHl5k\j:稵EqA_1(*,ORdU3S3ɽ{Փ2rWCEGj/*h7#2O$U6Xk+J%\1DzEw@^[EPĄJWߐּqKA& Y1-L|@)`*a [`- n`q|!-(BCZ@Q\ 3xU }81[ sƩc*xvm7&k~^>N/m⛿cצ+[7C?㘱]l\`ћƼ}5YUp]F{+4vLBWNkCń|s?i^ + O{¨xhvg.8q*0wvj TUІ2 ӊtp_x~8:c`]ʋ%nʑ/bSbD"[m"{2w+-!fmnx@F?K%},~.K-;h۬aio2E#V`jSRxkA)ҊKQgѲzCԶLd;v;L\b) OB?oiM-ff?1oO:8p "ޱ\P2b}(B21"h)#?d\drz{&.<]Inu݆T=>薢2;ur۳+ n"`!MXs!0YFFK)XG1;2FZԐXs) $U#5-snfLJ ni@z5&R sJa Iե&\kEW#'wzKASTSIRT^`{݁90cbI0Dap܋⃳H)7t ؇a+:=_3!3Q88C3M*'5D)zF{"oelZ˵quYYVZ fRlj9*I'~DnHѪ{sM(9lK*zPkΎj(d 9c>@_n~7ߙ~.}x27&e6k>AЏoyqӗ1ڦi ϱxZr۸m?3J.ݝQNDIM,Vv IX -+N:}}~瀤(;vlG" ;TΔx׹rN2csB<Ut:LJ<-&8J=܈D0B14}2t̺5C`1z LA{ΝJU8TOBsNMxձNenБ6#r<:V̤N H;*⣷9-\.M ebKVE>Ҧ{Yv 5l#i'':Υ͋r}%|X@*Bqm5vݰ*/l*^zOo@h_;5M ԯlOclR!qC1fS s'|KkXǼX2[g!Ex yHjjŭ#2i\XENL,MHh/[<aҙbf֪O i"˸~eWE_Ђ[?#C1H悬z:)LJCpSFDs?%oc/=&l4jT&1Znѝ(f|~boJ%R887էDxHseCҙJա\Q,Ѫi\;NE$#Ic0Tw/ f~*p"D!)P4T۪Aڪ4V FE8&0q%˜s?;iA@~>sQTv>;0E6o7[X‘\"4\kl8tUUD!Nޖo O1=p{zǔ|4I4Y$| 4 'l6vB-ݰP|}շٷ/}טX`UO+86M5k e@&}NX~+ʸ^2y4eDoΎ=j3? PgPGNW$슺r(U0ǡN E*׉at[9oGCq;$* SnB0,əu,dSƾOt i\3r!jB+9S%[հ=*=lD'̔gѣ $=ShH۳49v#.:K7JWUx_RɯhGtiG ujPx߾>yv7ƄnŁ)kbz@~}=P\\\uݻʔ AD 'հhII6 zc-6ԿITYK t&Qduq4Q, g^X d:ٖ/nUbuSm 9Cw(VqqDKs6``wloN nxjj}Ͻ&咉*&-Bqc bsbYحKd-M t. ֱ3s]t/(jBs*G]JbEr#ü/]U*']}ec޻WKr&& W(MƢ!E6ʆVGݝmrFe_+%\Y8az2_]!$H$tEʿbS/{m= .Sˢtl*w7`+hz/lWdMo⭳!bs%3 (jъ)&_Dfr41$0zB!RD @GfV-VS%- ^ eD_Ї=,C6QOđr*GFٟ,T'皦9؈QlbRƞՉ * +iUEkusN d##mRYL*6Rc\U֮d2^x$OpPGg㽎8x4{r "6G0q(+0.$>V1?4I0% M.i YyH ً sou^ʈ($ى)"t{OjB>IXPbOB"*Y.7 *v2tK>2'[H( Sn-/k !?YV` H:0,PP X NAyC"lkqQN5ZlOt`[mSٳzR^0!r4>>Ff#r!&*_T7 GЯnq{235!XiX53Q?š,.>#*vRIR 4X`~a#ɽ ',|A*4"¨Qe_iʯgʐe'wӥIDpG "S 𩲍k\VR'BN6$JRj܀8V(d=O!y^ d$`Aa?q7~t8Ł0N{! ))bh1(X-: $ԦZ 'd9`j@UkIݠD]U|s2I W9ǐtV,zH$L+{VErF>&fESG܂N45̿y[vN b:|9o:nG|gŽ`3Y9Afm7> ;+[g+ n5O\Ak;Hʞ"1+zLa2/OU>7'jڋ}S5y/OUR>nH*p<PmF n[m r5׿[]nbל,voEѼKkԞa_& trp3D Zɼۚ%E xlo` W=K0j ~ Ek ڴ#9C6T4b) +:O㲦o*66s+;+;; <[D2 {(`DŽ?\2>KjfBWOF~><=<93|tʵ搾@dt+6'T}KT[U%gt /RR9U(KAkf8EwR~OtAPyS1#o gVWYF͵uVQMgVӻR ~Ý\_z#;Y$b'?woS/FEW6` [mT@w; Y?jrk?wMw@kIo9{E[aj ]]100644 jsonenc_test.go86(5 C.ل04V*ęGx{i4Rj^r~Jf^~Vq~DF,ѓ/h*r iČx{$2{RIjqIf^F|VJ5x!LL*FS]*r s+ xrWr&bv!K/ko*.]YR7%!9fRI;\b7N{M7NI]PSXT묯tzq3Ѕr6L?ajZҋ=htrkR t֯ol$|8x6ㄇ&\%xt'~󌆒ӬbTt4Mn'daQ,6{_?}ǻoo(9de2b]Oglڽv2·Zge>9vx\L㦰I+a4C5z;f{Y:xvKA:Mt\u{T޺7R)i\bDx2I>E)zw&aQb N|{@ϝӭA6*6B?L77 ƙv%IW}ݾV]vMM9`Ůi &()%j̪I12Jk6AˆL(A$1%d8%w*-dG&'$%e6Nk(/+5mً(/zI *R~xnnl% O$m~۲a6=˲1FNZ(g,$@7_b j9eX_Fn_$`Uc]/}-.&"NG1G6 vU\tT^sˊr} k}9BY@AG3qL>7evWRB~>fq|EіkX9p Żk4q*2銵\E!wQ'ap{3 jXdv=f|Ǒ3h!NWNZ6\#{CVCB857Age,TYy*)~Gx"?JzlmMPm(È` q2Ov]C"Ná00KYV $b?WLqJ_߁b1OElY?9BhQWAGlsCn>@6a}ܹ5mnYw2ʲxaKOc)}Qy>@%WP ]U]pxz^Ow-׮tcC@_䇴?h\x9My% ӱ4? >E1ZySsjihFX>׹w-=e8!G0,~!\t8`1Vp9zDA|*,vt B"7zؚ+uw`%`~d/k@\wIQkq*fejb ¢X]=dڱoL":W~>YǷɎJ~G ΦU\}M__wh79 \ROP87&߹Ώv`ΡvD?"B4QEOʜ1{cs{z}xv!_;K2RYk7A$x^CBaY%(5V\bgpp#v7.B#D9t{fQiY)Gt#x'p[&'ŞˈGcUsq=Y]l\6=+?b4607M`H_ Bxt,و}u5d{âʌRV+U; {\|cHn[dw_,zPe$I!ra%K*D,/c8Lsn2]iD ocC(ڮ[|!h|hkMQ11\ G[6A]ߘg3D b+z &f 5UFjNEg0H~?3&=O H]DrCZޮ1 S?u;!)I۠OhtXY| oD0hցߪGf98E2ps($cjy;>zNb%AYQPK^ub{jed.#ϥ٠a֓#`߹161nXr5V6r;Y&z9-6?|T8OAAA;n'e>ʧ92 }6HCR6ë\yrqn2D jѓ'w\/(Vqqg8{w[2?e9Jo[|nNZ#]5#J"ʬkg6*Hu}EM`fޡ~EK{ӵ;ݴQ۳\D&Ȩa6VnU,C КS5VnH 8:hIQO+WQij(QJgTm~ӆjpzL7Z7E\2ܰXg[X7kDN>4}.KvQW^紡7z0p|oV[l:(2l|X&:AY`6k|.̦^$yIp iZ-a] {0 Gnݗ'JU\ j0&|pDZ(sS &?&uD듑+ *T /ZCC'-w ƕYBw[DyaΪ,)603'|ZǡK vvc6uӨWW=P4z褆`wťE +$Mi\$<~&ܻ>/Yy-|]W8J9xO{zTF!q@&*֧A\C5LjNH֚q^$/+qs*ْxOoh]2lߖv}VyOR߶ .+lTxoUeUoJMj^HebtK.); HE P{nL­[_1UiBaAcӧ$?~V'FU= jQR6O)V.=`,+rz|IEK|!(2?ZS,F/Qb"k `Ҧti}=Ztq&}YGhU6ܥΝPtSm.౞%;JߦD| !c |DJ{JkXU' df[J.1"7qPS#*?:+ɛ[|'AV}cn%e1wDؐḐ*e,*GA \{fXRDlx\Q `yg+lI TG:"-  twQ#aM+h&C T8pl~~r~ܸ嵐[1-'pt6O}rj qN`TIHE*pX<<_er+P.d_2@N,Qrta,i%aS9G،DwM fѨ"IUZ-؜F@n#aTDa3̈́|x Wg&2=9w2ʋ4*Gh5R.#b7a\P oy|$~PͥIp%8}i)6R? /; 'Jڕ4:NϬ2!ֻ#(xe3k==cOD*HJʬMjν(}YA{ݠ*듽;B{s&V*:` .TҚkv'h;Jh/ VIՋ& o9-Hsta@@<6=n/pR) r{l5[廼{wv h[*a0ce̊-7Ժ[Xof[JBl S ӃmZ_u}an۝cIڀl Žȿq̄ N."؆fd;J4԰ {p4d@' `R++Py@TMӌ:VJ#b]=y0@98gt;[ipK MHϽMk#Ϙ~yco_"NQ@ĩqoh-zr#*JKw5Զ(UgxR ."Jx"ƅL`pF`KNZy)gR1f;FvSLQMq˞[h,*(Q8ay4&sEU u4F1!֛Pճ$ת9wsB?3$ 3tJRQ3Wsrtgሡy;D fɎCSB:ZA90r@Z0Ch*@ q8i*&- >QiM7a6 oE"'T ZR;R{IVj`G6 ~8NN*?xhͮ/-6i]dɌ9.ýG^͏ּ6ĽxыBZ(%=`~fF/%#/ܜY=Ke%- E LprDk3,#j=k,&a\M!~Qw5l GQNV@;(`a R=f0DEuـ'R<. 2 j/ < {!P!EsSTZNx E<_(|k`XWض]q<^KW6K.Q46w[ 5 B|" TI@D|[OҹYǿ j6,*'I}&wOo_}n/yD1_o(SL85?-0LQ0(91cDyגOu+ܮ:Ar>@?T!7ڇ]gYPE6x&N9=Ԫhd@Ϸ }WP[J"ë'PS_P) 8ͼX >CCkC+y2KIR+Hr"N̕1FE "!a͙`gE)رr2lm~}(a:;^ь52*-S ͹_J. ^$GyN*wo:#RL(f aQh:\Gym"Zm ֗QXf#|>꦳dvnje*~v|L`ġuXƫie(:hF2(>&yF9,#JH*XC?do&PdU.&(iUlٺA1X xjl2`򢜕=U( +y67 m=e^;pUh@x1h7 ZY6X2a!3}\zl@}*^u\B/O8H49ª`U c {|Ӟ, >ৼ YCx+ٻӊꏋ͏r_96g x2 \ѣjn0,eכq2J]M`&R14 ў5cG AH%8*T3o?O(0:U3ۂ[Wn4+QΩ1RIg"MϠBMGE}Né(M`(^(ϕ+{ o?[ ~cUǾ BYmUp Kq@*!D,^ܝxC>[}uҾ8o=ǡj $ރժ;@WΙ 24Crde@sA8Mr9+j}dT&[?T[Ζy鄾V,ő,-j}d)eEV& l9>ntl0(~\G JDrAC7Ng$8@#RuA cF| d1.gP$Jܲ#^HUy}y k £H]c4TѼn~Uc. !'dr %Vg6fj¨BeiX' զKsg "a@Vy!yo*Tw/uݙqQW.%v'~/>zB0+`MZȐ{v_\}DwD|oPve03,r^5.fVbyU}xEG zX9;GްVVA.hyZ^M/ugie' @}Ba$d quݢEZi8o}m:@jf& y-zptkYZzbi\E!ϕ4 l,iRw:b'b%ZMV1*5Fk*Na$R. ?OE0o ~~̼Vi]f G, "$r=&a0+Q#ߋ#8PgUUYI#m`B&Ru(_*%=Bx;|Y&l"Lr,<zũ%7HN'j,^[^sdy~Y=@=: Je)Jk Ρ^'SmO3fP՞ڶ`|I0lA Y@gjjvJKGy<\mzDv7!2J7FdŞEFKƚ&&+1jn>܊!2 “3{I9flttx!LLKFsgdIzO޳_ /xĸqB{rL|g ȯx31̼|[>u_]zIR .xx6Xi2B>n x340031QH*cʐ-ϽIp}Β5yizU ח=UQ477<5ļ̴a{ܧ(d|Guzn)L.qz6i-t)aڠU_Xu#wy[-&\\nWF x\sں_=3RBBBS>NiP|Xr~Wm!c@2]V?W}j!g .7ƻ92Ou1A164 ?su]"Qj֟NQ{$}Gƹ*⦅ H遨áu!Ek)Rt3dr'Mg?mR8cs+l(j!9@t(=lNAptEC6t^8`6iÛyC#omw9e.K4Fc:& ,6KK2]CD7_=LJݏ,#K]? }f pEIZ2!sdr g8^ =j״BwF->mEA@@Ai`b̦*%sLM'E>:h[Q\ ڶYaRFg"kRoZ<Y>=}jUyKݕp㔹OJ{INKbV1NM,˽qlM 1-K0-tJ,Ť/+#[N1A%c,&Xg Mkm&=lG)!ava.9,0ZQcDW3 hj :nF=EWd#* !P^f,NN@($Czecgۉyg|eFNJd\r&#g2̒.UcG͑/ⳬC j zVuDf:FYi]nݑ勚ĥa^f)ShQg Yq8fqBdVbs,˯L (FGr-,Y5L(mEK>D<*N.>t̤)Aveǚa 뙨Ľ'@XAF$t%*u nUѐIf8,ܖ׏a6;p:Y[kjpK%"e``u#Չ4,0&!q\AS pv.vTe*c i# ҟ|I%O(>Sلo@AXSς]F~iӚðЪtQ7-)NČ\ N#[wX{`I\%b&R7:Y&J}FG>Gfv }ͤr'xtSMP7F<'B@PR*~=C8B̲`?!,f \"l.vr&kJ).ۈ4 a&-ӏl]zJHL,=G:)\̷mZXK8YĨ8g *dx/:TG,vb>lB@`|}0Rw'2Yt?MwGݧˋ;<k^֐;筷g+O7J>Ye/iI ~d c'MjW~,F !GZiMǨX?jFҥF֮A050!t^mX|">px u{BhK@,7ވEۯE+Yw !rFc_~C/H߫$4s99 *fR`FUdeF}s}7@Pig-[M[pmCY\7r$ZqisOn>[VgM֫`, Ob=*j%$^XAA o)Tloܪ˭.MYK`؝f-/6Ox!f 9޻(t04 SiQiOy (!NY`0n^O싙q}xxxps~ֺ=::nֻˑ>UCFq4?;r -@Bti.x&ষE5b=nYjnW; @n'ju&.SlG]'JzѬߴ[G͇xߪ]KL.+/sI꽨ϼĀ5Jpu}DCk k8;k+f˟ f8>,0xnhG7Z8%iƋJۮBKb<%)8D"d(wiuԺތǸsr>MᏳ/7z5ir>Yٳ%8gA7%F>g{v8=k/'Ƴf^&l+TV]xJzKҿ_??_p\x;LL4k'L`v#؁2FsgdIzO޳_ DFsxZnG}3cʑK$Qڢ-ƒ 1^n4ʼnӓR|~ɞSCiR`6HL_TLܨ_Ciru5e6/Uku%mZ2O6 El75ư,3fwV<.U/:{嶴}QMtZMn")Mf·*O 5j(SE˪XWC#rrhTFJ'9>]L煉ڪ{ikE':*Ӯ?4^ T(L^S8E?=Ұm5GUcO0 ?4 )L2hrɪ[zaYAN)6Z!VLT7}j̦A+szMݬd&o@{:4N>H믞aI ' !!q0={@qbe訓$]c0ĥ.l":@ovr5}%ZB=(؎Ԗ/gG{xz]az>V V? ͠*t}µss-M 8#?(ُ OY^TWD5TZyk~eVQ8˜V$|Q^QW6W7c*lS!y EPϮjN?{LqxҠ`a4jǥ &rQBܦs6I:-1owbƌH`2/*NB3!GYjb~S;u\t'Sâs[aoÊӗ/w;O,͎=NܜE)Zbu7X".uG؀j ."kzy}s.Nt@uk4 ?;yAVZ <2ݣDsn:g73!cMe5ۗ'C%E,mA \R }iAk32|Y'( @1"֚D.Z\bwhv GW<wGCqZmK{3y2ޅq2UJgQ"a6q}ZIk_ڽ7m(䥡ӹDq$rLp(z7ܦ?+y;!68Mo[=,qgsW~sspE;nӁлJ&? (M)xv4ysTt_-G, 0tB-kuŻ8V4Žý.q/s/?Z11%1iKڮgfsFDss|z#c7=v7o`aܔm8~se$c_X0Bg+\͈b#sgBڈnz|ZA_4VvyREd<w|.T;SS89>s8HT{FZѤsA7#77Y+[ݺVmn#XœV؉z 7TkIO=.h M8$< N”~VH>ʳ״VF-0uP=ܣZ)>@Өϊ)aS32]%o<󂷤8MNl,-n~ːpܙ *e&!P}چ@}Sc ##2㹂yq\ iy3Fc4zsgᖊ,b+/mUYe@1N>~ҿQr׎P [mvsx5X<I^x>2DFz'5&+x85 Zĥy,pc3"Ct% fHm<d-5.a'LqF&4.xO|mg(:H}SWGԉ|qk pZpP'/A&$Ppe[Iŝ#kr= 3þ  +͎bYڙ3EohN27BM$N]F߀U$ ^w{Icy%BKܡX8qpaN=Js *;+ 1B$uPrP R*$m(7hq|\qЫm:7Xhw*0 #?ڊ|N.dCZXU#yaqZn{(3x3ˈAdx`ae~- tUɳU(bVHI28Pl3"EӪ]޵ϭyZ `w_-:@Gl!]'>lޤ5!iM_G$auEp!ݽj†f&#wJ!Q ?HT”N'=qhZcPM .r87\xm+D$J(DXаS͇Y &$oԴ3!\:c*wZp)m|[(| 0\ 5G y9TGa&NУ8I)<-Qfu7`]iϱ* ˸4>w.f"ʝJZ{U;< "NvD8qՇDf$"ZDŽG>C zm9b8D<Ch r 0\A M?_G՜߁B E*oޠa=0I}uGqF\!ͣ-6]i${95Kk=[ pY6߷3<24a#1-3)IxQݗo:?qKzmQə%tB;k 6WC.͆p4 8"_ ňW`9ط3s`w.#Lx]]f%EGȈgrjzMgx >,MxvٱEƐnaR ^VEEZ]T^rOU{TB<Mso2Z_K׋>{:=p D4n6.G×ԡ>r^*Tt V!G]|`x8YkKstringsG'TestTheDocumentDeclaresTheRefusal: every op publishes a `default` response in // the vocabulary its address speaks, so a generated client types its errors — // and the refusal on the wire carries every member that schema requires. func TestTheDocumentDeclaresTheRefusal(t *testing.T) { type in struct { Name string `json:"name"` } type out struct { OK bool `json:"ok"` } N ok := func(context.Context, *in) (*out, error) { return &out{OK: true}, nil }0"&declared*"zip.Post(app, "/v1/things", ok)%&8token", ok) raw, err := json.Marshal(app.OpenAPISpec()+&var doc struct { Paths map[string]map[string]struct { Responses map[string]struct { Content map[string]struct { Schema struct { Ref string `json:"$ref"` } `json:"schema"` } `json:"content"` } `json:"responses"` } `json:"paths"` Components struct { Schemas map[string]struct { Required []string `json:"required"` } `json:"schemas"` } `json:"components"` }!doc);0 L for _, c := range []struct{ path, media, schema string }{ {"/v1/things",A, "problem-details"}, {"/v1/oauth/token", "application/json", "oauth-error"}, } { ref := doc.Paths[c.path]["post"].Responses["default"].Content[c.media].Schema.Ref if ref != "#/components/schemas/"+c.schema { t.Errorf("%s: default %s schema is ?%q, want %s", c.path, c.media, ref, c.schema) continue } O"POST", c.path, strings.NewReader("{")) if err != nil { t.Fatal(err) } P& if err != nil { t.Fatal(err) } `got != c.media { t.Errorf("%s: Content-Type %q, the document says %s", c.path, got, c.media) } b, _ := io.ReadAll(res.Body)  if err := json.Unmarshal(b, &body); err != nil { t.Fatalf("%s: %s", c.path, b) } for _, member := range doc.Components.Schemas[c.schema].Required { if _, ok := body[member]; !ok { t.Errorf("%s: the refusal has no %q, which the document req'uires: %s", c.path, member, b) } }.(ӢOxwLL PbNrh\nu*FS]*r L䯳\oQ 4k'L`v#؁2FsgdIzO޳_ -@xXnF-=ŭcX`yac7'maȑ8[dfFR@OO!%JQMř;sϰRjSy|kUi=ENϔ=~y_sǏϽ.gi/V&{~;$NpT| oυ*4ՙ)Rm,)VyvWWHsmi)+)ilJ\zM+: v/<ѳހC/RU_M&i$#Hw9,gʋQa$Q^~\)$e5t)vhR]x2muITpgwT ;*Iߜ5E+Cznzru+Kr9RROԒ+N٘[N՚QTvBu!]qgf4?ñEqrȧ}hĘhͻ {+e5~;3,?W)d@y[") (Q\?73O P_B|8EKL7"uukeyzV< gBL䕝k#\>EO_9dɔVݎ:^c #۹vtvNܕa$:tHq@ar9ʫ|~zd8$;_t0΁\iGzY2/NtYvޮPq,,ST$/de"*W`a(s[͜ol@5 ~e6+ hp %tmkJ2*.z-~(o#Q&U`#Fmopk@홬 ]Kd묁W':>]ATɦxIz!Ր#zWAީ}&~?N{!o{)^p:{!T 7ecdxAUwcmWIrP.pd `|*v[Td]\I8#?:3O/S\/9 3vv^F2LJdnz|l3!1ﻫ WQ ʒ_0vQYyUeP98pWCh5';p$)Y 9#Jii x8x`WEV xrgr9cU16uto(f\ka!P2T+&[fJOz<jY@deVyvk _-;108<[|$76-M!UK Uar\t;FD_clkDw7/c 8W0XBEPZ)"huꛑPMӺP~9jʹ} e'AS\}@05$!am˭X62R Zh,?ʲfU(=k4mZ\xbw!e@}.=`ZtL{ +S%UfFdR"tg7fKNk}#syۗ3|x7yaTj 㚍yݶ9'S` ,Ǡddߥ&<z>.קXPYZȓ | ovjRzB (fʒ徾("7ʽ[sYU#wŦD0_#C7u6vq6FGת'0~t*<Ńy,/Ba7d*YBBeLy JQ̌);Qdnu_-SGd!%{#.|}bhkR+۟H۶Yu)$AI6Zٖ~Yģj?%wxu_qBb~^Br~nA~qfIf~BAbIBZ~BZQ~^If^r,V %heVh9h(M6]Z3*0ׁlv$/XC^ޏsνR\ѣ.'^9袴nLh+(?Xx_6sǏϢz<򼬬^3xaLNg<~(Uu2jaTzyH;zww=3M:ښ$0u{](U%q+U9nkif+UJ#+Ino{̝%>c?\2}Ț|oLnTͩ;atw '`%8*a+]¨5֮tfIq6Lv=};䲤,OSq\uO3U9upTU𒸬ɝZ}I{II EZⱩx\%3z0g̋K2:'cpf]90evq؅xywl9yPaw.CH@FO9dua+c_258=c׈0BMxi|Wy#x])_W&n~fM^wl>?oF$ q Si.+4 iԃ4uFn!K 5z OA0DrZ."bap=U fO@۝,Ԑ{ W.o#ʇZ>*{{}? vИ~-6]p&*™בֿGFJsx ã)DӧH]slXը&cPD$~uTe*"y)Bgb/ bS_ˢt呔}pʾY cy9T˕5=3[~z: /BcTBUhuHүp;ܤO4=At=ԳO, V@fOʥ5UC$yeF8Q7Q܈z_BV1@28%u]ѿnO.jh*-W([qa0sSyλʌJ!nҕ5̌fT /s #P*L`*{v{aL We m*!VSvUĬ(8Ȁ!Ms#ڮ+?YO17xwv/v/݀e>G'?Aҩ(`XV<<+Wӻ7on>܍a!gzFME8o;?K:gІ 'Z̟GtTsN0T dXwE;L9 t ؚ̜G9>8r |ph7.0]ױ"?\4Xx[`;7Vm؛+`Ex.+xs=9ք6Eh{" ;4N E" 'O6e\_j^lڦ2ƅZGG1l|b9$~J3N$% X))hrqn.baˁLqB@5h"@1 & |3.RxtLL 3` u%}0Y7O\\ Ammﻓ`2 ;,%^Kk¶UpBv\0@4@@"84Jsx4Q훈>U-F&ŷ? j xh100644 emit.goWV۩#૴n976100644 extract.go NL*y\5l$${^100644 extract_test.gog?7)* K ]40000 testdata r_{Pzmć(G>B78m\x[X*sRVZZ.)nx;9ӆڔiLJ4)x;LLn׹81u+ !Vmh <,ɵ>)& cfm x\rƒ-=[I'Jq[vW|֪T7 1_UCllg#g?Nw9=~- E-2[O/ec^>yb^m-/[3z96O}lbAlCc5mcfwoemr@V,MkUV*YZgVfiݝ2O~o"Ūŏ.r;_?z^+i.qF{2ۉi,57Y{Y[4Yak[ߚ.'YY6?|{&-q­o_,s:aN@/MTqh]%_{աqo /Q$mLbʾmmӣ &EJa,sޔFVt9^t lt71"i VwkV> yY)?5I(s4ӦCR3+bi_@,[sK%^ tXH̼I<.2j $[o.%v\pg2 rtMy6|XIV˕֓+[:90#1+KNLrU^NЛQ 6Io2ؚw{oOM஬HE$D@ 3WY| e]e5J|f-~m@jjee>:1nXK^:ޔ,^rs:7OgE ;R/,ʹ$ sHs 5Z"674$OڕlYZ螻3vmU5Ʉ_NN׈pqfvĖNBnM.m(- 8魪|bGbJl)dpxRx"::IlY$-+yKlnCvL Z% G_̀'fsp0[=JcpU]_Z*ȓ 3@ZY%Q'N<٥QsE%iJQeBVnS{KFuiFYMQ(ghvw[7lr\&;9ЃՌK~1_P)ToS"iR#4.0y$b1DV%{^a^z汅&z93Fq5Y7~M'BtMwwkopI@rU9¢/3)͞D֋dn۞u;3n6oEow6i Ý3P:יW8ޛnb!ՃUY \KeU_')v -;tIN[T^uBA޶O 1λ3FF2Ց@%ZH:UĚDApy#7PK HPfn{C& |@%Bk 3V>uYKe;}SmGpe9)שM=rC~"5MP\`ƚCek.fDPez1T6[/NQN6,ՙ `9W1J("&y Q;fox|*csDL_^kh#@!3\abB@MēmYQ &Qt6FA:pOTv+f2}ȷE%# KvorbI`7IN*Ϡ4&"+!ꮹef]kj^tf6;\m!UhP iYhht+rNĂoYFE+^{_:Sr)Rm+ .=tyUmFr FN(PϥXt4#)̩&16QTb%ڲ=W<(W",К)*7…S@0G˫6v|,ڽz6|.:, *wk nK8zqpyqBqh8џ]|ăJXB`D'<&$F~|U4%2m-WpnYWll|%ה=bCQH|+'^ jw=sIý_q+kߧM`BDlI<_,cjb^~2j?. #ujݎXqqGS;זD} ܹ$JiGxWKV@ФhUL?Xd\`.174wuBs4QGLJ40(m*'MX GlbIru;,:˝D8EYjm!IT;DEǸ_kDo);w/YAnJYŘh J͘%~ݓFy$|NKk8yG6bާ* CAɑ(l[;.~W&I"cݓOq6qF \+J}]MtUxMC٨=^ncϡ,zCQmSJ6bLKzg l<6T.亍߭W,K#Ec2B#pndefX༽xbTeu,#h+'a v<;=- &Z8a75˒ԂJT"#Jmp-1ϫ 9fg= &q.#M <:< ~m ;B,GO>;P8'%,lj#F)YǠa.u*]+zy'I$ױf,kAlCqKIru:PGp-yOpGR{.c ӕ`pm.Ļ ! 5#g߭hM qa)0kR(a_Z&mԕO5Xt s*{+)n(Jn§B3\i=ݤyf{^yn]ԥ&xDGzC:A$Ȧl* C gʱ2|^Ηϐ"FJ\W'>㼇mPd>8>hKj]D.G0K|mbTțm@th5|kl@V'R'ZpEk9wa'5h7 *sr?G÷UϬ}]eU)}c+D9/KdV^O$Lؠv|*w|d#+z0/!KogJ+AV ɆP~}@EMR/L_ײ*8ݧeBAri[9S ]5[&ϿoP=>q4^3)Y%k K]|+e%f=EZz(ǟ[;Nt`glb~GRd,>jul-ĿοujTf)dh&0 Ǭ7!ͭ77Aݭ7wA_7:/&aէ`Z$rX@;>v5dI t?ȇ;kICw5[K|1>cg[پk㍏8PܩZ\Մ.wOfό6x\F~0H| 3^q;qOlw3؁٢M IuG1OO2{,JjۙIlUu֭y/pgeH&ytL6K~쾿8~ͣgyAEyYYmfպɳ˯I4m% ~."4ϝk\4I},#H׮fy^<{K@Vܸ6MttTŋM#uU֘h4NED/4e1Ƌu\5Aeqk?#~|,ڬ,xLSҤi\V46Hۏ%YMZ-f 5n*)\Tj^=;,˼rq$\`hY$3L rri]2iuVSWZ Ņ5P9]n[e['*v ;DVbTM4y.:m#ظ"([nm`%ec*9ł1d]o6Xt%4~&^au@ܡ$Xs5Fdum ]L^?@1PO-P;JuwlWIc]-BhWt7\P\ة gm<[.:)7$iס,T᪬(Meb8wEYWM.)gvJ&qnk+uY}-”0&N.S!nXn./UЁk- &"LR\EV@߭ s?|S;vο&WtnΠyjNT\ֽ;UW$w6SYOӣQX8Z%2^^>ycN?`1AG5 Y7ne QY5 \'+jRdtN&".0/`QJl@]ɂFϳ&MtY,zksLiT̩S5t!@.2?pKHʣ1RCY1OuGhb$+RG ɒ̱:WӰ}6D+$Ik/[ai% B*r12E`͜/.9H㟭Ēb~aaACoD?jTK=:PXT~; 2TG+ajyrKœ__b@ᦥlEiᩐ->㓘b! SQE^dޢPW =CMq Ŗ806M$4oӨÑg _FwL XcƊ20:}KVI[)]zu54c$QucNR˺nh&n ftW_ЃqǰDUcr*q>V*ABheEi:0;tpF[jE'hI|BK^<$oX±pRhIZQd#+iWGc,Ѧ'~G0?VX{b,_"{ !m; ق;Z#GXs_ q>,#s@ 3O݇U9z*p~=592[ uԽL:rP0M"-UJKP@FWqCR*5C^&dcVj/?=Vp!9Gf/O|?K99Ha~Яf4h("O>+MWQ]hňv nQ 80^"暴^E_EToL[P'U0Aǝ;VU:`q pmRm|0,KS`6!!kJrߟ0Z-:QGD~> ,h[1?5 |= zWobDf)vM(_i !gC;Bg'!ۊ %x4 Й:Y/k9$$ܭx'o%/׭r FH"sŻ=V[ ,.B$=KweABv'ٙx9;ݛ6*B~D$@B'kz/)xH4-T!<O@ʢO\puEI&mk2@5@ k'HVܛl,F`B=|9y!@x0 dP&p-b.o(%LjPEܶWA_8-3y`]KYCVgT0UQz-F{K*HINTB Ig 3ǽ?`6'D0'snkavW3Ilgr'i׋ײtcDrfwit/Ai?Qj )kvW{c>n1øU(%LfgG^?> ~& ί+O_?wZ3X&+9#~u0qfóMϺ9 e_C`2t %ff6yIt;K{<#}ֿcBLnprRS^%23E2]eK;,]!z78Q:clǣF8v W[i{4:.fٝVf Xc Wz^48AY;ez8Ñ;K\LERqu,< "rTnz[P=XLsD^ 3aC x*؁-{h;WuiH Ώax속 Z ve]ݏ'0:Õxd-ri,({e[u#[OID'| >Q u, Ԉ\K*4o`Y8" QGl;. "(7LY,tM^b/ å46HO#*#FT@wljr7$dWuÍIaݧ-8acDVp:l0$8\l&qF PAfpdUx@0RmQ*!?MFclc@EIp j|d sc(pu h2V;)SޙB,\~u.YI%@}H‹ h/:Di #1VwI@ K~J6J JqV2-BXP0z4WWAn'MzgX#AҎZo2\8Rİؠ$<>4KIbqS $ߠϠNW3£0&cM ZO@OWbqçbP-O7)ERk͞.NkxK lꀉZgU?D~aIPx7@/O]y-) |:yáV |r!zTj>]je z%(TNooxlrpC3^cK1 g w% 4~{:AbVnXSK$azL2%`/Z@Rn}4V K;TSbÐ3݆j_3Q'e[p -K,cZCeSkhݓh;B=}@eZt&"GO;$5 ý@v#l_n ~TqdN"'UX8!ˀ$ȡh;.,pǖRWco1~+Vl錈]ה=Q(tqHٳ{0'~ `;%}'~׷_ihF6ڔS9 YSc/j">`H"BRa1 ZLc})`G]KIn&L:oI39; Pۇ2o &Ld+yL ,IR#j FMR'a)ቐOl4]1＊j0.,+(Q,Kcd}&~4 ܧOs3)yA^GBr˗̟DU sT O&jLU@^C/0vQ<{ ȐbQ!Z}) ;i3te؅I'ksژAR;< AR=ܯ^{&4 o\4C"'88Q:T>e^Qfܖz=BBh| Ox!= d>_zA>zG!%qa*>ahlؔ?} B |Q[nq/O`$52u/-v0}bƭq Se5I8@%K'?<b%̔\zɚdurue}7xX/^PeKؤ Hz>pKy %D7(YG\@E:+Ny o#: NNBp-@)_@.y r{U%W.z; 05AҹtP8x[φVZzVZmNM>-G&R2L_s5&ׂ@A>}er䬿/ y9 !$ibb *@Hl2.0db*i[f2r΄!,?XG_]!tQմ% )VCb ku?.'V#YmvY#n;LC,𖪌k>8x@tBvUfԶ@PmyŇ؟ 0CNrS_Fb_UHp؆ @Mx;sgƔTB&h<0c꛵UEnf|xbbMW6=.8nѕfb xh100644 emit.goWV۩#૴n976100644 extract.go]JYpQ%Ze100644 extract_test.goMlB Wl^ZV¾Z40000 testdataDAӊyASyJ5-pq>=exuVMle96TKv(z"h)SKr쀎˖+Qc4*SCrfg( E (&?^{ @ @PH9(Z?6\^ IiK ?|8ٿ3loOO} x9e +("łi+0{, Ct9o *-Mi_fjRlz;C{)lMBjä% ú+ ;7ERD /:O5ܒdm Sr8& 5M8^h4EABaqMShHPciq4UL=؄\ [.;"x*N粢,=?9_?۷f]Yܲo$l05Ҷrnw@񋠕+-8GP'κ7TjT s|DBGĘx>F z0⃠zօh1%HR'g~jɼk"2_~þѐG|J\}3Z좭)wQhLfab, {d)jM ivI:RB7)ڐ۲`vqtAؓ3}#6}krC8<%Snک{.`;de E!sz׷76׾rq=f Ex#z[(iwnؕVZ4U[u]v1yc>҆V2a}Lњֱ}6arɕc.Ƭm 5,ItL6 E|AIV$yx9G:`zxK=f.ێ π)i׵T$$o,nxܿ_hTz'z9}(Də`(\A0gхb] ,~<] WM0KܕA \Od9ݧ# a2f^(#nO La\& tH@>y  ߿Vs{cz@"&\Z4e j_kjg؝ј+#8{Ow+r4xr>**tq}[?/OdWK(Oܵ.}":Oren,V쿮yܗBBٟW._\ǮNOo|܉ӅGhTF[;ƻi\ԬM6LҨ?}Px// Key is the address half of the documentation key. The whole key also carries // the declaring package, which Render adds —o see [zip.DocKey] — because this map // is one map for a process and an address is unique only within one appCv]BgOx\?fC  fkx[8 T|x@LL){ojPigºydW? !yk3FςȎ"xVKr6]G@*S~JeT0 $1 RW9DNG[7.?vX Dcb;N>~{(MX4($$BJ1fIILTA8LzctX+kAZ[qPAqB1WMf"BE qU"~cWdƉрkD[1]#&ɓЉWM=]~SX2tD? JDK_)Aܜ~#P2g0O+у*Or=htaoNYBDDv !=@/qΕ"D +_2[PS&G{ā C$?ofN,ɽaJ Ra2e'L#X`]'䜦ЁssBLG9q5V+zV@="㩿L{X!& Jy+u&Ę&|nmb,V;ؔ2QmWqK+DBlcʀzadO~]%c4gB~͓줬/0f{pڔX d(-(dF#KTo1Lq<*s8TU6^[Ig}~*gHEe\(a#OV@zIͩ#>w 9Tֻ3`@*$9rSݛ]Sߔl$;ۘlnDɑ̔k.a:VkjAJeiv#b,;zTVSk쥇\*25tc+:N?֒ G#X8;!hl8HB PT9zBEtqlW֏<`<3u<뾷t{ Q@allF٩mʥF^[~@ML } ܛ5 td}SI!14)"BM/c+wuKm]h-yV/* Sx,yy=X @y{?/4ZlWx"Ed&F-..1r"x;9Xӆ#y: J'M~#1MVξ&NOs|.MKqv;Z.y&xki$3=Bko -u nx͝}su&?E) JeSaRI :(Vؘic 3aEU~T>a>um*{^roEyV>\Ų<|1o?lY_lT'3җ?WҏrcWTWxY9}ǦA͇?.ny9OE1iyUUj1r39բzR,ˋ)YlXT\5gjUTE1Ly5~WzE̫Qq/c+Pax#M=ŷ\Wˊe]漜6I=)GaRV3/Z[9./xG3gM5|WqXrv8]F}q˹UL̄yxyzRU5g-)N Lۓf⪜*M7GDeR 7u{xnŃz^.u=v^iDDRiG*FtZ̧*/nbM!s/4'\38X>*fuIͨ^T`\!XU.7fAU ?LfǢkbpGiH_/Gˢ NgC(۳ͫ?}x;(wr0/[iiOw7nRM1ZjQR 8Yj *S^]7qrU #IgRz /GͨDθgě$ {2>B^7, Clt,o, IdG~|eUkW"_CGkY{p y|t$yZMYht"̨MT0b2uzqib;9^?g,H`fb\VSJUVlYW'IsձPLob8YL'R5E! 6/1^_ !-aU1dzvmVM|8V%&s}bx5@|)CxKRϊWcjg@bcCVbT\[J ȯ`'7<ɲ.ƓfTcfaR&a߂|pT5VV$͎l|zZt~8,OB+K<$Ƀ_M-DL. OeV84/:XMOJ2450YGZG f,B ~8 cJ ެ8~{rDұtxV$:~L&d!4YD<˥ЋGa0n-$zR 61]{SD(ZV y:$%MRh Q%ݘ{$z@x֒#˞jYGl2FFhx @*V OM2li7D?xZ;$UձΠ7\ejto0@.zY;{lwJVo^X<^-e%, v a#SPT]so M IHFI"?f,X9)KEp`-Nho]SY>~{{ n{攭I%CpZ!qUe ebȰ"dQ_7,s 2ceLCI~wۯ[;BԌhEe!jAU~)|3ӳ1m[B]%Sy9 . +;8y9tR_V_n&ڎdi潲A!JPT~»W$t䞰0ŏ,9q&wr(O#qV R'{>%;0rw{)=6a,r7J`-6iy[o^dW~--_thwBJ 4Hs;Ҿtu Y:(8̔+5OّQ_DӺTk)\|py{o9WG;G- yhTQm"wIp_~&M)4JY>=؇PүD^W((P.vZ  e4+ )b?]zxqTx!y:kW`ٌN(+qT~2Q~µjt3z e$!j2 f\,I j~AJF?ό d0{P%¶;N?H:+ fE.S ǐ8kW+AgHX99e-z*W$=%fPއș,.AJN΂IqXJ0N`xfIKf2R?MYe"~g6../2ίȇ4tJ=E $@yyI$a)-^Y$tMN\[.)O[;7߱ޒEa/,r uI-Ng3,жi%3IX!Y9 Pp"WDM&fj(ae]Zk..d͡紘2aE9σYQf,ҤidPz>аWh`Xi1fqfiBr6 6(>G: RK͇~z8+wF(D&D(EQɭ9rl5aMIFy;tG_DFT9xT79e^v0S~%{k /r:XCđԥzu|zN)7xW# )'l S oLTë!zL¯VA8f]df ݔ fZGrH` O)y^'dhˡ2LJͯ h|,] ٝnCqThBFS~T;Y(4/ C{}11Z6j.{܆ 4!"ʡo1m&׊R3|6joI/9.@.랳4W͊ 5V Q(x0Rq1F(9LDVF=%BRF? e= }*&&0#*i-{nF!sdG+n)I=)}^HJ>l }ne36Bo `( !9}݆ne\nMM݇ٸva_@wN|sǏ ȓbcVSd(9a(q[@lѳfi tǣ妞5D2(V>/6)t_MFSdo<ؓ*WWM@mehֹ !Ћ,7? e]_<δejV#cZ;m <ʝC7ib.1HZP!Xx {VEt=nȖN0e$/L&,̀8s/v0 `4JxΓMcDE9&ht:쒰˶Fƃ6u ߃]lf ]zoio:-{^8w[ٙ{筂 o:K*/['^‚D@Tg7)$iy2z$I\ҺEa'çf0.RjP:$:-d֚vSEyxǬuc1mxiTn'2n3!ZX:+#@Rk M4ȉjC A2e `Ko })E# k]R4+ ɫDTe댆3< ˈBr0ڇCXA\w eEfc<7s3t%fRi+M3J po.E:-N׎$Z |߰X5ކ,9=FL|ōն*ƻ0O!z+Cg7b{۱ʳ8;,k쾂aӰ1/.ց}N 3SPg| kv47]^:|9)HVAOp7PTmZ4ebh7IbC HAIZI$[P^ݬ3oq.ww4bcҏw[쟾.j<(٧g $=йoI iϸm0Qz )DJ=P>NNF_0X?{>6\2P-CcSFO.\ x}Tl<C_ W)wWA+4/!])QE.fiW 7،hp*\K;s*Tuqj.\ 77{@ӡF[g$ULo!.GyfB6I˘2N&cXZi]Y-mt g=c-vq"Oӽa.d-Gӟ/&fnP(q태>± Nb n܏~H <Ć6YI1 bx7A͓)JtEynh*im6Kyhѭ{o,L#,$MFǰYzV׷qm:f$zɒe)}ܵn7ob8! ^̬VT ̌ Wq1iHA xzE+2gHS!WKNX\k"-S#ȣ|1ڑd .wJnrOn"'ֽOՐrWG^]'Ħe%;mksçZE=x BT ДclB~8k3Swo Y]y3ufk RM`|U]wꕀR,B{c\.ܡ å݅q߹ !+!k $0{U? 5B7_>pw$ҩp= hHIN/ R^H6Y׶\`#fPϊ,vǑL TASz /oGAPw1Ẁg=w^\ՈȤyLd"oO]oϙ쪰P#J,0]bb XFXac5l}-c;㢨 fdlzI:($)@ H9EJ ffWo^DJ~137_EJ^R֠ chz̅ m%q?`p?:v*b@r2C9<3+^? lHItY"<4؛KP]z20{%VmioAsX24;%&/4IO?e] $J}=(_ 쎴J+Jm&UqZ)tB,~Pk0ӷ%IIz#}z <&F^a>o KuV]tɰ \io(o>f8qzZl8i\6yR@ڵ@.Y(*??z"MַAyaP"oŁ!ȉ Jj4ׯa;|ÉacO*۵ڟr|%FB~N+E=I߀H|V=RWX٧V?GcRd}*|%n-MA_̴xɨ+|Hi@bv}闏zwPz52CS卲ֲ@̗J_T5]JmmϦGDԂ\ͩ}P8B9mԁ'O^ < F'g .!+ y-Z\I$[`aXᖕ,H+2*`:?mG_2"]|GF<̌aO_;itRI(G1l}r #;o0q;E3SmK̦fu;SqɜxL'W3,M)ϼxFfY9fd5r߫luL,N"c^fZ[A ܘ+ZCa]C6:nI=[ޗԤ_ p^< P#xSP`-&:am0O-xt{>S"Mg쁑 :W <`jYU|~יC@(O?)Ђ`9_ǵ/ CG(:wBun#Źx_>$@ Fe`;qZNCDFhLL6_\ MҞHWTL\3rNT ףƾ֞"dʎ32JۨͤESVؐ'M/kɕqnғ-6? t,`ѡ7.~'Q D8$α[*B^Z¥\40c.bsȖ$KAXNՋGHV`pFPXyC( ]u>6 MKN fhly;f3ug'$8Q5Jv>6f~ɎfڂVI=FHX,:IºI::|SѼ1;Q.KaҰZD^l~٪$aG2TSy{d|SCzyHLjQbUE!-HVc̚kDoBNr_A*b#)=Vpy u8ulX|R.qI/Bᡵw ɸ!u Y ·b]|rD!m}@;ps 9N}<@F*&<{*C|yw޵,)z@dҫeҗ Z %5- -!Fc¿QY;ArMlgKjy##?NdT#|Hҽ`*T\t,e ⨬|{͏ۆ#+$vvūb݃??1q'a|tp941QLAak>pPXCR!qgbv eʴL K(?x(@އ%M`&2KgN1?-q@x<=$ӻs̬$%)6⦵i\zp_mf(!Y[\ghX =Ls7  ,pWӌ|kDR (dH$bE˄9Ņ[%\Xz_9윢!,e2уYYAy# rtҁjQ& oA<>G~=(뻝ͯ' |!c$NJcPk%|}'vUMw 85RYj@JZ=zdϒpzRY>=f"RRT,A[goN4\*N H!(fM(&AkiTR&1aSiWѣDF^0 AK&O}Yq7p+#gR@,O'/9F*p졚USNA*"(¹bI& I(`!;C\NFYݓPp=Z\ _%)O05P<5m&Z~kYGFH6:=TC[f,!V*t-ΧZlU&#cW&av.,.ڄ+<,.mN!{k ]4y9 #8s}ҙ0 }O|h9f.2n uc+^u]݇&Lv]:2\u+%QF b6sN `!D(Pvf*m8qq ERo;mn>#fs:S{B ,ۍqt+ F9mZpú Z@..=A{;` sXV c84"G>BVI}ԤK{o9,"O!94o1d_;!)e'%{A$&Sأi0}VP<."a&d3ןEi\QHQ}A4Qҩnxb>%pVؠJ[SOO'f"N'UjuTd 4Mk삺KΨ _b$' n>~J̀lpԛlw$C)NkDCYEgJcs>dC \$71#,,e0[<Q7ZZ FC92f ̤)}+  `@gKN +GGV 3X9͡2= IQS PA}ZBD'f"+S>ֱmס[ӑH3:+2 # 2sB}E(Abvz||1Wa_4M|b[nT6e"ק!i@|4pzKmܠQ0{ws q(z8~YXXJzbW'΍4D4B2,&co{4=c@Hã#Z5%W~+pA qBQ(SA0ua˾VlNߺ|r̗rQ}ٝ[Qޣ6Ko)lcP ]W' "Mbr̨H6LO@HvҐ\I8,kByX8$|NP%s > OGD,:s=]jk{PdGɌLeB5Y.U9~n7 6+GĚw8G{7X 5l(~-5{MumJHWbb8|^ 51(";t%= QH_<>|')WJ2*jOj)4nCox=S runtime/debugO "synce| 8RFC 9457 // problem document every refusal is written inLproblem // document;*> // document underz> // the caller2a problem document cannot carry — two // ways to D // doca >// // Package main is the exception: a built binary names its functions // "main.(*Store).Add", while cmd/zipdoc files their prose under the package's // import path. The build info carries that path, so a service whose handlers // live in package main fhinds its own doc comments. Under go test the package // keeps its import path and nothing is substituted|^vreturn packageOf(at.Name(), mainPath()) } // packageOf reads the package out of a runtime function name. program is the // impNort path that "main" stands for. func packageOf(full, program string) string {_{\if pkg := full[:slash+1+dot]; pkg != "main" { return pkg } return program } // mainPathn]is binary's package main. var mainPath = sync.OnceValue(func() string { if bi, ok := debug.ReadBuildInfo(); ok && bi.Path != ")" { return bi.Path } return "main" })_!%*s< ixLLLL'̛KI2?VjP/gS ԸT(L *6B'uvڽn:KDX$100644 json_bench_test.gou4H܇.Em6LeG&{}uD;=j9Sa17)}ˤ}.t)%'OxYے}WLYQDB$^^E&^jr!0$0  FTT<?ї`ɵ),t>}uG=1e(tuԻoΖaleLլ҅Y}]S¨/rlmGljޢh4gF-F[W]5~QpȜeQѮSa^Z IRٙqL48U7|JW.ڔjɳҸrVTKnZ<\Uښ=u6ojsY9WKSBQY=g|?+ۨp<KmďAO[eC<~Oh騀[/mGjg&u%JS_*=WfkKVN5KWWF(^Jt p3/b6N?HKeҹQK]/q |l;4\e- V/ߟ}gK dNxWϥ O+|}5fG;x\`A+ U܎ARY?ulsbMhc ?Ya&)GPO3]Uuu9l5i1I[Tֹa`']eHW[Fd,pGwYؙddqfpwȲLw.3U,q\Ԉwke Zac 0\|?¶Z,ANw$DkSV&&хɑ9թy_{;Rewb:pScP`f Pk JE7s A.s!$v@>!ōdiE!EVfES&{~KT M1Id/{j* dE7J:p;{rPg6'U!W^.򱬠Yft;*0L0/I?aw1xpkb3_p8[#XOUm?[~sAD/S uo9D$zh<}#*U尖1"͛*SߏWч `FY HGm{0úxlRDWy"TqYO] :QHؗ#p 6KEx: R:܉A4_axz/2ZUoP=!j7+\jtӇh l#;Dt H]-X#'6jpH̀bY[pPYP(j-R! G`۽Pnˣf$IO =Z*>,z7ZQ,BtMa%ف5ZQ ׽h|N3Y X9Ŝ|9Svl|פܖs "X<} :}c ep%.+؛] TCYCl(!7"Ch__>$&2XQ~N|Hlՙ/ua#K,׶k9ۏJ\b*N^)PF Kp,4|;7G}_}L{ fp "n.b=Vt$ fgL+Su" ۽CZw+'TtAo=TFs/BݛvTU4?# } f׉L@HM  z(O1uB߃M X6\G6oH>dt~I@%|d 0Z}sG6h4hijUR_uB0 <. ,pմ|)@Y[!c3iDZy5 }WG싋j e3.ZE cYefМhwPs)&I˔tK8FK-m"[!j#+[Ҙ%F;.V9zbT0!x"gSC J)c4KHDhSa) \0G0dmm`24"-~aPq98m/Yaru*)т$*6Eӝ %SMLc|(@i:O0PAcy۰Qs/?nw re/MH/aA )Dcg$\xj Hh2̢PzJHa; SE@PlxHA1HnoqI"pͦ(2AUƹ'R>@nڙ1#J弯)Kz9}=DU<L&;<۷M ;"W JۉtHs\2rvcpAēZeۃ0ܕ8P<ɀAmPC 9*CIcp,kN .':jitpWTCF"WbE``{dqCtʜ`ԉ8A싟涴E #|(ý%щ~?C> By9p·a䳑UW+ows6W9X"])Om 'r8ysa'VFaLɐ S\gcjuk*S VޛK70W6kއ<Է}tz>Th[Na觮m;(y\M ӓ#,TZHG8PI^9B yObtvxeUKoEVDBs D fvb(HkMq{fzwtz)? ĕp@8j~ /g#TWu}m/XRLxTXiJJiǕt^?|&)3eޑ J;9i*$)dXia$t""$LQTP)9LEC<8SYJ<4PyEr.Pm$9*,`dŽ%eMުFJdG_<Ң} $( y0<^9g8 q' fhUܹFJwWIV'-p3\*s/\gI}/)*;X0o{ttuڴ`Ftb % X',oQ#1oY1d_~q2Kh*M,xy-x;,s:.5hC祅Z^d6ZAxu齚MG)+( 1W)oAJS"r[qɡ7g8BNn f>υ|Q6-` D vܧ3-o'd3XWͦNa )L41 ˧O>ͬ uU`ӛ(+0 & Q=0~+̥Ff@{{$ ~d!Qc4h&cJ<₭1.A O>w:҇ZP4'tztt x*ϕiS5Vbp) caS)4 AJ>k{)P!X=NMeqYoeP,fy2:ڿތ* @jk6|ؠbP Z=lflm p̃Go֨-;}z9 `սUh80!CaK`F`mfQF|x^Λҁv W;/kE.ٻƼf1ac^]yv^Und #ȝI F% ךMMYXKm {ݢ *o3Z/~fQ.xꢕ< 7.:~jDaO`_I.FPUƹ McR,&M'm=_[%m7J;WO. TDxX"40000 jsonenc[T^ ծ]ݴтjg1'@|?i .P{f?f9p#(c,|hJؘfғTfo OO\r#OTM ̫Ɖ;sǼh7XFZUC3q2ް E&t5[3IRbt.'$;D7@s^V{f7-yh,x}Ok0էxɆb[r*KH!J!cYk5F#{-d!7 {7Oufˎͯ;~Rj$:|7^+eCD^\;wu~PRu/,``[-ԙNѲG|+$=5΀;` x|}p{~^`ocSLFsԥ&[gP9bݠe#Il䚇ѦԘJ6#v,|3;9v^gBFS94yȘIGX%Mq^| =--6dm}tF\̗evO"C+8ʉSW~xmRJ>JEȱğ*h`M! x}N0E+J$H]"H b1uĐD$ 'i+Ks첬j;B-wwxژ+ٱ5wEf.Vi,纜^ܘ#OnjDomnzal$B1x}q,Ro)RСGHR&aaw>tH^)NV Q>)O[ Aq=g00rdOۃK$H!0*3#r "%xVIl.G“w%x340031QrutuMaoyCH=E ;EB%Ɨ3zrRj㲨> UZTR%Ϳf-nkgO vp\} UyMɜGF5P @ܚҒoz!'ygQU x~hFmS0rCf灔X)4zs#- BߝV WR RxHN9CDF$%y%%p[sS_Qz%l-)<$:sW&>TIQjaifQ*H?k^Y菮5AEyy˔Ո:!z^kSo.(zاq#ڐD}44-J=ƒI)=aOR)v~JWbj˂QڰàPlqf*qf8Z(툵܊5t6"!d[-YW}ͦqW(7u?@DUJyNhB*bcVVjfbO310 OS4:'r0}OOAj' ~Ca6\I7 =pѺ鯮[HO{GC\tHy+Nqb#?GDxXnD;y#l͕H^ﮈ6 $KmN@HHݙL6g5rx#+͕v}xYk cE>PcL`!XdJfЛ0W$џ8,E 4XL\0379/D3|0"9M1DHŗ,#d4qʊky!pQu3-_ S|.IBzL%G7WRv1)E|.ūΏ/NNφֈ"4g$2bZ2՗9ڨg^ &vEBCqK<!uuNJwfwS j9"߰ et]PE] 0hxWe"1(t&l"AN@a乑$Ӕ3OSD&JNeL&cD̴1eRz4BJ̭&`?R}FIu;:[un 5e/eXn"!O1.1tf"۶^B"Oxh5fDe\񯴫BgtXOO /O8R7"R ؄?+*Dlnu܎dy3-RlԂ׈p-jGk⽖[j4jiq<P ΨiP\X>ghX۾J%WE37жP\5Ώ9+lEx Tez]*4g>cǣ >sYXnU& &'~`kh 훵:\Y$<8k瓾oo2[+Jy'|E -t8wTk7YLw?~voG6J15Eʘ3)Ij!"xLHpޱCxU:S<3 a 8&038ᗶArpR  [K{OUE9N߸>]0p݌hE>1k@&ڱ~evԆV ɳMhQEX(y̵hEeCPsĨ&$Wc-*)]S 7UR!b*e~z'XDz [D|o 0P_[nTDEjpZ ޿\eU5csLVDEi 񵫛 }h?3N3L8gϵ%!cG^Dua&&QJjpRkl[]#U`i_"y/ͽǜ%%i~/iRu"K#=^ x ՏfкDm0%Nc 1f65E+ \N(fD=N'L41uꔙu5{?8^[*#~ YQxZsƵv)nߛ<Ό"ѱ:R_:^KX2zt I9wwAP${qٻ,urF}Hn7]EU%E^uM4_ E7u,qV[SMQ'-Me2xIt6PyCŹ'iVk[`@NVqQy{a՛HMLJ!h^ʊ:Pt8 lHs;DʆheFYSHHRi Ó\.knyUAOV `tӋ?5YD 3/xjbZ[D)vHxW^3eMhrcueLb)r/OV]?iUMlbN%B|ZMFGGW@r]nqXRSaʆENY!`'Π$2l%0 cP{CJX- ]*2+}9 *ݎ_P lŶ 8ǾPeZӵ -l# *v%Bh42T% fsD19+ݡܠSc[Y"5K^|ۛ fm|CpeE:/!7P{TEo 6X͊ZW@;~ΑCհXDZaoèH\٥e1gJ: ｶ+5TsCE-hP%ǚ*YHb@ aBb)$  -.magXiZJEg),Tl! 5-7y=A> iLLyg21T|zݙ`v mHusHby\әY-%v;| UkCpJjW5?5#g|mH업.Q nWM0(VimVeM)Y8u`Y ccU~=U͞>_ѸZx﹨{+vQ7r Эz8S}PoG'6(vLrD^FƉ_svNF?^\&F:\}3Qxr1>ZHKVr&]04]jv6s,n.VDZ۰B~ )G v('s· ȡ1$kOtp^C^Ϫ4ѥY NGG4ڼ*bQT@'0kl'7G$T՛ST%7oQ saJKeѿfDùS42T tSќrΘoyN\">Vhd;lM>s1xX)"X.Ol]¹n{R4M tF!tw$B06wMt[X@VվԷÛ 3o%"3v'4f$(;u$3)EKrюi~' R,O}Mb^- %9$-Bs6W/U 㰎OO2@ߩGp{ОG=$mHYSЁ5 $E|843ݶSqǍuf 4:=ed Qd3E5'YbW"BM UOI!pl䰵06L8htA7W2&>vHׅ'i'Lh@x{7DhtFk#b$y =eN3Z`;sV`)0 Jba;հ4xJ`^1s \E |+nw z7=O 6lC'}4:NZ,LBݩFr s Xz$!!LӴ8r0( +$Bd0AMb$eSvI={Hi !AHk{O)98y7P'ed %IıiX l zd* @;޵ 'fԾ,qt-R}rx3> Wc@Z"i cVd)'AȌ)N@ K?^w˝z믝QۻP6u_%^d ]\?*ZN#z`X>| xcOÙkxuHwQO +%]Avyc: 7YHn+^5pƌ,fCTϿq_E!u nJ ~F AL2O}.C QyɻC` _ګd AD>obTXvmov;h?Q#JWNgwSK }uPdN2ߤX髰km/pOp}^_x{ZJ{oJ,tۑcaQTLaHH[jyry@Q)r6ͫ0ʫ*G4|[:L|V,Z.0)&}amͳ׽a^m^Efh1i^,CWTmYW]uӅ2oOwAw覓峷_NBюyh3=Ɏ~IyӻhvtaZ[dލ66䩺=-r ySdgŨ+VX_E6-ȧV,` ݇P4M݄?M-*?^p6k$]¿ OaiKޔya}bEoѭ}δUKg\FnV\f+޽`grܳ_N/^li7\e[d QfhZ/KtympD-aUS:m[Xew,@~iܗM5Xw^A`C GLdK`_yWvkcHWLmE64USuvD bʢLfы~DKj )Ąr<)l;3*qU|&6X^xtKĸ슐4E;gOg>-=;yrZFL`T|CGxb:nqgmͭ+1W2&Ž΋Q97k2,**b#b`7MDƗ>AAV߿.Љqf+NBUN j\LrbE5Eޡg ۟FSVdH@j|.FR_$0.z(q";Nji14K4E pI1PEl"t{I6oƶڸK7,^mAkp]wepO0?8Dgq.!^뮴ZA, -BvFδ&򷢯/#k@"HKW+Vhp e.H+zM|)v(ʵi^N|Q-[;J؞f磦w[Wl9e8x=mu;U% ]>On..ԟM M\. W?i}_|r(쨏K|+Vͨ1GbE^n؍cW暥cafЦ擢{ )7m 63szȻs|Lk\4od^-AJݚ T) F2\:/utn?Y{_wLϛb]_sc|pT'Vn&gW7Pl؝]/¡=22Yg< eܜMOJ Emt|gapyn>\aK\Xp]-𧺹? P7:`sNm=퀌?k[FNK 78jʴeS0͐!p 67q+9фVc_–J. X.NѼ@zbISkŢ-Uk٤+9ߊ >$j oEJsW: a]L[x \drIRpq7|OzfAc1,7%RQQN(v0M9ܫ]as7^;YLHfe;S?^ "R\v˾sGXRd*!xh ~[>˕ϛA0ht-L B$.#ں+ "ܐ*P+Z!f6 kNQa#c/.=YmyH_U涞. v.!9 K$c4*,~kvuuӖc+j0{_*230U5. چLe;$Y1W/K.S5kt i@m$cmF4+P佭gR\ 3[bÒ؆ ;9 GI YH5gaA$3oG{Մ6dobkl(\ڽ`K Տ\ Ez#ms &ivW:Za?V`FrDWݾ…|] /7p =,< #-&؂c^u|‰߆rCޖv8G޻Pl61 +VtqWWCm2>c+|k2&e'hT@.O#JȵXWzOEv,!% N {<Y|o.]Jn>PL=zX“ _rjNwSE gڿ{U{W'=l/cW$U㺖/qb .3j1!J KB*2 R.a=T=˩78$8&CX*E>k"^'%z ]s{ NbF ˅>QwWwt{%ￆy=wس{ q'mH[#֩OL1ThDR($![awRFǐhG0Nappl"Tɞz <ɖ{m5QJzN|^"D/`(5w ?!lUr 'TNS Jw-ޓPQ[Vۼ.,Z'Jn?Sd5KNڷ2 *;@gv$цA_G|}1lzBg:~E˸ U%Th.}iLAT(U=|=~ -&X=&x  _5tP%вUuXz_Z6wkZXC].sYAC0@0p:Jl!jtPd-IǶޞBǂrW6h %"sg'oڑ(|o (IJ/PFIϥ S+HzX,YTX 7cfq AAͪ2\VE m4VPg}Oy&+F'e7n$m=ê}RE]TL+ʖBl=Va6\|V[iR[pA.di)H9hƖZJz6"Gp`ODIܡ5}g1'66S6x}xT|l9S;HH63=nkեNhWo:0il+;1,5_k`z^c2':(݅#F*VZۡ7^EwobřAdѦPhkK,V2*H, L x rOK+Phv鋸x5B\]/nZ^yDy(F<ڍ,(i-5qe'dNߞl+ U )SvJ06<[׊> ߤG?a&V%`uM+Ďhr('HuZz ɷg{GY Tl[ n H7h10ޮYza"j4]P:7RoI 18цM%y:L8Qы"B_Vo`5oUŹ">TGPIPK3[,Cse7yϧ.n/ vs⚪{rf!JTֹq[@%H$+H2lOg<6]YsV=V(Wa(Ī ."AUBP4aek0&o1'W>'&(ʇ WSlcXf֣aP_p5{.d^vuS2ۼtݧ&0X ry'N==[~?BXp˗/TƼAcM .< UM03P`eP *CH2Tn*"Cc2\^EPaxY!%yQT[eT|.]l\jȆ@Ic^ssʹ MkD)6^V NJv>/ŹFL(źeR~x#I?Gchh35S|UmB2 *.-GیF4iL? JT722ljBmR&3=+BK^~G4^|l~~ǢW~w6-קpX*㼫Gڃhi5X:w]Ic-q,֯`kWI8s^2߯/l`L޼ʴ*x36]<$[ qyuh(>+BEB;xQ}Ldq0-\}Oa;U^X֕yQ2h[ŽXM[&ZpV?N iQ %iIӛ%FPҠH>Ҡ"8Τ#,k4d_^لC^@i3]%dD\J*HbK3PI-XVw53-q@q8 ˊDwBgSB`M+<7[.)gl7(A $V(h[E<$LDY/~^fe}͒MtYNQN=XC]?hm']&iʀgdggrD5h ~D7V0:MIڑT`6Z:ZnNZޒtW5cnm5|\;-c\lU^97ٓٲ}鼪DZqҀ)Y¾ui%  6I:E Vg}˃7LŮ C y<H-n UaXxUs`k _ms'AƤ  F e5 Ӹ̲BLߜȳ.:jOdZj,˦!ZB(Z9wX3F'+72EvqLL ;w 'BS|FUvD1bW.΅n>yJg@Cʕlʕck$a [1YC- >.L"ݏ= ]ōi:(+mIM>V20ʛ. QڿΘL7F9֨<-X71"RCVtL` 57L\ J`4b4;x\B6-so\WE" A??l4FBRM1_]/4Eta䈂* ur^&$D2!϶ZP59>ᑑ4 UKbOFSmNǬmגW~\\KJ?nv=wkܾ~}- 輞'JiMoVY`D:y[.?l,RoC`+e<5hձք>K\6(=_;B@c|ēؠsvA1L wLp.B#H#PqAXI*6ɬ,#2m:h/͈8t/'R* eJ$/%9*Adٷh+G0nhjnq9h|[/~XK䣝YɤjЉNtA{&#y^*jT|rvaׅV|m"+yIa#ʨ'n=GLW[LW7xiѼ%ȍ+I"8AJ#{jӂ:D-^J3xGI/K20B%";!>&:^w=59 ES |gYؚױ[%*kGhPS>| vc8%h2^J;8c< 8(R,n^sC3"Q2#C윷DY}(hk9hC Qvؤ~_pLꀼQUhW\[| Q ia7J{e4\MY> r:H"]*,tFe0G4*^,Ej$,(;@5!;Ce~&`Yn Rf铸d ˬ|^?)YRz ܸ߹?nJ[4*E!Ƒ pBS+_O}!1s\ PRt.\0}Ȁ y}tv$=V-ǧaD34Mc4۩O6q#<e&χW,s#!|>:c~3gͲ8}J-(cTdb^wTUP,*lj}XXbpy?OUYJjUō* LEKH>ZgO4˚ny2g,^sJwZ47`hpvjۢ38 K['=FW*%4FG1/z'!vjC`7~Xπ<&jqR[15{bE/owpIV 3ZZm #G:޻eԳM}PتlPp u%Si,rvꂉ3`Ln[I}Ksw_.IL#2MD*9,'9x .:4:t<!䦀K,_:M? wdP3^E69OVQW̦8y3Z4JG&v 3~.'rͯdP}֯%_ .bJWC@coB/HH9E y'wmV2v F`ݧ+y[ՒD lmVC- ? F26i9ߴ]ZoU?:y"Z/Yc3"*lۉlW+˨ܑs/ff2$F3),&TwWRSTҢъv)FcJMN~T"2HZ<F &Y\_^7Q^bKf++qIןU* c=ug\xTT?@,hc6fP@Y%2qe+iG{Q*o 6=@s^Eǘ$1'9p;HM=ߖ&g.^s8uι%c?PWJ`gfd ޵fE˩^ϷG<#KAB'hsQӴO[zf{)|Pסa6FAooqq43GsSZ~gU̞-~{[I]nՃ-5H̅w2RD]2EgS(.MWcR+]a=gz鬱?ާ'F_XC\o-df65r!z/*ԑ3&MJF],7-"hF9nC*KkB6ju͍3v \\hZԭc:^Af 7 8k-7j$Fu~'g@0vSlvB$F|b$9ɮ۱6`nn?9?6, _W1wK7 _XfR%$w x6Vqrjd:S^#уHGk 0x~!-qYGccP+.M&-U ;s9^="l%ALT!oʣޕcSH nzzckt[Hq}WP)3J¨`ʦX!BUhEGG {J2jrz]E Ne>&/'U Vѥo,%FCk}W*|\͓H"R)5 j~sdiDFj<)ë5'76DV.SN 0/l,/.fd'/E $jY|> AP,&D/<{#A'˳皆uj3?f z>`13e˙Cj 7 pYO=1C`Q?P"Qs3Z h[re<,6ۣy`ܜUKmrE pL{,+qFAlPl5dkfԩsr>ܵM7IkOJ`-Us5ڽi66%9C3 Wp߻.ܫ y1+?~N1?xl18;g{;KcmGuKS.\wWWXɭnzW+fu{~ [JO)c=3LD~*v2oFPzv~qSd Zp("qlڦQ$x cTywR4]VF 5Շ@&0 PWjIA4݆CjhQW0[q|Odz80:Ù{t) $1{Da%X/`#JnܞbZu莣5u]T-[ukwu?XLD,6{licLhͽXAvB-I\HΊ_YKqs:T6*k-BvJoY31:0WUF4 3 g~}5[HoF3z3)HB::B 79P,KjX~ǺyqrtTb$5qgfε3Rָ7 4@SM7sI|gCTocU@5cʚ5|?L 6?\h4ـ,[1G^Fmt3b~tX`& 03<HAxKl>ZD}*Ϣ)1mj'QԛtT?ŧVeA2,gzmS y'yGhz3ce1?{a5+6yʑQ[+1w@WOOCƍ s4.So& gL 6Ӈ3wҖ<`|Wd?{ǒ$†C\Me7L$uq cSet&bYkKld aj8΃SV[1ׁH!u56' @1UR=Bb{%$̚ P0ܨYd3i7yl2v+ݙn O8 t:j(]b>=B#jȵ`XPE.KB;~Mw` p.RPVi6WUVvw "hzS*o1Dz iэ9S)b}!m,@h^'>Pe6( ?~z݊>(yaUrM$X掔Z&e:_V}M=9i̠$`lYS9VqPp'Y"P+`C!z؆u)"BqtSwKCSP**€66 OXvSچ: wpIĤjSR›kθ Rf4vW?-RT`:C֌L^[4 YN#,HŏM}tɥN^V3S6RjX'+ eNlb)ň|hG߾vWT~<4x}VE)TBb'dse7{XVDJh+$3m3ݣXd'_H{f7Ae{=U{~^ӿu o:bL{Lpqpwp:4ܛit2>$͕t,SFsֿ̘^(,xf:^!OJ!W&]Z4'{gϿG7&x|qT̔ͳXN09J* R@:`NF0caeb3킈ċxڼ^ @+[x#sW--xULL|['HZ4QpA_ $_NzCx&NV>N lkp3L>ZN,5wS_o^zm"\*Jx340031QMKgsh9;CYܯV\ n-x{8C+ʛohq7 x340031QpN,JOfZ|(˦)w*c$?7QӄFr_J،f}x}y&@Z[Z0{ӺezOgY*@771(!c/˝.}m5oo}B>U"d| Hx31̼|LMLE;x8N+>- p x340031QpN,J+a("uYj#YN.BT&fe2yiɾw\iNtcb y  2^kzpe{ E -!ҁ"Z$]$D$aH2c "bK.6KN??Avx5=JAElDAÂE0P.53%;Cw㚸Pڛ 3bRz}/,==A٩xg,rEEV %As x4]Ul= vCt y@[)CR䆌-Agbz8; T&a]B놧<^F=]0g zmfvtA6>xV- {ڊo@ie>Q//Z?ikiex8qBJx340031QL+*f<%߶+,sVmQR6o9>yu{=UM"b760?{]e/~ TEIeA*XMyђFm4-bM; x[~mω?dRs 2sRRSS2S'3js&(9xZ))*d%甦yJzzyyzYyJH}kM.kd2l̶ӘM j=(1ʪ($UC)XIGA-#?'%H$?(3/]C(RW_Zθy ziy9s"tx;¸jCdZQbUyQfIRIeAjZflښ\ H?[8# UC-/17NA--35'xEv:XL]Qsr;W~yBf^^j!\ y) % ^~\`NyfQBrbQQfD!3Y63N :k5Rd&P)Ǹ*g7P g,9S5X7+멉Px340031QpN,J+ah6?i-qnT@pCC̜b#+ U/hƭRKL @(_DقT܍"Ls?0ㄚPYWXթ;$s~bT k3x340031QH,(+*fpR^]wŮB kM~OK !*RRAJҙlNfu1N_CP%EEE 5}DлϻEmq/P5%%`Wmguq\x黎e܆**)Qڸ,fᣗr<$ eJu|?m馭7[S UfS+ HY3^]kUx['Ol?wjx[]jBpFbQjd9yXluxxLI&i t]= xE*ȡ[H" cp.goj̞qa%(Xx:n4O&=aU0 {@OxB40000 zipdocGѥU8_W'y40000 zipgen ӇeS͆exrי?Wы%ݤ()VH(E@VPVcs03ʧ\@*﹔9=PS[q/[7?w W.o}}֬_ެ ]ZTZ/JjwGgr~nVU=颙=FaUOWi*]Gϧn9~5/T͇H [ufY#dx;_/gw˽Bmj2[ܭφ7m]MVʿwg{:izČgowLfAu:k*|TB|[˦vU=W% t{Ӑ÷n6rMٯf5YMFM>%Lj>3z~]a5‡|\ul!3!K|,!x^._/aKc劙]}?߯ۍ樯 94zAuqX :>c ~u3T r p[ =\fF="7o)̸f0Ӄ@ճCuUYN|,I/T;wɏ;hzJ̷}Db%9+g\) $ ABc1dDp[5Pt~6:hshp?gN2RWW$V跴ƚd~y|i# wi2'nY 0L>4+Kdo> |̐t5ذ^.'Z+4P4/,"ok08G IB$7ɰTgH9uS8p\ӿI/x_ ǫxv~ӼzxZ 4i+p˄fqo_TC3/ e ;*Ni*JS]=q_'8,(%Q.Y4GhȲa=j-'%,xr]ay%߭/ЈP|dva\v@W=ZgWSX- z+(ЫjԌ;DDq5c8Y;M-r^ [d(rv4[(;> " Jjja&)HhP aLe%+YI+j1|5( :A.B3v%K(lka&ZEjNjCkM<=ւ1ׇGpgp%@Q+7cw;1)I%%4|9P\ /"I9w΀ g&tL E uD췋i#l`? VzMyhSp 3RڃJ\9:8x|!Ca6_G1/S754.(UE0YQawn{$eJcƂS[OAcCeoM=61/Xys@HU'QXNJ|hiaU#oiv]$=6E $Vn=JpQC zy}'QW{Rip'+{cR5KiD|}߳UӇ벎?@F H0 +Ozq2p };1l̙̄\Nt(WJ'e[4 AT8@i`Rm׫Ji[G|{gXu/-Љ#rQM7Y٬ .Ji%Z9~_ %]CDH5~$g»u/'Ŭmuu%M#pr; #C[68bk*YA3f+wm{,C, dhfRQF9(A!q0K`,Rh淙%=aBĮbHP9dY&!Ԫ=.4o??ĘlϏbQ6Bp 3c0^/q!;̅%D+KjeTA8 =Fp?+)7ۀ ̚ Hz/QٍH,<_6 q=/ZZx]Z%Jκn`)wLcy`#k !QAV17?LKK( z !w=g\یτy#x#T{cݽ|9 bfA aQf*Z5Z{}+x 3%kCϥQp2 dDȔ#`"hЁ3٬iG@c{}+YdgQrfcKktyLucݼ*ҝvWirq+JH;8ւ G-2c- x_Y5(Zfn2p|g5ֳ U6?F$w6R4QYbmdd[7aI?J},aDR\n4mFtiN]wQmG(^,Ǡ*|[7ZL%kB)eU$3a>*ɞNN皩`Z+ӓWG),btJbn8\\jݘI]&DLL> jZO2Vi4hs22x!\abTQZXE.sX 4I"<]x ^|FSx=bOjw̨^WgUq8_zpS]5K]VT "׿gw!pF9մ;AC2J}o% S.Gj$C !B-dzNRB#SyOT*Ht;6Ut{kCӓ"jMv /COwZm)Aa9|ex&J}J56.WquU#^bXi8e{_)ތ+R~lrLFݝ'# ]=3@x6JˮQg!~nn˵G)|턺 >TS6tB2j͆pј(H"jI 8R_5C]iuYtb BkZp-v(@jkeHB4OVim;JtPT3fO$ma}ȗr6 hegƁck%f F@o&^%U M(yy##UQM࢙5l sjZW3rb)B D92zr`s,J ’- Ut̓%%̩ y x`~{;"&j*J8E"Xm:Z-kk49)ݴ}M(զ4ZP^_$4Audݡd` irk2 h!vgfHQĩf+'0ĚtTiSA>Y02n#VPlKwI͆W_`{`eImC Ĉ홷u2S<~˄K"kPAdB."{e0²8Yt WXCBrtzЏL$AZ4hCNLk`zK6Vkɟtmd֖`f2iG[9mzW PrRLz=x\ [zDcA3q_,qW;ίRSˁԽ+70ۃhс$>TH"ދȲ$Hݳ’6 s]n.6N!WEkb(m+dIRdpL+/јI \o|Szsl&{O^=ЛI/GY _7@l$# d_; ] Z%<1Pvb$<Ą=j?3F XF2^kEL {˿4!-QAR8r9.Xz;F*L:\GǠ5C {nA:.(h _xhM'y֢p_vқ-Qa,b&oJJ"zAS}!% g!/#ГV+RO> 6lb.;w+>܉F .&zJЬ.``:N 䠺RH?~g/OɇQibd$&yBM"`n/a\1bB"Vh=2S!3얽:Ru*粘pL <vD|`>=n`wrjy~qm#f.װ$ '.?ܦ*_;25]18S_A+&EBf!ofK 2QO#B^.bEH1N=Ơ-D~.[,⮻Yl+͌"ʒua8ԷjzB^8î< M <,"NzX =ǥ!ԆI9PĈO2s 5MEˠCFU.w#hiMEyQuX* QE$K=i˱*ꃇaiAH<#b d/$vO*qi@&疟nk.*s(]h^^хO:.r)Y^IiKZt4ا ܼ rƬ+Of)$"tW?[ȗjq@yxxдYL{˒ɡѪMbdf /TcAEpg.@G.%rIU:{f9:,9a% =j\0fFx"U:nS, |_!GwF(fS@3ĴX02`5@0 { D㽾䈌):FO#ہH]#Qr/J4YJՖlĥV:t8ahQRlmc_*f\ 3$=j~Ta떎A;gT&L}٠^s@B;,Ҩs"TMdjҢ#Rp UÀE@Q\\nb?VWfҟ/rTTAQpMPYܛ{Q+/@ū->vCXy5^pu߰'OIVb?Q/nX=nrmaТ%+𑖽[tqj\{ʑ`aG- xը>}Ԅït.0/;0 hۤr|w ^7K*&3lOQblP${deR%5o0\YR5t #ֽ@йK)":}jkTQs^*i:R;"Syм[B% ]*nj#{o.$$,(MG7vjqy%ju򏄼H17Ol( D.Z>#{F S?ys{re|2kT9Lo_<9z -k3xLʂ+jSFL,|RJ ]>vdʈy,R@Vj蝵3ﰶuL˗4z ,zmtg*FQV 9#pྑ]%|;Jh0qݕA1+L}XiOdNwC?:|M^m8j" e_/pmR..)kbEX$6*Ն+F*ވ8pPapRqJ4gP $ܷkvth&YLfyr^LLET"wXD/=eh,eۦWuWR`OQKmC`%nQ(gt~g4\G(L-X(92k:dP"f;|nkbQxelFA6Y9)F)TuV (T6CQ\F4jѷG$?GHVJ^/7oea4:-FoD>X)0*JvB3w9ѕaMYlSZ_]nPBR8>.a UCVecD% N6l^V^E7p®vPȅ=B .؍(OPB<)|nG7pnt z/[#lܐmf E=%wPs8{o%:f޵@eA{eDTS]&C}U%8^@R~hA71~M_6%A*M)fLjej *aLyNPQݦ/T?,܊JB5PiuK ڵAn S^uE<گM[+Qur* d7' zWiR_fѸLHoPu'jmNIHe9NG VQjdګS1;$ꈎ gyUEjsfU,Ert>'A__ԡqa>Nn@|j?rdyǣ)] IB" V-d#Mq9yLhloGvG)y0bZA ֳ] ™BU)Qyk40%+ %=vU$ IJ[:X]YwP 'F&TgH@ Q mEKu֪<1C R r 9P 8FiL`60*ۡv6pO@ݪvؔK-;f?zw"X`)~1&VE7_VIMܡaT{q6BSt:N6xN5SMR֒݇E;q:QY?}ٴOlJgB"*aBn43ɢ%Fo]G]kM 17!0%R< T2Q4brb]B52&r$N]5N#U554j ,1Ӟ9-9o)A6i}Hs[O#Nd5ǯNΏnB)5 Bq T7ۈ$>D^ (n-DMf> _aDKMe%HMCI MZȡV˓"zqb(Ia($ꬉܪ[)Nm۔o 1פj8wPMVGWHJTz>RJ %aʹ~c]@q\}pKaI)ۉg@3/ P_۔"unjP%#s2r28@WNn)yXv.db&yф0?CYϷfGzꉵJ)zr P-m  qr;p;=;JU˾ O#gpWp>j,:lA9g| V<TrhP*i n)JЋ1kszDŅoR-cnD;EQ>#E5`=Y?DW)ܺ"8zMI"/[^3q9m2RQQs \j.w>!KEK䦰iU) SPؒAy9C#Mz ]'u&AK3"0ZQ;4/6 gH,C4 aݪ]س ̉i2abf0"J|V}bf҃<Ba6GDtOh&$@UI!_U^m}0b:x8x;zɎ~RnJm'hˑjy->ӑUQݯZ$]h-.@ϫmsy)l+SnhҷpMS;P6aUJŋFk-E(?mo?w%< ˡɞ2DÕ?DMN2! {,`m:C +iS"=頨HEw]V^A0+8~;>|s44 L ` $.8&_ޔͮR&sO0ſZ>/P=ӭ]_QR`=Z$UpK0c&6)IL#ʧP*,kONQFY["(v5a`W2$#Ou5E'Fz R_yNv}KHz laPI9Y񫞥=$&b C]hp O]'s’+sh69vx|pO)2o~}}*"@1N:#fdR\ |Bы5Mԏh̄r(+(.L6xxIQ{=8+NDpe-1ZnwG[ޓ}V&;\Ӥ6gN.= ,(x PL6 i0yYNuU$ʅn8#OC<ѻ=W}ALp`F߯߾A>`Pv0(6LugaMKYCViupd3U9*R"a%վbËlwdOzlƇ%8la^*`( u M]H`GG4l3Q& yg*xApv-^(B2Ѿ݅0 _9nv%{@_8"z3 [ %ҫAߵP`N |Ƥ׆}QgF7wEnzt>x1%G|)ɻ#ךbg\30|I"D&,]Ɂ~2q?!/9oz>"5ZK]cCZd7rISaX~z`%5`HW!Xk%.~WJleewMӦeR<4f6gjmMƴ(nCVS'iz{2-;KZ5!yL5YJ[ : rGlGXqG{|vCvΆ$G:F;c#rd{{ಀ+R;Gaq\99)n ư_-A6!/>}7]񢵾@)IoMIZ$$g;߽ono(J%fčOk_SKtX_HBgtDt7w4tEx&e3\P4aI@{X\HaCQ[="=v;7Kiai8!4꒍o8=n X8ڛgw-D)ֲQW[-C#BGlW`` ]{_zVEzJ 4Bؖ,+ޗ2@ ք}rh;=;}p+"LH8 7<*tˬ6ٮ^ȼQ=i<ء aBx#H v4r3ہŋ:1;:y}O(B,bm'p#AmZBIy0zBJcP:^}\n;x۝U-i茄شGʬT6  sj9eS>O^{끟 Oyz}*G_a])ygձ08h (~g~U;vqxԟ4Ǹ^+;A Ku5?dhTzSA~E O8YGn;r"nT>@ =.mwDBdbP ?Hp: 3oơX:ӴiESZVJ@u_^͆"e >^Uʧ 3 ȃg=:gQc2KKWC;@%lzyHmZ. V[;쒵~K~YcDL}²?Ƞ(5֯<;67l=;$"x""6+{tA"QFJN *~НB,ǫE=_y/D-C)nSnDң'B#4&c6UUQnSS6y&=XzmO5ewɶ9!'8͵Y+% )eRqkSt%7)LīRƃ`u 8љͲ}>LWP5KpT=-Bmd *h<?\.T,s[{֙6"˭x 4xC.ԗ&Ȥ@tĎ0.Nz)'P)GP#ӧRhg |u6۔8)5,'6P>d Ѫ:FXMn|yG^!97JįF:jrQ\OأqV!d'|ۑ5HkĻ ?(ׄdg /~TXoD OxWߝݔXmlRڠsKQ>v͹T;1֗!ttn՞܉|j5o:-?D'-$łk}J~C&CN<!њe(9 rmݻ@nƓANeq%O Q͔,%"A!2&K\SQ@QṔ,i@2F9cpE֩pxBROq'*ơy3Ŷ) <)D?4 ?(#DsZ!,:e;vPZz/zhҖ, A(1Qdxs|O   }B,Sm]a∧ۏNA5qHWl ôf)zƩX xB Gͱ?tG;}HbIS;5 K(1kQFd|{HXI꬈ĩ̃CzFZAA 򽆬voCGg.V+60lNм'$_9^|$E$ RbUILp;>TÒt?5J8ښH#z0;r7@^dGv6V~]Р-~_hnnL_a7܁"};Glidȿh3=/Ww 6J dusjTf[R^YJXm ',z̮n9u]lldtt9Wœ%#;97`|rV?[c=h/60:[fŢ-;;uZU*ZG&4R_RI"qvs֍x02E'š*{Sӵe|k2 $h¥+Fy_`F3ux8ڧ9mcpRevisions are the revisions this door answers in. The two before // mcpProtocolVersion define the same Streamable HTTP transport and the same tool // methods, and neither has JSON-RPC batches, so a client that asks for one is // served it as written. var mcpRevisions = map[string]bool{"2025-06-18": true, "2025-11-25": true, mcpProtocolVersion: true} // negotiate is the revision an initialize is answered in, by the MCP lifecycle's // version negotiation: the one the client asked for when this door speaks it, // else the newest. func negotiate(params []byte) string { var p struct { ProtocolVersion string `json:"protocolVersion"` } if json.Unmarshal(params, &p) == nil && mcpRevisions[p.ProtocolVersion] { return p.ProtocolVersion } return mcpProtocolVersion }4*negotiate(f.Params)*GL9" x1۹ޜ+| [#l.88C|qnH; Ax7ޜױ // The addresses whose refusals speak RFC 6749, read from the same walk the // error handler is built from, so the document a2nd the wire agree. oauth := composeOAuth(a.plan()]#// Any status the op does not declare is a refusal, written in the body its // address speaks (see problem.go). Publishing thQat body is what lets a // client generated from this document type its errors. *>Dresp["default"] = refusalResponse(reg, oauth[op.Method+" "+op.Path])+@The schema names a refusal body is published under. Neither can be the name // of a Go type: a type name has no '-', and a qualified one contains a '.'. const ( problemSchema = "problem-details" oauthSchema = "oauth-error" ) // refusalResponse is an op's `default` response: an RFC 9457 problem document, // or RFC 6749's error pair at an OAuth address. func refusalResponse(r oauth boolname, media, schema := problemSchema, mimeProblem, problemDocument if oauth { name, media, schema = oauthSchema, mimeJSON, oKauthError } if _, ok := reg.defs[name]; !ok { reg.defs[name] = schema()_ "description": "refused", & media:^reg.ref(name)}}, } } // problemDocument is the shape [HTTPError.problem] writes. A refusal's own // extension members sit beside these, which an object schema allows by default. // additionalProperties is left out rather than written as true: readers off the // document, CommandsFromSpec among them, parse every schema as an object. func problemDocument( str := func(d^ q|@ description": d} !_ "type":щ<"description": "An RFC 9457 problem document.", "propertie-PP str("about:blank"), "title": str("The status's reason phrase."), "status+@ӆ"int64", "description": "The HTTP status."}, "detail": str("What was refused, for a person to read."), "code": str("A stable token a client can branch on, when the refusal names one."), }, "required": []string{"type", "status", "detail"}, } Y} // oauthError is the shape [HTTPError.oauth] writes (RFC 6749 §5.2). func oauthError(q| "type":щ:"description": "An RFC 6749 error response.", "propertie-error": !* "error_descripti+@? , "required": []string{"error".-0Tx}i Tmǧ-Q=ɾW3Ìf3(d}DIe,{HY*k!sΌ}}}#A0']zh?|R9QiPIQVRPST@xjhi)iyj4TPm RSQFyxٽ~XqVe?2 c}Sc# x(/3Z62ᯘ Y;X2=,U;sUcZ;j+K[ۘml/Scƪ As`genhlh #4qڛ(*:/ beM_ЮX"`w֍ VRՐGD50yBS[LԅgBƆNG\Z"{o P?kw!T,ASV{X5-ߜy":SuȢ$EaEMYX3p P$HUΫFd '(T2`T֕ )M, _PHZClcT0o<"NwDlb;O3D }㑚KsbLb5 &vvulN}DqXCn_C!RPSw&Pw%K!RHΒd 皆9m65LoQ m/9-t?L oq:bE@B+ZѢ¾gG/ !h\KQKBMG| Q㹧*{`넌zK%:ϺiHi5htA\ٳd )FoxvFH#Myp9TLݕ4Y 2_G:]U *b-ɫQЩeTi~1Gw6.[iIJ  ~}gtf)3"1,N$ddϚ7>wy>W;Ai )X8tO6>)"T;}3\s3"P!2ܿ}X lMiÑ8,`F<\xCO ),$:mqLJU, bV6ڄT1{|2mY /te|j2P#S"-b\F_!apE"D0B@|G3=F| ul&VSp GB)p,&8J# [bFgЯ]Y,x[r<8tO T+}4DZD7T,/z%lcgmD'#P=KfLCI;ϙvyͳ4ǣDrdotDe#Y<<"J"`;r_f Ͳ,Og"g^v%j9v%m38 ]i=Fvr!φd6bw_h&5o>*٨`C5Ҿ? >SLVj eן>.@t>P+tyMf&F.0oZ._nfvr2jo=S ]0|6LE`ٲ_/}Bq%q woUx.d}E))65T77~`4O WHC֥( 蝨7wuFA4e]{Fs֛u |P ("1Ϟ/ҩ6,KΣ{`XhI#_p(klTb `'Ьˊ~*б25&LqI=h XW&ۤ9^mA3uS쭝0k|Jbgj^0wzc(8|ɐ5ys"h(j({ߔ~[VdғIMFPפǭPozMX+;!#[oXO5"\(m{CD<{ 82W;O+Ǿ bple!˜ AF0~R ;~UإA '[h|I͍8)r&h[8a_Go$O򔔱@UBBHW?sءv)ERM6A(nŒ(ߛP>C-@J\w+^CÇGHjbg]{{g,bm+#4pV֗MaZ2 rlܛH@Yn9kmߛu#$S1d"͇Uއv ò:zpY+0Kq<]. Z S1By ySv .5!]ű~  {o^<}p#; ;Ј:ڋ2_x%~)8~{㖽V A) ǸЁUylo=|> 2ݽK)NJБL7rtS٭MYwTSz14a7!4gWw5N GVAeCZJG$w!Dɬ0|ps\dUgZ{Dā((=\煅g_u'nK#5 V?$ [hp>F.M{KBEY'TDPWvn{Ul"^*~me.رѹw!ТrD% L+˥ڳU̾[:=/ q&z V-Iy>6Tz@OS.;G q$"6dV#?7Y z]Ǣf%'o^č7.cӦid$+; VT]uR^6YwG(ɀ ت%]w7>ٶ$ GŒh B8U\&tCua9hvBEPi}o&u*ƀa Y }) .pT1e DDA2R4lDݪh PD}-{ vcU4c"=LeD-AgAҒۂ8pC$1X7b2T"Z@ս%Ramx^E!篪.;(baH`I_'Ὅ[wT%S暈xzbq:h^V[Q X*|4~tS%>oY2K+\Y,g\v\"W&&_~:.-/ݎ'\qD$[뼳l70jij+;IHE *5DeBMr$Ŋp4`+%LJ ݦmO"X@t0뤩l5Ỵ$Ѝ!:\Q[1 'Mg*6gP"'6Mߥ]e(|ȬgjG1Ord͘{zw|u⹎Qތj 20H32`͑#N>Ԏw9lӡ[SW u~Zn?з^<"L |{DfjǶgv ]u-$WI)޿n9AˎjZlU]?xrt6pu$#CIqKN-?<i<5?J!ז H l^΋,p7o.Y`qVfT4@]N52rW㎤M|i~#>+o';37`q/v5xy p;_sX|M&%ݎ[ʶn-T޺r l CX<7=4fF`U#C_HZ@dB`xOU3@QZG@ }9ꓗiw'RuP*f( ۿVuF?m^b(D$<.D'Hd$<~Y;@&<.B9 i腁 ~PK!u8r[xO!,hA[ Ґ]audW"SӏʘODȴn lz+h`ۄԗdm;>^  o n &0[c+ot D8z \_o8>Eni$JDV?Z^z JX|!ՓlLE>h?ȉd[0*zemQF^XO.ƞiYҖFA¤  4޺dVHԳˉ>.&PbWtQLW-uMRF 9uMDp4@N=wG͌TŰxOcNJׯ<}K[qJ ,yT׋[(h /׮!̅ ݞM~,EciqV낯m^hZm6uV65ݟfa^p@+haXbeךjrg8ovRxm>ͶMDNa)YYp^NWFr} hTM05˚xP긢䵉$rjhNef% {Gإi@Bo}!圡GF׼֑D"k 3mf?W6UPbN6qụ0$s?%SZhEB)>d,Y0=[g(әFZ0~u5(pq(؄Z7U) z}4lxjͦ1h^sNZ*ۉ**G42%Yi/SɏPx&ĄeUlQu Gx=IKȴ%ȓ% vZe?>E`? RrYB2;KH'c.Ÿ NcdU+xە!|?cN9󸱀ӬΧ9EiE SEG~cKpj.9"f.沤¤;dYiAASff6:#6RP蔰hUM67{6-Mu Wҝ@oQ?bm"+0FY;HE 'YOk`+&wqlm:50H/ ގh(Fd\b2H҅3 0Cj`(A׷"F %+P,NAB`Чr/@bچ|o-& ՜BzC,|_e Pj-ڣ&Gm랦#&JSgKVc -_Z Ի$G`DvigY![dszLq|5g3ZqVsmfϖҘOW!I |ЧC$^L=cF—ț$}JϏ!ϠӘxBϦw]Sv^1b:6]c0xF[㺼؋ p{>[\omc,D-=0zcpͷ41ClGq+=CuNVp$1>Ţex>zv@3pܶK}?O'G؃>G]GcIфnaYxQf(&_I^;So`q^*4G=t7IAH Č$ͰӦQ'=4AIRf=wJ;(Q%b̚_~g֬@[p]כUc#Klb3v>/>m3}-fKGQe[WD_UCEH1;]I oj>!5W?tD7cByDw!FP+stRGY `UJ2\Ygbؑ S_oVT Νj UN-B EFoV1 ӋzHxfurdCQ8~&?UWBa{F.%6FP" Xv J&?>r0ԩr%*g,q^%z[m~ޑ;汃;K3 /9! K$MxA;]rcL;3jNqPϳB_4`gd> 7o+*jrL_tkϦzHI@ }yh6[w"G=W}*x-do<2c]ͤ 5RTs`V]i:7kkȑҥedd*3d ÁY1"L:|iN{G.q2yz JĈ;Z?WT`n}P|$"Loyb\%Qp u]|St,~0x)'!2Si9 " OZXG%ӌ_3#'[* ]GEC8-5Z`DzXr`;/ΤQүމ\5mroXGfEH%v>ح=x^mKUcn="xę% u+"uh hL5;4 xQ>f]-)2 NVP_UJ ]R)jWцh0]ZO ?f=P]Hד7ghԊ5:;\|~|X/)Ǟ0f7/峷1^'jAR 7dC|,M}3M}Xo>)2Ma:'2eXMVҐtT̕V3u82eY0>9~m4k|mO¸MĚE:Gf[ T4tEnYj*VRЯIV{5CfwPdFݴu8T=ʮahw  ,5S7F%)ٮf zvq!s+YnF3@eh> 8EV#O<Rcis*/%1!(>`B٘(pgd$a? ^^bAbQ l+ί./ްqN*V@O|*t֊S]jyseרtdo:tZ}WigrnB!~`ֺzt皯M/`,3 ="41DuE]ctR|?H3P!;g8#N%#n/wvηjzT-)5 a[f B1MR94 -Qy؂E=T 2#Z8v4 ȌfhbzAz.2 #`'ؙs|E2g# r2L&ko1mU#A,h$ %F<~8HGPD'?sVC6ͩЩcHw!Q ?!)5ܭL!NMtd&^\w# u-[(QAsrXB{(ٛ c832CA'&s/ox7vUXnAÓ b"vMGӴ>qj*H.XqKpƯq%ՐTNE>F HܶWR0sز+б8 }(٭2HH2LwQn&\]K}p(mG"_Yc-ePY̗ y; wrLb$G8=gVL! P łlz8iw{וy>T G'/G%E\Y]h8]sbT̋:~ط1fÀ(y|FE<t Pwh;yhZTEQeD8 ̯4-B-j0С5a0E:a«ђ@`14)oׅziO3sb#O.qd} C%쿹'k|7 ӟG@$s> []xYo{ʂGfa ;п'3?pC'ZA`'8Hom[@㸘D|,V7*IVyݧj#k VACxR.b8 lP!q U}Cof/@'rC |Ԥ%P70h_^8׻V=w( c HO&*N7'xJٽbl(oeXxUy%`[!I,,:pOG;D۩ٕcG^3}wPfW3r7T6(pnOnT磤VHNCXq~q_7z?ΕA;QNՖ S `Z%}0~; X#$E`ZI}bxB+B !Xż}'Kqb2H}À}!A%"֤[n? 2@6D|z7w!oR&қ^#@oR%ޘD d02iHjl0~  ̌csƞ^miɄ [gYKsJO=wW拻պn@G62Lq;gtyU Dm A6>s``?1 WDaC AGm迌\SU4Yй;syaKcģfqH 4l{k2(h=^%gǹ[Ǿ{Yl gqgY#{GxEMA #Ht*i 2'VB@ܐF( n8X쯗f{C(" r#L Vx zy٠B,2_ؑT &:Ṭ?-2Y:).<0xhrGUy+ce-A"<N%ۦ>0ɘD١}.ȝ^X_mx͝rי?WFJ CT%[YI V4Kn4YfB|r{%s{HHko*UAQ _yvUSezv\U;rltyүvίѓ'uSճմV|/e=^'LJz>^MrVVͼjcvjQj4fR鸩óxyS5mջ)=vxtum.׳Yu[@k_i$fh4F_yq2v5k5MN:8< z HY.֫f06Gd1^s\}qZ-j6m#a0P(ߛ7JfY%ZUz]A3P4²9  `oLϠj4t6ϫ inylYf+ P-ANa?]6INuK1/D*/k135+kFj0E3m2!ck\(2wxU, xmU-oYMSp7 z e+͛ft 3>gCN i T+|\+-r#11j+fLD-=(}0g_WGϏοΪ'Gr6ΚnZb5i.sKk UUӛv! cy."A2N7hJEk-_WY&3[ԓaU,r>ٿ5mŬ1$$X߲d2kz:G3}w}_*ΚXHe,xނT/Tkju+6mE1~_:=UNjj@$BО1f-W@ٰn_$u whՊG M"ܷ`ዦZCUuXؤ˖y|_U/r ǶZ+-, 0xtϡ/fAP\t1M*vT܏%Sf nW{3nW_~ur*JD ܐ2ZvmVVL7[,n;~zvX@dΏJiltowI;V!e 񳽳/ßL3iBZxl>x^"2SY!tnԜ 쓗Ppf^}?/CDcZ}7Rb -?4 N]]p<>{{Iq&z};JVUg/زrqCԝ>C!^-ȥq9t;C$=C>Lǝ x?7L De=Y.D^.=3EAI-moIZy , *"h>b+/fn96ϫzlSCu/0)Q z}^ 7pFv{F"?doM&R=С V)E Az X_f1if.+X/3_njȣ\bxr^zɮQ*hh- xp/x ڶ_bfo8Zf\rO#xوkv@<p3Lj-cIjɺԯDVcߡ'Jmܽn^LטV.LA/v\%$]f15boFK x^*rM5(0,szK\bUTѐ VWvtj^q9t=/k1َ< >$!<Ѣ osB T3k;^No"MYRrU]OW5ˆlixהV^O>@hH`tC3dKm0kZkˣGVyuE.V~jXqT`b`6wNu УhGS&XI?}\s{(!9ьl[?&z"];w`zOk-z: A8NͽuP=G`:q8 pӪA*Ą!-v!QY,DI&BB3 |!N'Lx3P]VO"KqkjP@zH!PF3qqF7ǭ7Sq'hwA8.͊ Wb1\\VID:/JÑ\; l)d%PdDžS~t}<2&P6J(*3($+_.7 $oNO=N~Lա^cX~?0 d5G1bpW`P͖ĉJA"|sW9Z%[y9Ee%dzu+\ă%W$JcW`/OψN%>G:@oR:v(j,#Q9Nҧ/A񨣄/m+t>Eo%[ɪ4;0nN6\_Ok`ٚu %<ة |BaɳWHrflE>6S"lϵOT('G#(< p&YRzoZQJʠm굨 6ځ>ȕB6*AY>}SG /g)YJ^Qb@}Gx[N:vD(eTTͼSb̛p{!gΚ.Sze*%Q:PV꜠]QPHȫ ƽC;+Kr^ak2^(.8zM,_)(S'.{(B c(EjVAHDUTD9eB?eKRQ 2^ahf)'ZNuNX'땊*7)i.:W}Ґ7* .ψY/vj1d  㗭q< M.>E\ε߁x%6QRg*"` Rh q_o(QQ= HgESbHOǶFvÏψ2oǼ?%%БCwy*-x9@*mC@1hWrN;vs'3Z3g31oݧp4*ǯTHTr{Q? ef07BC|ѱNsyut~V=?j׷5J.Vmc V,w:IS&ڦ/!ͤgdD(b,qj C&d ikk{BXe.X]^]PmGaŝ]T ;%0@_!V7w*";SEpBHmw qru,((>;qz /72:EL8RTStASIG!`/_Ň 09Z.*AZ<=k=[J/V @.MiramJ&U?jK쌴ql7)'\S K=`#˭D^🌪.q /?tռO; r/6<\o0n`.` 8$#xe@qK5u*zX5g>t#h}ZdhޝH8Բd]<N ϒ")(!ŸiELj\y˓aTIKS"'A[?pg(V\ld  ,Wct'{F`{3 smBTM+8nZw#~ݠ fb<asѡwпݸN?{K?Yc1֬rulP? 'MFkPbYQ(_.!;D\A>Ee):;<tkt˦:zaÞc͊< x |̾U$*AHϣ-Qٛo4c~@Ԉʅ ^RU^n$y3ÌWyy=LswQF'L ntR>{Fo ~yݥNxe3sѻXV@7aJ|™^3*UGgCg L(>aMk9Zf&~#QL-[-:ڐ:7ϳsTE::=;}8×_a¬ 꾬lt-ņb@-l^2Kc̐`\& ԲQA٢L#'dGZD`T:" 6iPeõ!J^FJv gP2;G ƅ^IzBJ`4ʗᡒڵ8sΒ^}yfEfYƭ\Nmnנ #ޫr! ~ȒuffDL _,; KBNl::"E.M8%6tPaɀy]-P ;@ !<0n`Fyõ"*<?S3`==@gu:'JsoaBl; '^FLe7I=OT(7g 7hc6qE 77 ZN_"LIIJ|v]Ҕ ]Nx9(g7b᠎ʻ4PmZ#>rmf TZ>K 8m!J[ i1L6- _ \KcϷt#M8@9}jjZCHlI9L39szꭄBntSM͊nY@p]XOF!]@ J^I"SWӀ-g;h?^4"*yW^Tۆt5-k@lT傈} VS[^թ^ RT9w,EgE?%dұe0A#'F=^Gw#2w1oоBJL,im`-źH2Y(Yh)*Qɢs fz4BBИk6q>hXWfUI$I=ߧQ`$\=2 \IMZ)V>bn|Zoz@IK3 j j]pMFH%ThGo$DN`[5E30%I ]uOGxu; 'K|iw9_o@s{L>0=m3LMg1R5I\nXC b Q@!퐮~ُ;iÎ!O/Z 18ޫ1҇#7R. ߧdVw(Ri捇8)!ظCُxF2%D%Yv8Os/+ Yi=2Ite%g2Gx1 1@S<#4 9%(4I;tyk,hjxIPgEaءTdw$&B.SJ!!oWReةAӻPtl'6L^[ȮAǔjjVfAJGfpl?[>ɅePzYz@Li=@jjGLo\ݝ}!n ɰAbhNQGn|KPAELtrmcrP0S{mzIUmBșGg4;Wjܐ5n4&PsЦ9,>;$O;1Hq*2H(^U)r`\<0^>,)/aa DJJDW{qdÞh=ED/tPl:VQ oDt>a?&#Ѓ[2}}LX6N+] ~?{#uu`р75UTg %ƃǕN3Ɨ@lu>~ +'xTgTk'IBm"]WEi: ۧGeXf % :#yP*cV:n^n8+]"I(zt@l348Xm|UgD!XZXy`PK~ %YDkÌpng$=ݞȰi7 ηA3O&`^84.y,JA"*WdCԗD/wט{Ǝ| vLcF~J8L|%EU0݃n27쏧9^ĖBK*x[38%g(gƟwi(Mu;qF5钭wB' , ySp/FrAN+q(:ϣx>K*z݉S }YBÂSWȤW{][z@ `9ɜumC'sI kuN,`LX\.xȽr:+ CRIS.  Էi T*`if,Ƿ*ۃLC n]=G5B 'PGJ3hbQ H?5yH>(4~ {ŀO 4V >] ;2W?<[ ܫ_JP=! g#tq:s2AN5iaT\*p7emdQ$h8WߚFu1]> lB*>5FvQ(pF2oC <qʗG/[hwgqT ޚ]l@P/y*8CnC|]W}ʓ)r>zR`Z#h+^XJBmZoLiӏ,XE `ԷtHË !~=|7jLءP:l 4w ЮJx9bgLQC,@cw|HmId.h'+%c= 0~~+GF'p Kz6r`wDm>r4T/b|5Ug'1|sNUhBR,KI6|4 kk ;Ԍ_/Rh&Zw4bG)4xJ _!;ˎ1K2 :U16%= yg-љ (%OדZRJzPdZ?kqհ\QEଈB*&u >!riX2Ҹ7W {:IP 3O?Arhe̜Άv u 2 &|J^lTlk!˛UK{DF j#^:CJ:…mΡMq JC=X$S>K'qG>B{PKu3:8p;_v} B$d?jh])y "|TaDYMo:#Ths=+1[!O ӢYwmvAEJLi@XĘw2)~{BN@UEt(qK+1 , vȏoXc8e(ԋl2 ˕\C{/K}!%n+Ѥ,Ӳ/cfHˆ O?G4?%= J7'l]ў/aGkBZLy&.~Q}\\ղG>cZ:|up_W_?cS@:k wh+]w o$.Sa|ҿyBD 66|pꃸ!2GIin:"lnJ3gѻ5v8*= cѝ _^+c^]QzRD4}2ȃRCVR(*\+%:ЃtMQ+kFi[)Y\& #+GLYmPg yU^tcC?8~# D>- H(v[9蘢E'B+]0vrP!>ز;?G0ѤG 8 "яb|*Ucu5T cPd?g|\u8RѣscxxWAo$WfJrX%!JRlϮ67N,9Lt~ٞ^O{Ɂ h;\4$ qAOp@BT랙DݯꫪUz]|mیsҐ[K@KLLa cQ8 >`nwxMkΦ\^Ƭ킱jh[?;(SD9>Vn2JAh4ŏ¯T*XF;T1vBQJg"ٔ>OD8(z8ë.P 6%lLPi0NI/ϣXS,4(Ob*16KHzngp(EBV+6g!ʄ9D"LX ᐶGTH І=[-Cģum&GcY3$@;1==-Ʀ`h nb)"T\{{DόP]%Ƙ[rL%cLłM!&Qxq>]2%E\ߢ-j-RKсqY/A6޾5ӵPCO]ۄu !- DepN_E 9{Z*~DXlgrL6_1Y0t߬>S3|'K`Z=~dAfxO2(Oҧ&9M__k^}':8_zۨKGi@-~(*fOǗx0͓ϟ*}o/Jp8]fcaqa-A5[tih,,ĂIPWY݂n.V&7C_`U PT1FE4 یhj5n \XFWtxׯ]dI{;lP[}ֿu;S\u/>tR|':aU֩:4~ʯW=U_=ۀVwvYk~l0T!ihP2kSz~0#cY6ݷvBgia g4d~ֺnx`uyJO fu7ѻkHF7iuE5@ wEj *,*U]=֐?4u1KiT-6;o#|^ĨdFG͖ډi!VTDhp.Fn,G@=0K㚖\ )\YhrCnqbr.k'*i{Ig1@K,Q*R.Ե[YC5V…*anN?:SC Ҹm 9]Oϸ]*pc 9W T"C(c0]'!aM 9#LpIf\<W ýKW{a)* P5F#VUB5BGdK65Wh=L4xC9b!-!. Eb{p!V辱(N+5%l+Ŵ\ht'0EUTm:8-~U9H@uew\_Bb )2)H0ѳFVjiYr NrdcȔ<%79/V]T uF0('Z@iIQI $CPX{FeľUBҩ*Oϑ) MZVٳ_8l'g稓B~K/^=0xzHH9Pw&ymN3{T100644 README.md@k7{EJƂ-O *p2 B ] r&p3T(xr\GyO B@ @ Tfi 8l1۱yzz-{RUMU}:?~,?jx3|=^zd}\~.vzǣW/ջeuލ͗o~};TYxV[ճdmݎz=/ZַbPjpnﭗj1_Cr5z;ɊU zl>\ _WXvl&wj=_Qr<ُ҈(ջ!Up:FŔt>lXs7mxf8UUr;><8>܍j1v F0`u;hqGU-nÑ~Wo |9x-y%.Ǽy\]n<=olpv:o'%4^*6q5qˀj%Gzv̫ j}X ^3׊Zzvp9 4.pņ~wrWUb,??c3ܷZ/Nvr pm^ͯ6w^0zBZ*dpuF$?Cqn>\zYLi0t='5fHmڿjbl F(n^S'f8__WP$54\mfT{^4Vw5Q難K+3sJvU_j!6SlȪ$'|uގ5"~Ur +VG'ϟ:X`ry_/j< ~y NѝR+4♌6g|w@w:ӱD`ewch`u}3?7Wmh|1? IOV`2CooNFv8W/v \*w:}}^FŸmt>8yqn wD\&S-n+?erD'HV`YKc\ n5eu*?R,&Xdb>p|rv~ЬQDżY~glӰdwõE6jΗ#CKU>:纜onnE;QY ,:&bP7{i\>A/~käFs'BgJ^kr29ݬڟR1=5_M\ôo &2Wn V/ ov&2F }+会/Ec8*Bǎ7O̶U?\GOߌѯh\T!Xi1 Pg*|p0WoVBcZKB=߽Yرl~kkt"/Mq\I69֤NCX~˞-|9*pe0 #`Zj/uv2e2Ptkb. HiZM,fu;\@aE1Vw"DGӆ3,X䓙?3a* PGޫRi c-Lzq7 -knT$L'( GJZwe1X /YcEj<6g]D&!q# Ǯ'-ơjBWީW4 )vzE[O"AɹyU<5d<&ڲ=uXv'_h;j*G1E0l9ix-ZL+ӿ{gǁ |+|Z}0NkQt in [ȼ %@|DВ>z˵ܝjk\OF[;w#@Rٯ"u;^N&k`޶'Cw0cJH5B% MxT2k72M 2)&JDLD 1 ZZ]0%D;~[lV =j LjW hdvSY|ĂM2F"\ydu 2yFt$sj aЅ5^2;i=]Rt ~_Ā#8?vJNl0WQ ~f_\a/oq=] qץMJLJg'^p CfJ,īn+\ɥi7lJ$y/Fa^/b5{~CXz!z&)U NkD.$F'I}bR-.OQ1",Cҁ.jᾴꚯ;ֈ!NA @s;>OgE"gV᐀'+ @>7 e@Cӡ4>y#I7f:/*2!4&D:~zhyd$)ͳ'M\HR~wA +RpHIG5-ـ*"9\"驈rȑ:Z|ϽVq#@>`VK*J*ب){eRhdv4#ny%~~A aVECuyvG eV;I)?L_+q&d1 Hj&+SfS lvi 2 Eu73H`@L i*"/`WbOFc ֓O~ (U"^sD( B& q0#eqМ-%kۿU$ aB>SƍF]QhVtP3PB}QDj@ok'y . J+h6!#$U c@vEhʶ@zB],Շ4Rûߨ!EwNqG'wc:fg'Q 4?t-ӳR%RM1)sctgxDRI&+gkTjdi=)]$1^-g%wcUMVB;ïA/WE%\E3?\)HI/b U~ pԵ#PU2TLd & ֋eVr$PH`8.5wZrdy.6x!j3T`UO86Gx)Eh4Q8+'6&}T=ɇ]6y_ -$raV)x0zr9qM©P9=03#Fa2<{Dj BO+F1Uv{'5)C e:|ݹ Ev&3y5v 4%&?eæ|UfSoq-mULD Ձ\P4C%;UH ZI{pM>@WEx)^G}ʂ`:(=Tsmo+T)OO͊Jbʰ/$RI"!բi^,8`fk;-@@WZj>۩=ShD`;ql?(edcU@[V7Hr¥!D8L5*`w R|P!jaP>b4́GVΛ# ?@/B0Ug<A^<2܆GncM;L$  ^*F"OZFh䬺LM $'@juO,jZSsV05lRfBqwE,QM Ob$Jlo.7iDL o^`A T<QKjs%[TFX[@ +^ch#yGa: 26Հ,Cn<jnf^c Jʉs!&Qg9x-vgq"pF]Hw.cpkkFb].4J̃(PaޘB4>B2Chد0౏`ŇEnF.SKY *]|:$Z#KpT`ԛcf!xIYs<=c-_~UO?%]t &? ?gzo~gO?g)VAҿP3Ey;%w9tjT@<9Ey_&? dD3aQr-2q :t7Im@OK* RR!$sK[cv[?; ĶMeC/#h0npDLӲv ю6X ΨI^.H]>!&EMY.'3$:q6rJQ+UduRDNAҷ{,)J'fN#\U l?#(+qX^ R4&,a|f /`^.=kg6}ڼ6 `Z2}[w3{ZM[szF[4}EALkzP`'Ȇ5Q4u RT X1qRώSj.:үQI3=|w <(>}^0W\v>K@u_a!M 67/'<6ӌ2hPxˍqqDb} AH;X RBDWw)0Ү9]c4r.pvV=~O $lu?ѲOJ#T>)`#iTL"rBkjw1g^P=u Б63ИÏԙ-ǦLS}XB>Hv1FN7É( 7] :Η-'s%Se1ؐ?"xǩCaZ eb8+TӃMtǂF~TS &j? m@[1\6^$_ͭ~(*\VgK+ 7v!eIzEc$@Hrq0J׉j/h'K`z/4wf,^.!_ IDYM9($ g8 tT&fhVQY@*`@0Iˍi#S;pm`H1͙\ wX&hѴ*E@̼ d%mTS]xu !'?Nk8"`P`8{9RJx Q{%OO93v/(-J\`';|7^0lgԬ!Zd=8! 4"S"2@V;[IKY^+9 nu o6E#oBu-z J&znMI; Ghuc?(&>q6䴰 mb4FJy 'G? + Af 6Xa(KYD,\p<-,r{b9T}n'+(§2W1T%`#M dsrޕK0>tl@$o͚_ FTW5!Lb=%]6zz8$х*I:N.ŎB˪NR\NaLq㴀_I'¢T~/> if+j: mIƄF7%FrľLE4v/)=>ev)9X/d66>& *9SpEbg31pƈxAa.C㉁d}H:>|͎[L;Mr >xL!/T;>F" M]ͪgc#8F|#i\ %P`P"!یbnHCs^LSi2X^y Q ?6G-A~p+G4ޠe9ML9NyR?f|'x-s4HlҁoaE[`Vc ĦmfJ.r!W9G9qqdwp~ 0t7xi/ȏq%Y?G*$l{NqL7k^fLN'EtJoSAȨ0cSZ? 7α_E%cuFaadnG S Ti,n(x%̌J+Zʣj0pPQ Paq,{iy>W^)-6 zV~K[r2?ޘ^!DaP ?_v|8M-S’LQD]]釉TyXE!)Eb8;ǟvi~ -? L9Б9[AB,T+Tѭè/:"EÊ-a)H)CG;zZTxVOXWKl!,[d J N^pݫo8:9ao 3ɜS(F"/nJ7!ltrḦ́5G5¤ -/ Çh nDx0 NN/Vdr?갂`jj)QBvfR@ õ0t/2ΙYP#H1 -Rw@TEj՞\~a6F~.pCEew|zKX()]F/4VdC1Q.]8I_sS(DImϐ!he(FPL (IHhj/" [4UrRdw=-L4 k 3,,!ܝ.aϱ@#ZfDO#Ϟ~GE];:ѯXBƝ:(U Va|L -,wF0EU!5 Rw Z|lm)[ (ڎ< uLkb̷HnQHtZE+E2 9_h/%Qs9 j-Qn X!7z(]FwPB+öy6 LGy g |:M b[P4Aq53af1ko?>FbWj4hÚsK<wqp;( 崽߇ TzL7,3O#``ʈ( O^W3pr: x(ui;|s`R"]璂dqF'4 nRҞtBGF?( 9˫)sC:ӧ\哧sOسHI0QvQt}9<*-Bb Y3D s}i\% 4h' eQf7HG rPhv'2 353ߏ?7 A48]Ƞ>"O|"ǛĂ #>^\l>Li&GCch8"bP΢W07ɚ&gsktR_F{UmܼVlNN>*n鄇vEl ׃W)rc\x8KYLaDV#"D `Orw w+ ni6l3%Tgu[~w߈m=bΐp.Q%L[VY-< o s1Z 5]*QԩAd& + AF5k蕤Q}fB 4/Xش"E8_2 + : ȅFh[ҽIB=]FZiD+tR .bLÃ&VZk$PoԒdGi$%;&6!6HE]O5;k4A<C 5/m&HYk]T@7-EZnJ5MsFP$2{k:eXk~]PK1hV'?izmU*'l+]hco;,'ov$@5%hi~:i|sɬO$j@JbAԯj1$ R&<Ɍu~أrЯ’eT%HU:CXXǏw>BC1VD./%WL0(nf,z.ȼEHx}LzQi_P\{Aq v6BA%H)ҴUv >VL'ӲDM¿?"nםm}sKbڗF ,L^1 h 6Tk'wת/y%f!}Gfh*44x5nn͉$aҾ{\!P#9inMe R۔bU{ `&jj1`VgWY't1tVC~vKjr> y_:SQf[-0Kl=<}bv؍b+$L>$"~H 2˃n-vH+@` Jgb5Δ嶪dZs.kHv%ϵf^c~zܘF/lB" MU:c*_b*X9ކTNEX6?r,Y:{g+1ou,^ߡVtYYd!i8fjGA^"W$mly\\WQi0%Z[P,VF%zX5<0 `qgFה5,/"#1”ݾ'I^ r9G-< Y+~o8jK͵c N/Das*U@UQa1^gljD\n0f[6,JBزC).-T9"!x шN+]@ +8u} /$t^F'a5A>)-hs >U,V *ׯ\ڣ'TI1l#%mTwfzwzy!n)AzxdF2A[,cpy[}Z⍺RHn^!tN"J<#潹{fJ ~Vxyٻ~wMٔI ]zLGz'@{jdzEc)¨A(TjYI|y tv:_M: % AG):eSP@OB=nzg1b,&A~H-Dzi(~6/ua@M(֫$@4H( Gl=^#BIw@X,1"= iLǺGi'ҟC-,~ܤ9mb.(M伪Jy'(edt[jrM˰G/Bc#Z~i@ 3 Çy6Rjg UnM/ VoiCZ3!y%Q@4DOU}MUAHeå!DL.*UH&#&1:oE @)QO,MJK 5þhgSd-b%2:|-uNI5bbP]/w_CtU׎N#k7+za f=Jul5]k7-i:IHUV!J"`AJ8u@7b[x{sM!tFGV3OF Ce/h+X0p8Ƒo@ÐZH5l H7 o7R!7Uz:9;UV<WS(2&,,UK+hR͌yt響=~ug1.f$ɇPeD"-`-6=cw S~TsOh `hbB<[,eP KNiU(k+(/ĐdVJCNGR CҠ0n`Xg@SًM1wzeN sFn5;YTnD_y"CXoIr(p% sIVm|G[|Ii^9& h0@#JQ2|*P50NOs,+#:1F&@tJMbku"?Z u鉾{՝{X3pvg}/N$:ofơmdhscp*!*!;~Ё_%yhœ^aft{(79~ч1D&+JY^,{M QŀG^8ɧomN1mgjY&}6YAG =s'2lᯇQ/CV}0cy׋7Q `5TncaRfO4hduKN C5HS IapDU-Be|cĢ!oHR A:ha"!H.ځ4kE W݊8§AJ:YJmqq&ePdvd fV ղho\Td [t`Pw{b,ҀRO#4Ħ~ν2gE#/]As32GۦnO?WL_?ӐeX&Qʲ|TE-%[#KyS3 QH@lb 1VV՘R=eJ>*A( :cI¸t&0/Z䪍_:04r 0w(;( ~yҌ-2CTŽ̞-/o:B hJ~UqpA/Oт- eAuGըZgFpY!, xQ@#QypNΆY%[b K A4ҳ. 0Q9dv׮,HY]m "Q GDO*!Ke=LZv_DPsŔ7#YK` y3/C@{iz>3&'IXT/ǶT6:S5Д 3}CO<̞szqJ/\u%LbQ _7`,dxqxn=b>*d 7:WYb(RcLB H(èHn[zס=$)RܗA41L;wCцjn0m˷c2kŞՖ(,;U΋cA4h \l!yPZQMJKG@IIEF:iđ㨂&#錚.o?fAIJЗ!Rf4q!7DP!)sDAV1v?J_0JqC4&GZADe:6X$hVHMF[T{_OB"Qvݥv2S(N6bsL Q4t2e:W`ݧnoBH}( RR'wƏ "J &$:p*ǂ}i#G$N d ²P>ЂӀNu&  'JCj x:>~+,0u55DBp-WxЁt`K)S)tُ*j`$ћk;\ڃ U4>/Fx5XnC(DoB%$#⃶ΧX6iyF1GzQImcGdBW$pu)̀\brB\+6.4y+DS`7}4E[$$P]ny#'.#8SF-EʡyuZk #P:嫍rRFh0pF:#Le]늈A&8x"g7jy\lmY$ScJkN.U.0nܶyBhi hn0ƱD0^Kܤphū5c<޺G^f0('%q{Rs{%Bge@!D"؎,%E~1Ii0]b꘡o ;DxkU՜ԁbsݤdsRalLj墳<9FAfmc[*PȰ*ܲUlBe<b\e =H* \zl_ϴXBd~gNa8 >f6=3 n )݂h0)vBYNB)>}8 Vv8]sKn&{ԀVX@46Yɫ-)w = EBކHW|e-,P޲QYOf( $tG=~7.ޖ18IW\eԱVƍ{DRrsi=)t}\5hTrQ;1Q{DVIv )nqՑj C~bi=m<[.G]F4'Wꔔ(.mA{kNcai7Zzb="f>wm~f2Pt]0!pbk &~A_2-@T@azMytD}M /Tz/gh~ADŽ k)E)=G{6G( Sd6r#(X,4E5%K7Z'pŃu!ɈT2uoo+l y4U 3?b\K[++7\OM:3'w}f/eьJ7CaC i8n4|CfJ ^uWkч#UXD[]񅙣o)hآFhM# Ç9kPfSԅdܮQ <Ǘi5-#)\K؉3UظbJ_b5(}G P'O)s<(x xL2ͭ~"G@Ec=T9W|F=;\/x6!$ z}qKL3`j!}-3ңaY}'lYMYq}c!fMo.Hq/e0yxK%aGU/ST6In 2{:`;gy'S2S-NL aVuD4;؊qMu;DkDU9uno^- q% >mU$Bw}l&ePlGg'c<#fR XkDgL(,N\E8Rm{,JK#}W ,Kӱp[L-B3vB_jžFy8 i> uW{k({gGH@D)tkF̮?uelpi|X:dk1r|YucC??h@ ZTۧ`eN\hxOvgGֽ9ТbS 1z"WV}akʚ?#3Z!лuՔ6BU׵'VO9+SQ1|2|¸ -pJkхG?Nث3s0G9:QhL7.]N]7ƸoDYV\by~W%Ω  BHn]hr!4Nd Zނ~+R5/u,:q~ȼB|qQz@9ᄘ)GPC #4G5?vC,󏭋3nZ`3SW@nVO(bEmkYb==U1 ݥlj˔=x}շS;(% $Ho+}ZoF`*/OUJHEW/Z QR҉Cӹ&WϤPPqQ {6bcJ` 2ASGē/OU ۬kD #)1JA Ma(C1jO?uYq 39 2F,/|ݠ$9_XI n$'V/l4`? oyG4 S9);O_]˵ %'RаGSL{/{ 9h_+=Q5_(aEMi짺q("N9?͢8xN:Oqo7]"±1颪9 Ҵ7$֋Apү>"eY@ZFY-1@" 6 BcKKF䓥Eӎv($%TR]*9-nQ INI+"=шPZaep5BcR:Ƙ꞊2ҍLˀѮepnPQ&s2lh1WG9!B t>q sj}Fk{m H#)H_,>k'/«F<뼀Z 8 ۩r@W6GF`Y:Fs9D.G 5j!,?B< ǯ6r >໓˕^{bncz>~;宊\?~Rikeٛ-b S}zxo,[|Vp&jzOZM{]?{ n S֒@/O[QH(Sbu.F9o}GXfyݜ7 '߱֍HرS?byP5T GOia|a-wSPH̤z|f)F.QR@]zSo_Ժ[\Fo,g kt:JS `#3b]s$MaOq\A65hh"r5P_'`z-j//$q ss )$DZd(uXB3O;ꟂXvpZ/ak?2V'D%ӡ޹2[*͂NHKNn?k4c}j4Ajɓտ' >|T@D<)A: n[NHUŹɍ1eȕvJy^U|@#sRH`/oRe eO'VN[ רYa%yv ZƳ^8ʪj]Liyb6xZ_\ -kyCK"uO;(2ģ`ڜg{A㞵W?}O|#ȭ)<<Z5)#F1}oGp&=R~%+\_a)y^gO\K;*b^iF+*SN~)6@ۧ`~yT6HM!UȪ ?>sx#8u썭@ EOfcMV!Y-Cb]ʙX5^J'^tP ザC9qrAmpUb\>=!# f|>q }J0#0v}1R.Ԙoɴ, IZyǪǕw^cq6PaQu&j:%qlahZ|dҠ!iB-V #GT*a !1&= 7h 纥e#l8Ir5:MR"WKJf^KE@KʕM%<07:X@4u0@)E!?ڳ4!V{LoP"{񛼄Q0maNq(wiHطĬ1H]x_!3ߝͼ#S'8U8ժ_ !AⲮ)$^>H*(| Cvd+ b*LY.@hF(gqCuNlxW#?U+U7nԂ"5]' ]dqĠ#g.J=W-:h%;b2vI!2VRъ z_/U, Um'qPya8}u ̂E ;;LW'(T.zb{ njrH'US,0.rX+%lZp UXegЮuNPB2 䍅wĉN/ @/<n Tv{{C~K)Rw-F`)  VpM5t}ffx? 97B(֘2{"6}E| mEZe%-c]Oa:E}:a f&h`<̨.G.?2y(jfq1j\`-89 1x<}Ԫ'6JM'vسeb53̢BncϚؗ >Z;;|Z*,wMbx {2'rcqPNٍ?j:*I,󜐚밼t1c❇/Xٲ Z]N2MYHU`XſIO#O}Y%4U얲V4N(mW5  N;OS=h+([+@=()F7iRTN" mTnDEX\v"rO>qI0 W^htÓDjm/wt|'T},zcEgғE@ /Xn"*x`핪fca2DGn;Xh-*6Ԫ!6j{ .@Հ80⢎Q옻I` ٵPPyav- EsKFlS. XA hxHe'b[\t͒#F@CϿ|{&c(tij_ kύ&ֱFkRGQ\F2)hK]9fiGNdQI~E̠A=$*!ڭcRW|oDWfd@7 ,_]BOxYQb ZibY)) hjr04#] v= 0I+bw^<>K#xIs" wђ bRQԁG ]ek V}^/:*X6 :ku a@RƚrCbRj]&ၹh!+ kH1 :3$`k?;)(u-= d !)ٔe[c]B7YGPq$(]Ś1gP7cʩSKjX;RIMqᵥHi? MY#My0_ >D'i#8Uw]dM5m42{ DmI8<8۫Ž s_lTPLN(8vQ4@޿"6mde91V^ \GyPm;:ڊ We$HVd-R^Q41*K-" ϕT 4(k*%S(ldΠD8Wz'UR>O56]ZK4D}^8|wQ){UL.i9*b\d5'f~e+^lY9>6i`ǕftIB7"z WG@3G>\\v<29pό GaCFTy\?s9AF-:ꊽ_w(ԾNן鉰h+ìO Pxbӡ tEaS,+v@ h.Z{ɈlG'1b:#ud-9#Pgtvɀ{szϤFngb6`A~&,iqhɍ8H mWc8i}YH~q)w)`c)?)GN7/?:dj?s<b!]trS])r:e{d瀟+f_BI#2# hąޑK𦦸0VGT~6<哨"cfV,y Qȉ"K+zݱ> ؜;\ HDyb{b5/9Y=u,]$P G` (M$w9Qѐ(TϘi0g0Z-: Na Q3"©_ͯh=7m9A.WUYBB6Xl|Pp8m2XT͒An]]=#m/m ;aڤނ9x5]+ ( ˦g(N{Xh)]KŃ0wFjQ;$^&+*A2-P^//h9B:IښbY +v)?4ՁZdt’NbΔ~YLN% #[r,B4t3,' U\eq |&| B0 CAVR)*> 7=!*9@TdrX<ڊ J~L1<ȥytX]-ttXҖ)qmoW8HL 3fi/mcQ-/ '@_quO`ϖK!qIeqce51y#G,pr$$&UC谳mʰj$Q\"Rui$B":L$)ndM 9jbWܲG1VR\UӔP.G7nH2_~fX;efuϵ`̌۶f~Yd6(R\ݦ&9θٚ9$d9 J! GTc0ɽDZ,EpM(5&j5ZKJ́F!a8%,+|^ glT}" ;溮* 첔@Pt9$)%YQ#Y. vy)@ b{>{X㻆V%Ctx/s-4?R(YW2%Ѳow u_d'Iz;dĽhx͍_'daI[\.΋Pj̞a0E\r`pTـ0AVY}KK궈E `o2z8} A=b.Tn1Ӎxr>oHbl6I3oKOXm]m\8Z+{Kp׸cw ( .S}T,L5: طܶFjwڂ r>)O,IZ C .!%_Uy6sh)z3$wZQB G2&G[3<1j9T:bCtD0iT\a[ ^nqY^SwZ[IZ›{JtڐoN?=?[J>{qΓ}Boq gQgZ7p2@FlVUH(`d8ߧbc1q3I&2+vQL-?@\?*4cPkn&4j,ttxF=XBkApl$8n$6DvagŠg;C,JV.2t 3dӽ߱Ǻ1$WM;vUR5W\֍n_8m=ՙ@̉@4pct _>'RʷN¨bY`F %XK'-Uu rdýŒݻt{i3 JrvHqzg_3:8oSsLfv$RSoe6MdX!{țt`T6/pCD5!_kʫ&n.3| F2+?qHHl*+5s_~j (ljzh9LkX#]ߚr+ L?v%v*@~2yBQu%.ȳ-&K+=יyr$!Gi-ހ[CB?4ip4}TKz#pi Y[G>1RU9BSf_A* ; ֥b,Ó)bn&#w[ROB_i%Q݆-{}bG֜LfM%R)Wi~ <}yae1mtՒ,9٩ I@ּNzF.-VRdΕ+ls$a'^q(6OR'3n!* Y'$e٨bl zͅ6r}DeӗoS>%ZNf{U]7`IxX^h bL6@X> T'3xrUnF5}0n+7GXؖ߃-f*|/^ )4&lcS'BMff`3 vК`@Str,ل@AiՂf `ǺM '7vc*Eh-k\í>C"C<䤞msXєCGq 9SPzWN&na8N2J kdQۊ{&(k|e2L³"K=,dG/oHmע S RX:EeSj&(?')pVK<6$Iqi?+1@:W8rP;P/sѵ:T6"\ Rc9P~Ԕ5[(m=Nl^W= od[ /?H0.O6N񫝠Y3W40Y J'4 I;! \PhQ) % W琞pQ>-wF~,\ʖX 9XQT6w iZ=ֲ hhuS[ܜѤ)>9UVh=_H-u+X%@}ah- ;;Ve/5RaI I-@4pӵ2"&h0&cL.2jE:rd#|?=cgZc P.xn*nMf\ = SgިaoX@<0%b3vy7t@ R~ްXJ;RGrwX%]u$ˏ70RҏIE\ G!ɑථ@Cަ"ڻ|PqQ`,N!1ǩgX8Dۀ}[{Mg>׶+?IU5ap`01^I@uCXf֬x耫rE {.P$D*rջ^OSzۊ cy)*N+Cۇ l aA~YnokJÈ/ B ,I _T_k{hQn7Z 0ؿ{Ee\V]b^oY~dט~r^|5Mcm<ȅ]bN+R!ɩ5Y%"Je*J$>ʼ[M t7`"KCF*k=6ҿ}댗, 37Sqt@)* Ѷ$PT{^1Iస*_' H?,[s7g|3i 1DT`!3Z0 #hʑJJ7P Oa)CY`^jaz, J>ӎ``EdDl|8vr/k]ac`Q#L MzNH,T)Lg$[ % f?pk7IA$k? A–\r [1NsYW <> X zVr|a֒h)f;BFJo0[ą:V :HgR / eK1N]l:2te Ek/*MR\xѤ)ιQmCxk0'n##h7kS@L( 61LE;R$(F3r>}6`iU-fvyt`YُK&cV\RAU7XTUhhi/dÒ]h*T;v*/7ܟ¦Z1pxG 1q:ܤ+Mـe-&r.&ב +$-sQQUn~CBݑ@ ן.P(=D$bd=.PX>T ]2 ᯷~|{e19giDP˴`9!)ȡV\Tb6U.#D"{T6G\ ǃCƚaUʹ/Q$Z}r h0”6jO[ZSPuXfP'?ul5I[!i/0NtaJ1H~S2_۴۽Lgޔ!?پVh!}ĹܦiCe,nut1t--s W;n:r+ u*ޓ$۾sϙ8$z+fA*JZ21RCx ? I\g^nWmzGJbtsɹ|K;0J w"!+jݳPRh6`B5}6w~[N$(J"kaj+K5hRSeXd&7;V$ y_y_UϿ~>`gr}m,lTdNSNփ/~4[2VnWm>HBB1p7c)& M$IDE_ԑE2 WF*)RnyUʭYn-МĉT 4橎Op Qyδx@&h.ӽ29s Www#9b=SwD+pẎ lAy欍Je4g*n:RJԔ,]!RWÑ Rɒ׵*M2Jk2>N6@T^K{[2qT0qG4B;djjD_AubCܾߊhtD3mt%ϳlF&VΆ}~*jǣqx&6"nac=;l<ˠ5(f# CSD~Ɂ`B gYy1R q2ZW_Y:$wC2KPx:ESP`s 8DqQȬjԁ{C@3剡nή G(I 92X?̶HHF6 (} UMd@]ք,14nX4oؼ7⻧3hϿX`_ǥOO>H%'>"jdITgdb=Dy #SNGJFRJP]hS8щc6ȯf#+J%OZ7KZt$"/lZ5 mDE3"òwsJ*̤HȨ\TԘD9t Rݔ8d>nX$'+.F ^o\:!9cy`9*Z :{O6U1Cc$v[m.0OɕaKo+:d8BOo.)Mhެf7x[99.aԊ$z$N1'A*eJ!D z#o ܌J/sU8Ur {].t",:44a q*5.m%M} :9{5PNp%'s«*bD';JX W[p"3B 4HS"+ork`)чWpo83LHGU Hu#|o2*i|J$oIց*Ϭ"^|$N4Tl4TLo4BTR$G=%aSYy*_V奮A:)E7.%PS&`Q=O$BS<5_׎&s5]˲ZQcsq|*tLJTM5!A4kG^4|:T|-"ibK>QJՁh#pJUVy2PXT~tw7'}QZlKR%:`7F.V`n~[ Wf=g wɂe)SV~LmƾrwF|ۆ ؝? .o%8>C1t[+1tDPa$bUSt)A4UH3JR F$j {..وA%0,:3rxXӪv[ziIcK.@Z᫘ DLir"hU@Q*Fɰm1ir W&bx3<[- $(F 9n:nֶ8;*/Ie@b#S16!Av `V]ƺ]s e,|kaD-/дZ5qYOs17a,sb-$^г7Ԇ=ˋ$ ^`9ϙ{RUMɠ??w0P09$W9\TyG0Sj =j( vl8i%qȩFDzRu]h4VUpX:>Vqmm~~" eE-Q2hpEt[cmrDjos]u27(^ 6.{a\?fVz%!c>t{L /47?ۡtDЊP{șa,~01'S% (y EJwղ.h䁫S[ NOUkEKUZJ w+'P0Խ9M<ݞV9źӌ"eL E#;o/i9xm[j !|"`:%j| @I9~_}Iuu&:ie1MBH}R q.,*1m S[:&ݬ?^ZYWaoȷRVeHsܬ4\`١BtQ7o$VǦf%hXԤ,Y,4DFp4׷oO/kb#7yP"W@dw*YUxs2KWb5CJ-In,t )Fv ̃NÜzgbk5鐼RD-PV\C-֕6IdOW r2ap'L==eӃ=P|( LHY>`O.c;빸dMn))RW:cs z-߬tHM׷>!Tnk4^ӛJlƵ!~f5=ߡJ LH6 H9[q_7+4gثvYpK(rF$[[C)!{#V?9k5ǛSiqP0E)|؆)\bŦYGUG_!z6+w1C^CXN@2b/q!/kuN&Xu<ѩx;{6"YKZf)ݹDf.b#Xa2n@|Cҋgrh`حS68?热̦oOnL{v '1`P9@Z{3ufBianuc'Dc0) < .,Aܚwb~ɔ+7 ثGkt.fm?SxZnHSԋ* 8QcLhȒTma \-^-rW(y9EJv5K$wzc^{5OCw~u]dFr3s;0f?J]-U6_.%K]l5Fbе5S[PJoU7zkp.Lnlnq6'K8PԾ:RkjWIs] 'tEjFJ{U+q˕(qH b+[+[N]ίG4l^_b:>;hcT\.j Y))[ntSu _mt}ʛ=f۪Ӻ|zPʡBsOddd׬ߦc>/M+=y296EnMIbKnZ#9H㫩:5p%IrR7zeFۢ׳O]ݗܭ=衠?~<,pD vfꔭKW:cu-Vjar%VT8N~`9_WMZ,섮ivwŴo~݆w ! f1E{דuiя|dM~tQEReꈺsIPAq+HmoQ  m=tap(V,A2RwY- -VB:>cpQVYd="V3KjS (Z"- |S$n{ۇǿ?28#|aCk:-β^ל!&V2ѕ:p+,nB)Y%-;kрsu! 9+G,SLR$[+$ %,'b{+J鯳˟^_^|2\q$Iyx@5y#-)AZ/>D(t,8ىéȖ z8e:KmʴKm-yehf7kqJ4+S9{QB8=[LmQ.9(Ir0PI7*LNg_|yzzu|uz{Arn B/Mםz(5\ 󲦄9Bï5>aV^gnPǶknZsS~t 3m1N}.lÏ㶥 xtZzڦ(Q^*eW>:_5Qڥo03}}lG_/< {ٍ`G<m/sG F|SHw+PEL(m7Y<%gNڔ6uÅF; 8C Kl)]yC傁?txRܦ; q0 /2̀+G+r\W7zC@ޥ@AJЄ?'sE$Ք(#oe7m1bí"KTRc:~q1xr+4.DIH+]u/E ǘk;PGyBi Cw>75!u@@-hy/$GJHQȳp :[.;@ ,>Ǭ\Pk~cB1F0.w@w[}zVkYKY {*l5!v;:JZ_\ ;F"y/`b}R ^ec# @Iv)/ λjlw𢥩DY]a3ޫ>G{ A!p }3~pWWn$OɦԸH[$x^ 9!`{c@EEkz:,Euh͸3=hOn1|$XK!V-wdyyT~ h;],΢}mtƩ!eaSM`QT" x!HHOJBc+H)d`%ó x340031QH+)JL./I-.Kgzt&=>i +k|BԦ'Tȋ;^ Z{C?-')ltw͉J 2hx:HHD'%+:,0XK r]㜪| 3QxZIH"fL'prose_main_test.go7܇}3k_1|!Rn?` X X*τ<cUuC!%;xIH"fL( ZxrM,-/JMMRH̫WpI-SII-sq31F"x;cĴ/"*DzWX{]9{610E5m}a|($'ė3ԭ~7U'6-+,ƺ%%5@uS§"5Ӽ*\#`Mjm~s]jhEIױ1ZWY6WtUsޙwNRn~Yd5ϗO?mg&Wr3ퟐt}Y*QǗ=4|Bq A)W46I`rUl/{c{cpœ2Kg.:8%Յo_O}N{?wL&+Ɠ[tܺ~B= 5-ʼVx:uC]s~Jj斺(]~ȱ x{VxC9/kr~JjZLSExVrdC4kr~JjxrQ x͝}oV?3R(i ;I#FK[ %"ep?s%)Yv,0Er^B,=}eɯls/GU2涝mNd#Šɴ";գBw;KH?+-M~N< jf~zG]05\dƾ2-ފq`_w,e6Ȫ$벜M.*cluKJF, W-[E7L^2a/9ftLGOt.j)Ӡ科2Q7f+Y6fM ؓ +v]<|%XҤ1IR{PG;ǟqSOFlØ?`d8} [/zy#4y'l`8A8\C"k:r?sviw+̄w ҉) $YRp::,L|#vGKܸHc0jtdGg_7rH [2xj?&慖p>ot&l]q?0}/A#'57K-ZYl=}qGIU8he>폲b<&=i82w)&b,FNW'3M^sc ouآo{vexj9BE~ b +|;h5TP | {ޏ&s?H )L3@ꐐ0g{p xPEQT}I5ՙGΛNн?ѷ>l'N$chf"B+̾`A m( W%ݲx6*hl F|b-.!ёlWs*˄45DJADqQhu63ܷK26ƗXK0D3$X $[S=$Pnjr-Ν3si͠+-0dh\V M,t򺭊~@/} *f˖uW0͚v%u<[4f2a:pV*2ovZČ8gWrA - =ƒˑ JwAONHX qn^ X,1S*RJr%:LR2.RҬSɍnPmݱ`613+"RGbbbcZ20{Яӱ{S&d>oYf? p`,;-fULd{=[=2:[@-L%arLvθcZ!a1h>i hP>yxHH1}N͈.Z2:c_lTD0ꂽòA$ݭ3<}Q֨T%ҷefoI}ӈ²B9JI8+YbL&J^!ķz;cNE ʐ#W8s¤4K(f3Q?9s7тTT×Xzz{?9$:Ip6Dj|ڒu=}X*Xvx%pYhdvN"_cON lQ-[c_͕V$4.ɳgt?]nۏ" t:E\)M-X)J:|N? )nFp&:_d8I{|:y hz4J߂%>ozGST7 dnaU֑_L>ICg>`)h. F$?:_e"U\P?P#e!QS{o;,UDQGQpvq2$0W>H.FvqǿgU6/N7?{{ldL1 cnm2Szg"zrQ)nW 5x3s DRL駣evSLPKXO1I{^w|u;QHKCc?˓c!wX%n(-["R?d:7P*SEBTxn|D"d1-sDܩ[6[eQӮvpˤXWn%,{ |,_ b]m,ylRCN8G@xGŻq`QfqLbdM9Z餽7C~xw,zY2^xJ kbn$THBǀ1UEdYz r)9i5JқqYDb%UiTQZV!*2ٌ9)B!АF _5o"gyxRmDn >|]>ž:RiM'%rkp@cW;jJ.;unxZerWg3V <,.Dash?nI^lnS/r( Xؠmsg<~͙C I]#\Vth=׫jG锭9ZW"{z߷ϊY 5:AAVď~ZKm"h wLGy$Ӡ1;V4&Ͱnd\+':.DWB2Hbz>4\WLF361Q*hXjw_ހa+xL} i}UY(ЪR„gj]}Lc^?1ZQN߷*cѿ=(?McQTE9LR0ws:>p_uGb~ Fi/ V͉q|tcR(Y2jxr~H N!6Qs|- -rϷW7\pȻon۶0N6ʤ|;վ*d0$|WP"TȔWJHb}vZ(*W§[QZXSf_5r|ED?pL'4-:&yQ{HK%5+!7,1}ʓx+j}HQȋܞNeV+r?i /X'S+.5 z`v"6"¶1[Gxū@H 3LW0 3י֧M%%3X s@ Իn $kb*&D{H d ԾkoyIdC[k67CFvou )#eM!Neuȡ pU4:Zp'˰|3n֞z{Bʚ;q7N |57r$@wRaϷ-]ݩxӬ{CwǬ曞ٰg-Xޛ^BƆ̉9RϪkU$RM#>0M; )[6VP~LYZϰ|+nq`5ďlv#rv՗b6ગ:dJ4峸%Hf9{uWta*I-(cRU2$ǻ,+֚l,%zwj<uPסE:fpb>҈񔪊D2aڸǐ/P|Bcz Y  -od1мsn' V=OEUo=.V0OS]SfV`?yIl=u~@WȼIf[msjiaO<89O/5r=B?iwGZU|T _=`}ail3XHX#\rT9/( +f_Dǔ>WV++>oB7QoYH;2e&oCn5f|dåȽWe8*uDblxGpЦn_؎9߿#и҆Lz+4턪b.9^0rn2-ֽU49Q _+_9W~pB1|^ TcճBy?A(r+ZϘ-!xFhyWE~?#aQ 5ZNHO42p^`+cSQe>&UƷ9 7zevDKДO%b]'x+Kńvm Uܴ[95/TANϕ3Q‡ʽsŧ)ҤyfYf"eg=m3I*& }*!S֚m#YOqyT[ H"rH$_q[}#N^x@&ZnA$uޛA6fpfK "f%!`닅i+&^GhUXKgr ؈.s$H{i쇟Z-|[%SXӥjN)Rqȇـf{+v 1t7 7λnc ч~6pSl-Wz |Rfwxk zV3-i\H-v'W,̊jH]4c@KAҌ 7u=lsf u~db-4711 d~GI7>':Xʗ_q)~Z:C#5c 07E6Pl-;n\d\'V|[S AƼ)QH;,`*z(~qF8;NЀg(zWR657w'=X%ױj]^MۮO͸7iK-lgj1d!:۹i,BcZAn^36^17;B:{@2v|/OCaM$;SrFn8ۭ)]#!KGˬ}~bJtE'}\Oi I,PMtU\:&;~e !zXO|ʋ>×tޢJC_XHk{^;"’`kBb?&v{udCqQCC`[8!]~p~g-GQjT]/jDt9.rR4fn C$arMdNhKN%c`DŽRֶ4ɈUXPۆ#ȧK0CFJ1q_$]--S^Y8'e3`]_(vH;-w.2쨸}}Vkqcx JDNJm=pѓԶٗP? Y@JCm6mi5VuNǬL81/V`X-Hī͖:%}OҿvԛEly|D#AC/qWo44\!b]v~ rxrVq:/aiyA{Oz6?3%:?"@CR陽` G:gMHt69eVvݷ#aܑd{nlze;/\Tu[XU>azC/m, ^ CL5GG0E0D ΅1-L73:㊙?Iîۇ5!XMY>6lD{lxB6nusjչ?&_s.r~]X5!ٝ9}+oxD|>İ-NwO)ޞ..Fqd`W"&[t#&GKOq?r]źHm9"|??+(> TO>Ї(Esn6F B{w~|9 |P@4iCn Jr2 yJT%MO.*X]\=E1X a-נ1#P%CPuӪ"d ,Bb2(Nw;ś =QdIx* @5Syiе"\;*wh ic:hV+5U D©@ k@nxIyR~_=B_feN vB\9Mnۏuۡv9 y>L$TC֡Lx%GҕvHH&e6C\- S-c94;$5gabf| nz^a"X$BaXJ>N 5bEf %'M%3Mv [響F5um9Dakbi0t0'=14`3 bȢE%!&CW&˫N4Ml"+U UJ@p~t'q#pUvJWu0X PpVW{'σAFZiX^TORlɴTilB٬+kJqTm敆wYt5qvãG%dtF8u]yd=~!M_Fc'ߜ$̞fuzITk_\wHv~y{ w}(+w#_r˜|Q̤_MNIBWE۔ 7wT;~~5wj3E+vns;t{\X9Igw <|/A:?X|i7^8זKWL*tGV'Yi: 8M!/ g9w١n.g;_!Bzf4=塿ocxTN0>obj )[ġBP ġg7&vj;K!!}8P@Vg;U tC2vGȳpAbfb]NMliUd왉u%+ז꼋 _ilDoUSVNsq%LvR!9 gh+* O3r@YM?z),Ȉ?8 ڄ9DU- RCBpo:B y 0bU+K;$,Bb"XwZ! "Zj`b`4;kʡu,. u-@k5FfV/~yar2l4s 2e|yrBCN9ݏ x}Qw4A;k2XEtLҠͩv֣s 4 \+aGY [_S~vb x䇠d|yF?&a{=]WZ:J3SO.rqqv29)R_&C;<)P;G㡸&!؄M@w j奤(wna#0P.xLij RHVRJru&H]zAK$S4fyY dz}ʠAE`YgcDPMћ&i/9<>0U;L~W$ƶ%l38!!c2i>o18kh#"5B~3$xkCs~JjLItU9xbdR01d.ZC_V37kb|Ox340031QHOIM/I-.KgہeAsdlvH}x7 曅~e p4J,OOz5A'`Ͻ?Nm5 / sx+./"v׳:]bo),4'^Uk xVnHv*mR +.J R Bn&8xm"Cw4).$c9gjtƚF&֣V+Όik$#Gm-v ǩhdlgf7n{mskڭVkwΠ{6G3/Ք:MiZ9 $N{G w:Ě)\X۴T>4w&ABYuL<&NuD4ֹE4vd ؛(yBHHO~Eĺ>7 F7 SSdd,o$m•:b$%Ais֦ۑ E]j;$NPiyԔ:ZIyӓ6-ZATY4V.$m-F+&*lۭ Hď^Qfl0|Vy%Lil%VZᲱ]u =$GoQO]Z\ܥR>)ГI@8&1 tѭrǮCAn\i?<a*j@07ֈ?kzs<5`᦭faG>e.¸TY!CsG~Hm_wjS*\?m1RJo!zOkۭu쏾q3$ZaFjpE 1!{ JP껀}ZށS}Tg/aU#01;/ #֦Iˈ7&鍎/>\ Y*z좓cf‹~a`6y \,pR;56Ff#Ob3VQ-wi/^=4:89vPlYbw^d@0!D6 H~o DBB(#_֐|u5=wڠ3R֦J5X\VA3 2n5\7A] ^>DG&(Xkl\X}qG7vP_-Pτ .5;m, nT.5'x rR–X:_z,,@CXa` w}q)ȋ .@~fC-%hV`/l&}!]z B:y1=é`}~縈{|5uηKoe7z[E=\l ,3 >E7$K@17Am8ArzS3v03oe0Ա_^45SkY/$ϝ^z+|, "i%3b "-!% #WuʁKf(* ~ޯ(j" OV)@#[q}ТVZ ymTwꢄݞ/?WYl<;x=j0EI ir,o56BB u4#["ohВ?tX="{3xvx敀BEv?(]ݾA%Z/NNcgӳxt<`zC-+'h#6RejM^hhu#늒G~xZP<(A-ez_Vo!<,.}c0w 13 ML$R#vlY{[ r#-xuNAxH6f(SEJDQsydDA " )(RE ۙ_OU Χi" pA'[( 2]STBLA>vUّ/4A!h#M1PPK( 8oifa"Kr|s I$ _XeI=*O) {}|URdwg]vnhLj=eZc4n'§(xۑ3mOٙY Dgq|#-a7ax;J V)ɛK^%$'x{xqJFV٠ LLP NGܦl`V⛋2e|ʕd*B'Y"kx"I~';s~Jjf*vd0<*#F KxwHHy]^O 2 J+Y-A+  U5cG !X j~!{/ay&Y$'5/x%HH % 6ZzPf 'pP  $5nx{t+o<քlNbdM̫QH-*/T޼"5DGa|d<!'g-g)l'Oo-J-)-lwG3X"n5x;s! b:_$7A?x^HH!40000 .hanzoҥ[eLLaGxn!k-;za|ڝ@@-UiMSe4rtYXqXc+c?zA*k$FD]泵LB|W}ET[fؘ0zvSz"IPO Fp-fV0TJd KchA$0[<]  _(ZE{b`whѨYpڂDvTb{>5$BgUW-BoG 1*0`cQ^%ímlK#Fx>Sԁ*{6_ 5y0X/" 3ƛlq#ݶu츊B@D f;ix!?lű4kB {~Lk `d' @9ԽbWUhfUpλHwzfpwr =Ax\cDsi_Xtl鼼mMWO`z!m wr~߶Tф;KFk&fNL̩8&n =i/#Zטs<%B uXIK@/?.Xٶ brb/Ot)jȿpہ! k(I{vt(JFRmE( ڟvm!S!2kEd5;le$Ͷ{}AXx>G>&'ߓ BJoo1jsy/ |&|Ckkj"L胚 Ï-$%ஔu5%B PAz2̰cDÂ#=nIQ|~O, vz ,;6c|v+; hZ`4 E[2<)dߤ7/{WQk÷οM8,םxJ` _x_ũg:[?Ҭ\vr4Unx$|M-/˝{)s1'Ͼ#<sJ= f>jN97"|ݻ@ b=?sV/yaqO7Aހ:ZxEuaWo ]!#R"'?V\l~vL z"x$EaIHF[F*_FW"_tM@lOL(B1+*ۮlΒN~z/@󼒭Iz5o"g{T4AB1H %dh5cLnO36-%pXc!v_ܒ|tX@59(}_fqxB.tcuyizy㹋۫ t&UWo;^K#a8Tkr72Elf r>FeCoZL_JǴ2's(1eq ݲ$=W GkʔAMw ? u0Cw0AKʓlS*Kw-a#+1m͢a|UUxzF iQ=Լ'+uu4|V)"!(땭!eJ&Po3uYY/x`nj&Ak4rFNIVَ&MH be;M"WC&gN?)ѡ~LjR^Htj[]ꖨMczt@R6.S:C)qYŧ64F ΂94+o!i!1nHڐ"~WDXWOꜵS!`<\nb Ϲ+ƍol/(7JX[l47WZ֧ya 絽yEisi6/Mk[ r?$O6gA]&?lhUW,* ^o-O AF$FLZ0= N|fKYo;c:{˼6$j5v5q2Z5#Bԙڢ[iH@ /O.6X7{zS Weu5/&#ްNcTC n%]W;!3,UzǠ!OYy B(#Еg>-:#kP|_=a/l푲KL{z&z} ,XT~fиWo:ڻ\Ј_"_Wi,G>S{R-gDA}U%}Gǥ'Jl'SLݱdc2Ht@^ ϓN1>tS0 Y꫐&/[a~6$MB HJ69KX>G{cRQHȴF7ZIgFe+ }K!kɨX|[ Kr PEaqX"?3' * ^kI1<&(qX$㱮>b҆Q5dK0<O0L`N*dQ rgcn  ]N2dl*JI;(v.Ft;3%8[e"-)JR`N;ݽ+'c僃G@K5Stjv &#F |dUTwݴFxBa W>qYެW[Xo'>ISGn:C<"dF{k.c0 Z`D {Bv5&^o0A#3$R˂+.`JC}ǽ5d8V՝4dluḷqvT(r(~H]N6Iwݓ_,{.4LZٍ.o12(OΔA)'Hk /L7^42%bg?hb[8b%k9PS6ԍ˅љ~WoI= `M!+g%+&n63>%qp)9BppO$ƴEzjqgr sBAƌM٘w4)Hizqf@wo| ?_K`fhƑxR5|,5/{%udp-c%y"XDO2rԠ"oq*n^XT 踓&Մs"L3E( 65=}V[&o p+hCB6 z5|O !;Hl 式@H?Z\'v֓ *©՟3Ɔ#7q$snZV>yr,f厂HE p'&ԃY܊%m8Bo @Y tܠew놯]%b}vg!tE3#9_8,o,m7 ^c6AZG2=c: A)g0zXcgXgPJ'ԚD|^4E~JxEDӟT7,>l^^-|'2|joN pA9c`t7= %3d$wmߠ$$%c )򚓔ѱ{&-/㵤7u#5;?l4 pe/}lW{ҟ[1~-teޓ]%{V/T3 0_Or2L:zOxzQ 'JBʡre60[DV5ظ|,9J #?ߢ,[FAt@!GWSk.ig3uO;Xph, C#Q Av" N uOU'TjZʊRiC/?-9Uk;},GTWNj0gI3p;S&4lNlMT^ܫnbl(&*Zx$hisw5%~z uwl#Po̗|{:;.qlaGxzuC\v;{Dx31̂df]\`P*1}T(KJp$I/xHx340031QMKg(>ϿwůXWؿɼQmXߪ\xSMkA%c2jD|In̊HBD(EdLn7&{Gx<{z_aulQ~Uի}1yng olȲ05*j|}4XܵTveJx;q sS5&encks 'oMVSS(iN>h'pqrqekhnO28q&x;s1ͯt46:WV/8xeCAz<]rjs1)x31̂df]\`P*1LYS5LX ߼c̖=l^- dNa!´Y]v#+Cx&DCV 4ejך)j  lex31̂df]\`P*1/}[w' .x340031QMKgxѕs_iSa{lxk]a]71+lukNixHDCV2~K3btZnj* I .bS)mDuNd xJ!֢x31̂df]\`P*1lvNuОVfN x340031QMKg`6pljou%> pZxkmPqF79'+3oĬy=-XU gSx۩X}ba dxx$CBya~مVsƓ(,!DqVz1t;;BbL A %U$ pViQ"GN\or`!XOH<*P`MV4)%[=Ɂgb m;(y}鯙 +100644 sdk_test.goT#6:g|`z9P5diO Y=sVtueUEKxˆ v*ޛӫZ !YxMTAoEV$-TUimk64%!ISMDVٷޭ38o" \8pሸ _}{}?=~~[3í ;€ITJۉt4"0 YV` Jj: #ek_6HRczid,x]@fPCJ|R)&>>ܾۀ,q}ں~QN`:mS̤hT)GwXKC:7qYysHyJ$ѩ96q9 [B'O 飐r OŲ)l$ɄҥLp$njмW0ܢd.a~y~\,Շҙ.e/wW~թ_gm`X[_s2PD#mߕ`:8}g4ƴ_IhFW&mX*ʲ]:ornZ`]{f@BS(F cõ1jml4ܼӚw/ηLƥ0xDAKטq=/6Wa0w'^EE^SUő,ҩ|zpڻ6jD˵+ap [4?E|X 틮[TB69㏷^ׇ:RX3LR  2,RV,5Ǜ@Qb֧Yܕ o\+ԏJ#ux"JnC9nb^^~BrQ~qBIFBANb^BbBbNBI~JbBIeA*l E) _6'YSR7SeU-xH>>;=˚ ɼQU8100644 sdk_test.goh~Rt($ՖѯՕWk# 5x[7]3)V j.ىV : *J*$fY)&De&TneNX]6d/J-)-SKM JJ/IZJRKb@b\z& Ho, LYLxs\1 [z~HeAJ2%z~@JzJi`BZfjNJ MD7;bd`>ԡJZJ ړ}4T'kd&ZF"I9%VZMԛ쫡\yF AZJ Jz'?2\ ĐV-əV 3 Z%&LN,NU(JMIM.+I-JK:|+mCļJ:6_ҿ(3 BЗxhx4͆z;8txU>=QCx"j8tu:oɳ td7Çv7aL7Ν$5!: KGR$c7xۚ<%zF7]<Ɠyعs5sS56 xqADԂĢT ͲB? i%x{8iA4Ԣ"+[D=̜ MɌ,biJ`jH&g?Y!!xqdĢbr29 f!x&==0`Koܕ;^ D Zj/xq [vjSRs6 ~\VMt&'q*m2hGͫ]xfG x%==sjWGVha^OGhpz-HГ ' g72ur{;g̃tq7B}ZF+%,(,Q,k"2VV i\Ka\@ߡ B@_* 3_"(@z#%R6׫"S9p#.qv.ݮ\v_anxejeFp%/-xddURgĕu~o+3 F x340031QH,KgXg4%'>[t%UCd7b!_:TU%`.<E"'.*о( PHI,Idpyx_cJEsbC̯5Jx&=Yၶ;I%DVQix-J@ tV 66+fb[wewr灠x>I,+KAp7g3o~ϯqpqyoRFɲO+R*6\H"0VZک۰,ao#>+nBB@Qɀ%pF>ƨj%Pwܳ Oz 9 }Rレ(u *VKxy߿N"Aח^6?qdx?<<x&b og̶1xY# ^tf}Dd݋&,sx=Ɨ!),&NivR,WYuXtXZpQX5xyY ɶ['p0dl.NNZ.0ݼm:5Sxs<< X.DӚF:\iM㡱i2Džf0$PkD;.~㳾7+W1׌S&;gb9x]JAE"II.`++$VB`gݷ֙03!)l!7V~.,9}wR{=``)xbJ@!v8cBl"3LNe1"!CZC))d"؂+τti_wá6 @4Rx͓fUtM%fuko6`\kʹt֡xg>Hkg_/]Ϸ6wva+S >!)Ӭ-bFg@3nc&#";͎au%9l{u@->J "( GCq5H%$ $"5\[f$9*C$\K4g(w;f(׀ΐ?rBXfW±5$ Ӥ}Ř!( # !A;hMŮx˥UGc k&!͔˵.3>&*fSivSUx)]P)LeG̲) mX<|xW>UzU__'5CHr Q[2~IeIИYdɈ̇pҔ9U DAו>O'J@+\х;  WZ)iFh>DW!tArw4(OWWAh~2lAJħ 뙠^ ?Ccm;G.hoa=,? t;(Zݠچ ʻ#Y\UPEsbUX$\U1-Ɗ$q]*êUf]7:M?Z7iвUxĽP5](2JS'L3ݽXwmB{5c4YQkj%*ܘ&G]ku+.h}4EU!Q#L'244uzpjNф{3Ѹz zMBx;v! '?s,1uK S-x%<;W% '\ Tu8h x;vmfz y%y % ɉyy% EEũy% %E%: 9ɩ@:7Hg敤k*d+䤦p+$*زqqR<[X' o)4u IxS;;+˟kRX9WyձP Kvޥ J0 D4KJH+\w(  ${% xeCf;xU<\|zZZ E \73*L>b)ɕYRP%% %ٙy ZlB2RRKKRsSJs 2sRuK2sSSJ2 RJ* Ru323&[)+$fpmNh۳2.7A*xmSkA&CwZG 9HMnRb/Q},Nflc*{6?et|ƈiģ&uhC*6<~{QL:=KE܅mE)1HVEةBZpXضhD:ӂ:?MdYe:%" s}4'۪MȤ9&[#&_FPSD'7 ufπZ&.M⒢̼tQݡp}\!(n:99@dHviBQ~yqL^LI-6ߍdj xddR01d_\L?f|l~hvkz'*1Ax340031QHOIM/I-.Kgu)$s3_ֽ1`!DaIeAj1HVW<V͜%YĂ̪T U04|*r!lרs)eprSxS;;8zZ |N|P8^l:WB6cvD=q$--MWl $""hnSxk}eş4azBxqR < E% % )Ee%y Eiũ ($*&($)d敤%&y i) EE\ i@%y I% I%P ٙ y) y@VfT"D T|yـnIL)|BMD6.؜ʲV-f?.,0nd;;f0Ҽ"Aq>ڞAIvN@@nX䱛} $6)!ndxk}ˆ] =9ug=xdz8Q% ?yx?;:a=Us&'gғjt #3Lfz/2}9$ *xK7ӆ{ܛyR6Wd(2:lڙ8nx H>]5hxojg.g)_ |2hۋ *$a{i :G=(VL7 JvPR%Abv G f`4Bˆ3S *-gJr?ٿD,uLZrUS> 2I5FrGI2k;,ӹ{ΘBYdXCۀ ,t*<0Ю`lm݅G??qDhru@=@误g/JZXedzl>ΉUx}Wn4rI`Z ,J 9)ZK6\Խ3mN{v;(rOAWݽK sꫯ*oO :?VTSB{fSK]+͕&n榙!|yjk$_~ޏiUM8_9nȰ-դ[ TU9E3:}6zlO3~;LJ;ώUC_ң'uvRU컅n>uMmkS`ls~m#BH)ų?<Ax!5!X wva8AW;`Bͧ+\+♁Jej"o]uuMd_ˣrNa3<9<<[G$ΜNRpvreU yX  zH"F*$.S|t 3vTNhGoU( ݢ($_©Rz?YqG+&OnlU+[<[v+u 6il V3W?XmRs]SM-g (2X !Q>/ziAnw5ǀpk 5. Fb4. ?!MUVsB-9`JB_Kʥr2"%G+UUCc0a!z6.=\28u -gAIqLO|bCZkb&<(!Lו3-V&TGR)uvN$Q `xabf*g4ȭ1!%3ߥ'" +SS0ɸJENϸdh4fVXvNCؾ-^qQxv2?`}W#ya)%xXFX]PWȝg)͚EXؕG%I>uk& ѴVQfjfbjt]mx2[h߾~{B=+N7$鍂oquHoeڭ8GppB_3ԕ2K Oujh^'q?QX؆<(i RG3$AV>ۍvr`h UMv+.!Kjl؇Ы SC u}mX>h&-%q\_o"ӛd.ic <?{n3n$my`,X6˯ٹذ/w~D?I^x Jt1e"\ _%9 Ě5ETyd^Q2~'& Ӵ!dl!]7U]'>"ȼ9Pdkjo_o%4s`ʊFhxoj>qlby"o)Zyrk2PL? -;xiC_3cT&E0_1xoj>qlby"o)Zyrk2PLH~Od}o:^kuOx$ vzh3t-%-xx=AkAIhA E KbZ']Mi%QH鱇[wffm뷐7^~oDѷ}oͿϵ_k54'576xwS0yy=Ҿ3` i:Nk?,oȇw4򝍧mZ1] Qϣ㫔yv{e+L8\ph41BFiP!sP'h<ρ"(QcZ 2Owyd(^Eg] #=4$NA'6‚ROI`N*ACq0Pށ? <֡D HK*R0i2Wh=j2ES. 10"b3뷥Y9`Xe܋%0Z!?{>d$z":4#K`}`^$Y\/7@|MabzVXb +rI5Lބ2QEU:C`R+H"w{>+9{pq}+7+bLx=JA ha ;XZ "X)lvϙ9Ky!o`cNvz=Ddf87;B1 `|~΢Bܖ_L"^E݆>/r85$hS 4g*] 9 1֧ VBa'vnULŖ, zKV2e QA-}>pP[5zlo! ` K.R3•C) 푕PNxFbmֹni`ҙB.q:A(P[0JGT"Kox\~S)Bx`8$// The sibling's address is DERIVED, so its length is not something the // caller chose and not something it can see. Asked here, where an error can // still be returned, because the alternative is what it used to be: the bind // fails inside the transport as "invalid argument", which names neither the // limit nor the length, and reads like a broken socket rather than a long // path. load.go asks the same question of the same address before it execs a // child; this is the other half of oneU rule. if to := plain(addr); to != "" { if err := socketFits(to); err != nil { 6he upgrade sibling cannot be bound: %w", err) } }5$="Ux&::1Y͠ 'K%@?MTt<{xb|&|EL9v3mndYx&::^QN25/" D\}cxiڧ   5-06-12Pfown { ^%1case "initializepHwGj!xhL!nʼn'MCP`I}&8iyxmT=oGERN"6.B|@E! ru7-sܜӦHRL7{( c>{f~?􏿟 dߞ{Mt7˛z=#Kzk2.){LTq`h9_sV)}7xD"jkӴ5-bJ1{|L+j$٘;:*iNM\doyNk"jN TyP* )V[fd܇Aw.G:?Bk?zrwu jmHfcO9,O5m:#&C1!'4*@Wc j],/<HHIr0IBOcePċB02U=7Ns8G2(<{-\]z _Tj(?0z}u "=EF`FNvZRzubCF* r4\Bh-H n>)<?)!ADzyfLW) N7A4'9Dk)C{0&9\d^PakHC9Q4M9ǐ[.Nɜ k5_gz- ܹ4[OU諾iD^,_lcgRt$V4Sd]7Hǧu96ޛ3Ä<)xڕ0$$#~trBڦ8ETRbI mԧtXGQsc#<u@|ds~1/MSy5U:qc-Lgn2: > 6:ѷyV qĶfdzb0U N>xkjP+`"h=qƘZb+l4 : xdz8Qa9)wa~|*EbxȸqnȔʙO^3v>s![s˵ x+űD(d)} )!;E L 0Ve&LBxkj!$2#u'0WNs .ax;i' g&+ ڜTIJ- ERx9::zOk.c^Y/"X `Snƞ߁ZY}ܺl{IM:x[2!Fs2ML2nFx;3\ -82"xkjP+r5tLj8g-[ !x I2MIZU!3x340031Q(,J/I-.Kg+o:9w kh4\߈Kj9ne >VQp.H&AdUxdz8Qa_d {Y;x340031Q(,J/I-.KgP n^f* 5/afUvw yJAQ7N+ey?zi.*02xqy\b NvySfr+[̔ 4̼M.N4[Ĝ< [G| igK77)ܧv0l"47x{%7E 19;1=U*`?'O, xkP+,0#ϟ+b7w!6#Ax7 nل47YjmdLI③2@ A}(&.1x6^+‘!gpFxnv9K1]&{q񳑂g x340031QJ,HKKg8Οw%E#z80"+/I-.Jx^i-i˲C  x;hC£) Eiũ) % y) E%E\{YD̜ҢT ;$qUeqN\ړwqG}rfS޿L1M*l;Y̌d&§O^ɥ\V<3$C#M/;3/E3?-MV!1'3=OQ(ũ%@) L{nE-f4frU56`rfl Pex뱼iCHQ?g*siaCdĺc~[mz̼H, ~42x=RKkA&&$ E!Af])3Sӳ I0z`{C.<x1 /:UO???Qx1tVQL0e`ql jQgeXһ_.s!Lsj$݇10\k`]֎,WGrTrIrلDm%}g| -K+-f2~7`&C4'0&lV BMMV6c. |\\v϶H@~Qd@/?,C.s/S."M[{C6WT/X<ҳ"R+6s2ks-~X7CŐy6f;D{\QKH2ARAȨ%ۜ9h%o72˔ו@u9M`1`L#8?r]0$y`ѳ2V$p7v(@["V_ &m=* &@$]]ǂͥ= Rl;´'+ hBS~=J(S:j&̫Ʃ\& PMr3G\iI~sr<ۮ${/\L?p3x]R͊@=9^"fňwaFXٕa NͤNwowe|SxyQ<xL yAˬTN#it=xF=7[@&4z[`A^>/ X.DӚF:o$ߤnNy5Dԓg1Y͠ 'K%@?M'vhpz-HГ '  J/SdY 0P2Q p6Qi8!A ը\!!{.| (qG<_ws^i6^QN25/"jM? euqYfEa~N$PkD;.~=.$oR9m:,A-D9yMzmu_}oYv.,Ju-HbSF“=W% '\ Tu85(aB&A8 IxH78gp e;{A"range_test.goS9* [i5zPQBʜGx3i* FZ\ V ٩ѱZ`: : 9yՙyŚ@iE :  Ey pi l RR4 zk ˁXř_Zd-ax'¸_ 8J1x[1Ac~G6s3|[* *x1_c"bX<.δ"x +[ļTDb Mj.N =JR=l MTGBDMf^1X'[ĂԼbJZY0Brn 0*x]n@Ư4!q\zPHɅڳ(ή6 G@< 'ĕY'Qo~73ٝK퇍k۽=y,7rްP;o:@M ObOԄkx oa5a)R#|-(j[e7.L% oރ2$K{L6Ҳe\~\UB LR0"W4r07Z9菎.FxJ]Y@m&H^˺n &"u$T٬gO]2ysJe+3_`p.z3'wۯ;6_6FZjhlq0ʥߕty$IWaM[n(x;77oE״Ҵ] wOU!Z8_ R? wrx;77ozpI</yyJ٣Lf3mVS>8UgnX6z33m>ixw77od#elTTUjĖX]ǟ&r]ʓg]*м Q}b! &A3޳ g/QF@la]FyrEOdzb/TBgx[` 2xq B9yYيK2'?AB~f[Ik6xO6\)i9%ֆv3nTx[q 9K5׆7Zxb7WwVĢbҒTMM.N\z9 I)0.PgK*l%EyQH)R߳k8%($*Tep+'()f[)'g&)dd%+K2*nam.m YMeYcxeTMoGXZpH.P(=#mK$G>"aa!,+ꝩ6n{vXk? |K~E'~U=^vWO+15I=ɇmonu?u b6OF:;ЕRI/%Xb'a0S b @6C:a1&>Ơ6qTltIU3Q=z^p㡤+ ç74&ĊtI|.fHwhQe Ivp+B +7.6ǫw+?4Ih~'W/Sw6zԆ:)S9QABEqFR"Y9Ea"rB,jD j֣UYs4Crt 9#$#a "MKa[ n 3 ڄh jzFRekpm. UDTԄG8zr6AkWFny]֠@sl ܁\ݳKe;zT]T{_r gZHN/"%fפ[TGO,UhQf&0Wdm=~dtפI9$,:-=EUZ:h)FӃӨ'em0HpJZGRӝk(>Fzһ,H[Ϭxw1^?\* 9ZMɥ|GkYj㦰n"|GCv8g pLHIt)muU{m$qf>ţΒ8INzOնx{vi R9y Z''IO`,|ZڑKSVG` T^/`n@bQbnBNfqIBIFU^bnBD"?M!Q!-3)H($(^RZ_ZǕVdPMBqIQf^Bt,PYX4,L/R:qrXaGbq@QjZfFAJ jj 9y v ՓDZNv\ 'CZ/x8dB*gZfRjRzfIFi^r~~UbnAQ~I>XNxc3yҢ+[ĒԢ<.Nδ"xTDQb^zBr~N~xEeVxM) &Pg-cP\R^ZꘓQPRQr] R5JK445椖j$C,nS a;Xձ '39$3?o5W6O^x[:xBI,)by.x;77ojcj 5cͭyZGe22d_SiS= Apx[KiRIjqIf^ƀXASraxuJ@ ӘC1XXRzT x'{t/Mu}?ՏOoNuscc{6@kBPs"Vs 6( UypH#W= gQ{F;ŠJg1ȩ~sMEbwWq+xtxʗd,U]듽äB+SRj#?>wt8[Zőz.fv&Kn~/&f6Ѩ9 <9,ձ8%34 ,<)7,3=פ<<<'rDi\d-'( o;dZR_Pfgfg262۹°9#2*9,?8*),'5E"5P;9q2z)`j;dYX&V9[F&e8;Ee,Fd,2x z9BsGaio~WhqIrVeGevchdI>9͝|>'sGxP77K)ibling_limit_test.go>hv*5\|~CoYv.,Ju-HbSF³@$/ x340031QH+)JL./I-.Kgzt&=>i +k|BԦ'Tȋ;^ Z{C?)SrrE5ux&2OdC( F6X0o~.  x%77*l NOP&^91nx{6$ SD7[I12OxL77?lwJfufR(޳a100644 resolve_test.go@1`urwGb ED2!n^x[7iن.>d|Ĝ"ԊdM=X'k m~ϸfS̓}٬ *SiPx;{qT egx[l|6cK? ߭|@<7#NHx;4iBȇD̞ǣ'gYv‰gAxT7745S{]B`$lYEX& x-І$Y2 ӃƥPlT%SFwD_ h'bjxk<6A43?yxb77|* WioBzD*ӳ <q׿d577%100644 link_test.go!ӼJh#Jx)In$ L(ixb77|* WioBzD*ӳ < 0~nWs zF100644 link_test.go$^ Ywp =$ ()ˋ1x[HbB jwxrOFgxgYc F#xL77?-;߁o(G3100644 resolve_test.goЯo6fvè•ǧN;!Nx{ZpkBb^BpB~B{QbAF@bIFx@FD+[D=\O&g^r~^IQ~FZfRjojIF~{jĔɂJ{A V\ "YP"DC+iXx7|;NxE76r xTO% { ,:x|_PZnQ1n;!?xOJ@"\gҚf%؅P c:3qzGCpJoNbv=x~zmT^G3gFf2BnE6kbJ5b ab8ZR<rF'BЉ#'׳GN!V"J߸l:D a޿I 7$.TCU!J#hLM^.QlKYs{ vr hyڸze])[;R(3X>7y^EI;xk5YY/wuf&& ũE%%z ,7h⬄kEL~ƞ`tG#ݛeԠĢT˅^0;h6oʾp "۽S(7WH їɫ9oY(Vw{ԓ'~ƞׁ7p_g/"mSw9Ǣp;W(ܓtOwse=P'­X\s؆݂+n(]m}69"YӊQ pI[]"ߊݰ-i6̘(u_d˖%n37Ca)ÝUECDB.+?lly'7FZi|x 551w5 s&Q. m ! 2hÉ6xIeMa:"&87:Ī(pRiPDݳaJg4bZHu6vw~b"p [2 D09X:YtՋnXXC!bݼ (L ͲFJIH0AΔNYa4x( 3KV p,bxoۯs6zRڅ17|8BUHdBې%jy[d!V_y õ,kql 3+Ǐܬ%G&1YۈGQ4u_ܬPWl, ,Wos騋KY҃FDtl=<&]NnF1|TqVәקZ؝i|]v,|>:cLXH&o?U(~qa !X4_Y\ d$ĸi ݤ'EU*HˣG ZE+ڣSzV$҉{揝}AKbAo BS(Qh$H>$iL{'ZN%i4!\GY6Ě"SηC£xaBX"tu=S&{rũE`~{4YX1%73Oi4) uA% -j&*nidem2t6is+zx[a5+GjbJjQdWB./8hA:~5713g/[1cJnf lSbA%.7JΤ$)SxmROkQ?4\DDRi{O)$Q+o6fs7?/E ٯ'qncfgכQt0eDQ*vd[<3gi''͜8;R(e3b0 JLAh x9Y'|: S/~_G_:cS`=ŏΓ| Aّ"#APCYU6^E} hdFpiVm\ J.ɃseJBeN]SA/ˀ\{9dTF,T!bPyҤeXLSr-u Ιp6L5\6>ͨFUw{C} _"[c̄52LޏmGc*[} 'yĭ"pNC}??GeegQxҘxkL8AAhP&hZfRjcAANfrbIf~捲 2x;-tC,KnfnyExmHeFw, 'c3>I %xM1NA E-@i-JJjh) PGG;(;loVS3n)9 ,h}~N|u(-%dQ2 #׀] k2G <V)lPmZ5O#^v 4êW`zJRh.z!&_"{x}!hKy0vth i+EUxUB-pMؘ jA55f\8+C8γe%Nx ᥷LKF]}L~Zr!x6rFSaSF$On) Ҫڿ)+5xEbES㳒FxA?H7s1LUx͝)yfLi]p_ e x},/MIFBQjaijqBR~J%BfH8(9UG*'1/]85'5"2ْ5zr3%m#%M7g(ᩮ,:C:(HJ4/;/L0NԅYDE_ M6J}<;tޛJq½/\ԿV7"0sλy//?h\DXa!pQ *@L,^e(TZЖ5<ktLm'3I1n=#DHsIJ\[`B q<ɗ:`!Ђ$Kn84( „ЕL%k~yzA.Ht?m|flέv~~iݵv*OO?m~K *Ϫ[Z' simZcfQDi>ML!=S <l$;-P bv;R kw\2> {B 76f:Mi([vR^\*DGneء%F6 XهIeSJff^IF7㈦m Fٟ%>:}ܨ\Ec"Ü* Dz2Gr^V?o%)Çf}a SBH?E1&L۠aҍ24[F C&>G vVX:C%yyU=k`S^}dsIpJms7ڈw]nuejz'-%*[UX ?.uԜPYK3: L(R0smY6 a F6"9C[tDhlx9r\2_z͌('7w97eԈf8ۯ%`lX6n7>"rˎq3rjGzT%T^QQE^T#fݜL79*7e5Rĩ#dj* 6$r@0[" +ݹs  B%lCyXc}=ח|hM׏<˗_kUG TNII(6)80[a|!oIӶuӿB`j L Y{πqҁ1bz=}}NP`gj(oDPSS㐅{~Ҥ!EiFєkkNP`m 6S]Fѳ2cAr(FL[NGh *NqIϼyugt2&a@苤T(ˆǶ D@+jQѝ< |ƳnvQzɡ kÄG EN Ai2).g.x4@l5*lB}蒎pn&rbvς'd`A~Lt|޵)ڴ6r|JK~aj/(L~_=_g'x)&x:q\ !Ei%!5672E&[qHOf le炈ob,HU<[<+QXDMax?s]Fi]Yɗႛ%$ԻH#ORⴿRYAl+uZ$=K! '˭h7gBvLq*/` ͉lX ~NCFN> ldx;-O`?f1f}Vuxjeqf "T<͡ }x_7zÎ.*ƑK@%AUz8ϋ#(100644 telemetry.goD+ju jxV2C* ox;4iBHmUv{/vYUm-`z] 1x{brcyfIBb^BBRQfjT+)Y)&*%%f$&**$TN-%ձ?K*C xSMo0U ڜq)4%+o%T -*-"UU7k)kmA՞8s@7 C-ˉHq7_~-yrsaGKոPt/<7}ܔJ΂n6ira@ȴ2v$ 6!\qHG)!eDm(J}ttRk?-z6Exd=+x[]\4t ?T%Ls;RY ebG1CV %lfJM".(X~hRUQΉH=%`X,1C6z}bپFK ^dD^8Aa˝Q'+JrqB0Z:=@Q[! q7%Y18vn Έ!kH$5cc GlOpŤ@׍-%GZ oz%H7:T}O;ƁtL NlO0O t9` `2-LxzGГ0{:ҫ3]?Yui +x+*A'ȼ&;^a}czN`5cR6ʯ+e #]NSo` ̓RAUԹ+Ht'7G༇L@Ң-0g8H3c(^rĥrGVk}=uXw?݁N/i#QS`Z&2vs6}doq 5'ԥ8(A۹?bQbq87Ih%*8o0(P_ZVEԺE kk 7ua( -b3և\jeET.\~C )x}A J\Ei%5K2RRRR89A %)6fSHTY6̞#`|xkذqDVĴs8T"bxkL2Ei% %) Iɉũ % 1aM|M|]0dZN*x۳qV j/du/JL+ټr )xL447?-;߁o(G3100644 resolve_test.goЯo6fvè•ǧNv!2xT75"40000 .github58xV'z!Y[|B0ű!Q mW I ,:x|_PZnQ1"&x31촜b6'ݽx^Onw; Fx340031QHLNѫa<坚"G`xܶExDZyɢ,B%IEi9I9)z9I)&f)I)iifi)&&Ɔ\ @P4 RP(*K-RPVHˎF2bD[ ?eKt#N1lP6]Q/7100644 problem_test.go_!)-YlnpG'+60xUnA׃@$qP(!A"$JN[Nv=.y $#K+蘽ؖ콙|鏵#Pme` 8<=G L◇|P[l[p=$*4(H }4P9Xf}QaңڃtPbCdXCʇOaceu=A7(PRgžC-tqam;G4 M|cM͇/v-W6jNkeKuOozT5ElA#C:H@#* BaX!ؓ6DoLטBh, ,gZ3Чh7lØfI+vN St"gʶ.iM[y !4N@y [Z%S&[Z#gZɍGANQ E2Xlt;idVmݖv)ޡa%fpn@A>w˸qQ/x*@fǀmx7vbٔEvN=]-jqaai)-\vuKfX0fxAsdSN%Y3 #M.NNԒ%+œJy%yɩ@!%ĂM 55 I)XE[ļd͌Ǚ9`rF&4xR`C{QbZrB`zBJjNjzbIf~Tt/5VUx;i}zC$kzQbZ*IITxk lpP5(1dq]IpSx۳qv /du/JL+ټrr l!xehf.s~#{|x;`2d;?}3VNbxQh<&;V2xfxC& bjJrY8~8q 1xa33abJCv6]aR[6iov@ۏYn100644 go.sum ;^Jȴ zE}LT g* Rx043i1)U |~ fNa}?6L/2}Ii?)a[bJCv6]aR[^6iov@ۏYn100644 go.sum ;^Jȴ zE}L _x\BE)*B7v100644 idle_test.go0WjqW1tʷ`gU2m40000 internal\͖:?: Lb%22W{Haު |Ls}-G="F>렀?x77 +/yw)Mr*(mV!  .x7~e4gc!y9 |y*b]Ɓq3eq?]ȥ-,Я440031QLIOJKΈ/I-.Kgxh^mg˱v틞*#͙wQ=/\y̝lsE;ߗ[NWf*2%lV}-r-{vLoM>k7iߥ<$Գ'gHcZcx>21  _7"Rnj/{ض~ S^:P)Z9̳Ywu?8Mx:11 MV] _tB K/ēe[*~IqݳK~hHx:11 Wi֍( ;hbsc;Sw[/%Hx%11 RqEJ*'ԓ := A3x11@Kev_T"? [#8?`1ev._8b[-}`Lh M@C$6zok m100644 mcp_open_test.goVcB4!Yz AmSѳ. Ex91)O5M=,75ѪTK ~!ݳ[u`Ȝzuug`9Rd}U bdrq,e<Ȏճ tUx%10s:+ꪫ< oYr'U4x!00u W1C_rF܋# &dbxmPJA%5w `/6H^SD6{sɚαgP%?pi,DD,_K;43;͛/ߖ*7$Laþ}ة 57c$24h\pV "Mg( iC4@(1@sDkTӗ8wK+lj "#tTX 35oXLY DA{jS{5W].\Ǟѓ<1E^c;s)XhKbiz;[ލ"~Y-T]vhH0>GЗƳ}4[\(oɭ Bo:`Rz=U"axMn@yCd#A'q! !ŞأlvEDZ*^ Mt)DjͩI 6vF[ bhVV.<|y5d P!Ӯ9)2|Xl2 ;-K¡T{5,4|x;];zFNP4@-Ц6j3^[v.cgLxgRQ!==er_++Vr/b8]@kauȸmrXbɽM,]'9bW9(ya~cBzSxܿ7H-m.G":)۵/0v1 g.- 8m6л9)L8I[E$3| fq&EΥAX>;y6xuUMo$5 3+!!Bt9BE YfwOӮNݲ?,?)g~WHHKC RW~՟σޚ֣4Bo`X%-.Q^J$"ԦFAy脛NU*yABnFXƃX Hg/T7->/A"4_ OK J0:E"p4cuG(z_!FccQ-"MN7o%lXCzjCI!*雧ߋJ J]:j~@ߝ.\h:$gg@c=6ּĜNQ%RRLU@A *"iMӠ,'b$'ia ,teO3nX b%tb@)zu_mhb 5Ԯ6>| % 5T4Exi1~uj#UD !{nyb7"PUlHN[DFIdV^rO]u饥1\Vx0 CnPFr^(L8g,5( Q Hޝpw3-ȣ%rWŌW(vw|u3Gǎ'km<"g`59yvK:1C'`zN9Ȍ* Ь+E ܌˖<|$V'xˋh|0c)sCc. A *NK쌠ۑ!i3(ca?֮$5}y}'!zz񻿽xz Vx7?  0#=$e*& 5&jx6. 89=D?Bhx{{f.2͛bYA4@%3n^Kpf))X*$l~T UYE@xgC^BFjQBUf^pjQYFbAZ(irqf)dL>, VcZ LIMK-RH+KTVWUs/Nk5 @m\T ^n& (xָ'@/8U#d{!+Y5'[e))X*9fhhZO>$% X))hrqn.bσn8!K~4xP ɮ1@xC("v1_pricing-policy is not // get_v1(I.s.Q/p2in|xm8w^@QjAbQY 62nRg5x6}PfBjQBSifN%a0JALI$Y;YO^v/vl֓gbS9xrq: 6gXKn>!˼p! Bxۼ@ ܉46ճ<}? x[gJ( CUxۼ}=5͊B6[mkM{ x;f2A"O6e-N(" sndq̓8L ;MN|=>x[bsf2>=ɉO~ç.ǭ B\zrH"9,jM%7{Kd| oԌxx{)L~4f-RVxw , @0@v ,)97ܬ`q$n1xw *U=&@x{ehCH՝(37Ķ9T~ i ix{eth-)?4+}{uYx}SC3̔Լ|)^G.y[2W1iV_"sswq`KQk21̼Ԣnϳ_$-Afމvgnf&ޛܓ%EhFYټy$͑KR6.x=RMkAeHvn,쇳J Fr EeL ;3v첈/ zeA7ċO{޺^zt>zh}NS!B;Op|W)~ fI= jDs) g60P ˺F}荒zӾל~Hʑ9D!Un ) 5o;EZփ=HqP}ָwMm~5Zۮ6F]G Bk·Aͱ'k$$l 2FHp2CCbl$@"l.̳,gu_rm:/sݹF1L(lVWNdepm[zÉ[2|"j5'(g挩@Ni%bAHbvD oA[1(b/V[iʋ2v]N O58p$TeAZۏU=TG[;[+mӻ5_\gK&5s͹ e 46LX2EJ=:daD&9[~jݬUg\l=]x10DP B6}ඤ&냬Ȩ^U]W۝$ 6;w'T{=eo100644 go.sumo60ߨ5Bv뷧6d; n1NOR5΍}48Eoz xCO7(|Tz.o [Y>ҀI"}{,r'Gjpxb00 6:PdZM>=100644 go.sum}T*V`$s\ʳ P X <y&]Z>(T?)qxo`IDDtt؞,ModRS)yS$C̿'|pkKz&;9YV7nfƨ{4U> Oɥ59[D!3%'U/=aKJ#Jeg^]^tII|Ijq H[۽?D\ڰ7n_" ̜,]Uڤ>B OL0uK08w߸no?>O2QJM<"ˎ|=L6"K.~iؼHWt:'n|KjƑeP\rbb[[?.==5Th֢ߊ J.Hӳeƣs/ y_g5A+Y6"{W8ux>%Wl%IdXcN^% Kb Ȏ7xk0Xg[))5/9#$D/=a '+_Nc~;E-dkT<D8x{-{͊a%%˴r) jx{[)o*sN"ͻ8 LQ\#e9yLBRZNbRRjIRm&gZQbnŵ%'%#29GkswfZyI9)JV%E b7U*AQK>;2lfc5-xUjAY2sȚ5ŢfY+ $ANdzǞ-ă#=P/^Y%ކw\x(ԎF5>ĂtyԆvEAޓ̈?xJqP VR pQ);;ۍ> ,#KYY6A6Rv& U!Бx8]*te TZ455<918 ~3# karڨ2C5/ןVmkA0*%罆( bNz'^]tt` RgL W􌤃tY{,sS))Jj,E^[^sdyF͵ТiAnƽhɕorn0t&bȃBmrBiirS~!8b&VxJAlj(CTTd< $"Z䂦՛-swGo> 5|_@5h#;}a1NyAkaE42zTlIUܤFdqe|s?;/'P ĈuVTT&BP6-=A&J|zsLK.4]+k+daoF߹Rh$ BB88lM¬1*u5ekX(gG^H(sQGВ* s.]Z\xikÈ?@VNSl)RDQ0(%/`rMR^+ @~MPK<0soR?{ZrW2iwVo+xUMoUU[b*B,nGƲ(iSGD3מQM罱Æ]6 س톟o P!ղd{so(/X^me]5. LfA)8"֪!]^\VOSeL`{g&ֱFud3V{tnRCUX&3NM iY&lTvbeIL>(v.,7}w۹1 gʪ *pJOAS-I6|o#K= 0<#rGeɜ(fqE<|k*uѣ*nC69`ZY~yu}c~Yo7/]^ll\Z½hu.vd(D3}O(}&%vq2qs#XGI|ӷ,s\1hJIhYC8`5IqԢ-}SHpV'rg QZAC9w<}K. =P_נd@q`[Fd ZsiRQhXsʩtlHÊ9*!РILѨkYyąC?x}HsߕUm?F"ö+HU> 9jClh".i_Z}¦7{&h h}L5`4Q؅nIJܦWMp:& -ghټ\jDea?*V:}_h VXi.:}AU$-%8\F,~2%b٭~k. $rl졨,lw}/&:ws~uP7r n]]HPk7M?ѷh;PANv9KϠ~_cL#Ou{m<&C5QBuJA%E®|r>(8 ߗ.=^irye-Vs J֬:FiC ;o \1z|VKĿ fA?cƿY7j[]xۥHuC0 ObA^hqFniq|FɌXqM\y fFٸmg2%[x;$vPlC KfbRIrTlo@&x;(Ml*fĔ"+[TG [Ds JvK F!x=1N1EDBRQ M^lű&4!  Hh%`։\؞Vv5׻w 3xlӡzYt&\6ʟqXH/ Ljn1 c;;ö́06/Dd BD0C IAX>B]a%MNbNmw` _N 'zj\*_DFM̚,\t_|vaa-'P^FC̚,tKS: i9eg'*gGFHZŠIq)ы*\҂"@ R9+G}*WGJ$;k߸nxxqCf2.P}.x[qwB9GUbAFIIry% ))E JFz@hhehifj44~Ff,̮ @#V=&J\% ;00ld=G"XyrIQ6# 6 3)CMˬHMHisPde 3Cu$%ayj+Laaifj v&Jm4qle;?a Bx;gC:pbJJBZQj#Q9;ELU\%%$6g+)&.`$YMvP"DRQbVY]VflWpZEgx=JAQ"b!0] AXz7$J6|{'p6?ozg}N =4^ #鰻Xvu78AJ\̹Ǎh3- ᰆxDb 4PAi<(@$ }ZvTEKfºfaeb8̈́dƐֽm!c"j Jj VzA>\}A4#`9X͗JҩfVzDM.,rL!eߺVVГDz!@cX }~X!2[OnGTrx[ &jy z))E ũ% % E% =&*\7HO>gb f3JN55bWH?q(gd8f[<KJR n'8ޓ MD7qw.x:11 į:AJ1u$k]{^=T3% !K~NnMxr 18hxrqf 6gXKn>*p!  x:11M(.V|lltP̓h ;jX1%xg P{j/'xXn7[zWj\v KFktKIvIYv }{{>}CR+YV6w 7Lt&WY~fS^7d1:ƒ~dYf0uE6XZ2\h.BӡBe5ɸ _m$R.pG~^ٰɱ(JQŭfPmUEB9%'XhmAHNWkR8*ze&lq*:,De̠cO xLjjld(-cnhT.*ŏXe)RlmLa`3pig~h 69{՞߉rg@Y#PZx_mOlв Pj>TҊǟ(Lj}P+Ͼ9jf} gKӸ@6pZ7x6m_´5r%Eq+.=rSaDjNVj; "ֲemKX_\mw<~j߷  jUʛL:^EȕMZQN`[H9@\ܮKZ{g^wWzC$I|CC4ȭ9'*ƗqMaEGF^fM]c}jL4> -wAiW4/-kWne.]9d[rTwLmx@b9/b`*;AYְy$M:)Ĉݴ(O}sDǫѩJ G)yi{6mo[P%vmUn};LglV:~̭-MObj%Ye CQ]esM9@t6ս%hn=;; Q_.ݗvHNYIؒ "$8X~)ttW84N5rK>U/(z~w<2H<o=j͍Ńx2*(SL\ sf4_#vBr3 ǨS_>%.x@4:ģw#5-}+Wđ~ χ6vh_@GE<Wgz$@.Ľ#:(z+̊3빔{1<ۧuv}d$[Nh>3aK؅y~zH9jdժ󼃎cy.m)m,i׫_xu^jsQb 3_!vep؝OGM iK, :1<؏+O\2]BEQ磍 dmO_ljs+k9x'']t+- r])۟ |f#Q\NgԕrH_RkOis>#BEhlA]NL,F彞 .=T-MPچf~FrJLX[!͍EiSܐ JMT1n3`eq]j'vJ*蝞wvDt#7[2S^]/&V]/1wMQ1V)!iz~ҿEV@Y^̅+IXn# \x B ܢG y*"Z2sIZq.I{HT2qWӷ gCX?TpDgÁZة~0EJ08=8:ܿ!({|;`\1ԘR= zҖk$RPzDv"`w5`~Zk_E濜?{WgOg߁o[7 T%>5x{eUC$=++Y,tRd&CF/̎mɵW^7YDDݡKQߓW>R=͜,D>;x??al[&wmfgyݫfaJdE' SogQ=/`:SWE,8pDNKϬ&̾ Uﷹv Lf&& zť OC^ {RvƘ)&3s=foLQh|6+gKK>3%$D/=")zoM9+cݓx6-30s|w~Vj7'?17\=<,}I7Mf5_fV?0j|]՚\ҹ#O^&h˰|eU5_%WZ RNv(DHKU r]|wȲ7?_sz`H|6MeyUave5['3ݷqHWt:'n|KjƑ+Et:M/ X!:+fߝ"$RŌŶ]z{jюUB "WZ|zx{PE!/L^'tZ$a׉9Ṵ im^N"6"{W8ux>%WL$V, n;Ϟv\fd" [CR 7If]E|=&uQr˯0BC(1 E;|EVmZ]=di%uxO.!丹=9qVw4,l޼wRi%`x://Q q^iE:7gU`>e %|iX$D x&t A -Ix۪UCȎ? ׳z.q+%< x{qUr{lWirKu ۑT1/. x340031QH,KgXg4%'>[t%UCd`"ͺ6sKRJx~?}jzyb|Tab )% ɿE?¥{Yt6=> x8qB$5 76:gD>tyb2 vJx#kN%Eo9,2CeLtlpx\+dC 9FsX\x6?# l  x[8!LMD؉+8.OY?1K 4,xbb&^[Xҕܿ0L+;'f) x340031QHKKgPЫ]YE{x&>5xk1~2aLbBf^Nf^B~^BjEANfrfBIeA'\Y#6`e|Op;q4Gx5JA YBlū7};i7tvfd[*H }_n;K` mHG;4=e`\n%q] E?M\w?2[uW8?~?Uc_yyW5}޴}eYqW٢]Xnm۷Gh1˯6nmzO}u2`Wz~[Qoj[a۲~3m^wf[So˦۴e5.-YC]=-mͲlڦ^|q_-G?;<_}^7m׷[~+T}̟/[n ~?F_|۬-}/VmSldκ]䙲YeTU/UW˗ۼjdÊv[M1ɻ6ȅ<)Voy 1LT)c2lzDֱe=E1NR6`;LVU'c#TFfce0GﲊwuoBjF㼻'%*V?ёb|crs}SyRZ"_`7QL}\$e?CϿrJx'`'BAdN.I"H->YUX,ظ e^|(G&y.+D.GpբT1_OxzV7rlv]\G/9}Y7NqT oa+Un܇_l\q+.=ATȵ_eJDĴB[ϳTV "jaU/v-jem!genHߟ_|T}vmS7mf]wj6:uBSsMP./)Rw%Ih;;wYhT|Չnʑ`G)DA'3)BJQ2-)9ky|GJԲ~N?y"޽弙\.1<+WiU۳ d$4QD&gŅA^,)v\{ 'ZΙ/Jxx\.a&ջ+`K} dg`];6]7\a3}xun6=v^i@12/\k,I{]w}Ռ'loR;+/]֋:ɠkE6&-{U>:,Jo[$O98s-O-emzaom?Z+LS=< />~"To! JBa[ǴmKMw_nIHNڨйDF=8IZ\hkpuЪʔ576u* CTަ'c%{`7H۳ox?oR nQLǴQQbH٭eh5[+ܒ1QaQz?_ Rj_"SeRd3#Pצ-{Hǻmn$ۮ)C#x%f]yKltۂ(mG'-NT52q @pC>Wh"cVٞ +Uɯr 3 ޢ];Z%} < 0Wȧ؍|uFU` IjRo5W/B\f&֮nmՇ pFSٺ:cYORL]%s>? ~#ӂe_n(Ub*^d+SUXlPe*\ x& ($sn]MY&y~R98vpSeE\v1c+Ƴ Ce穚 $g~TmG&#N946Hn^J<5QGQ@)# YD[Q$U|xPntp`EMw %ny<߽iMP2@u^ uu?0 ,SYꪺVjF>49m]]Dn!ZC6gm*ƊnKN!,6\82ͮgrkPLPӠ$fWб0Ⱥ7 fft+iK5%"!PuGںy+Om2:`z0oitA_ p/"뚻En[*7/ ;>ۋS=`87ÇӾTf3VS+kzzvrqy|}W.t6xZvZ=>6p}5EUd<9Fi֖6r2 3_fTJuCߣʕ,zk06Q-'\bٵ0*R 0~ bu>XZi+JOͅZz,PsM W ޽aܩgʛ\O$ _ m+S{v09RZqtѤ-IQw+ݵyO08O T_Tˋ 8OF.A9> OP;Kxs^?a)baRE"tWJ;:2^n*rCqH0|Ks2UaU)tbEmfPKJܼ<6 qm!}@>Έ!W;nʯb 9/ g1P[Snj~iGbuݬY#U4Η-Ҋ߮1|T>y}f*^rŊ_"6Zn'#,+Q˯Uf %T|ech6BFfx!n<*VBb:)6z Q6Jֿ~' ӂZ>%L3:ll3=BC}b33ۨrѵC ~h 1*!ŇYrMFִOM"0F&daW"VWS嶋p+T˛xem&t'TpS! _n oŌģbQ z6ƃnLg!N!iju)tȋl#x5}sp4aڍQ~`踅x[CL>2_酓4WѷoϞ? Y_aF(܊\e"ۖGpKrS 3Glju_(T';jbwlM(\-G.{yq}qgF]NȊq j]1 |FczT+vV.R-,E?׌}3_7UߝA{:M xObܷT[4>hի[Lp[wԡ A'1۵ώ9 Z #;Z6̋uOc4Cl?xT**wFA߲o"Ú 00أXગ}{*f6߉Z'>;>x%iIhW+qmk^.~,ro#p tsk<>vƊthrO?5t`eS_7H~ OMjl2ߪ&!:\Aq3EvKa9"ʰ-bTze?e"܁?Q>JKq;D=6 5-s._v7Sr$tpj Cw /|{ɃW/DF,_]ȨfNˡY׊Q d"FE1u6/V|:\:ty,Pw#zU%MnKF/磿],v[$bk|#ׯHׁBg,Z$/~bꉨYeF/n@gNSѾ'~I[hhx R?P0ˡ[釫J}Uy3]ȅ[j~wՋ݉iG?v6$o_cp,(^Fճe}{km3_[(i @bQVʝ ۧA(EmL\{ zS3e2 zL7jO7rԢe9BT(HWbu-D'4qz615DoY7']__\`BjjIn?޿[6c `{ִb4|>44+T2<ɰ4&( YDN|zE&f}]< ˋwo# Zpv  F54i]}*rH+f!'5@Fc{鍦zչ`A}0G-BK</1hlW䪳o͠c&ԳـhV yh.H֥ iƅE(nvWQ[jN_(2C5*-]\X413ݭ!gmi HçyfFNhg.39<]W=/h2Ֆ]@0Uf$.MFUUޒ3~ 6j0&) FҼ Tﮝs877KiB?b25sKѠ* `Fyk,(PVd5d3x<V38FM8 cbҼ XK xU~,JU>:ZMde%3}f:B!rngoG9^Oc81{6q~ĝϾR(C5krZ s~O5 |B}{a91a/(_&Oyx$SQ]w!ƾ<ʟ?{G^b {/ߗ/~[Dg7ً=ͳoƼs)/Yѷt=-B[2 ʌ ,֬?d*03giu=􈆅]+ ;wR՝+,lLi9ҜNsX̓z[KFnxΣT6Gȼ/zf/9=5g;Uv-$E4jˍMb5N:s0*DlƜĺn5iR {do #,E%ژ54Z.kh6"ZV]}x9T$C랚BU jo0QFe[ǯ0R(% p53sg&FVyS -\&C]r9e1 4 {۲>qPЌylsM%XwvM9?*> W/F(1*: !~#2r2> \9K^O97wMhUG{]SFNY.-xP,^9q'ߣlVki8`VյR7B(,ڧ/QZ`\B|tSu tI Q o.0ez%],P|9 o}}MJ3" 1b%4~c‰( M!o%v 1x[TjV`cU/LaaF/jT}B*C(I:.j1aK.fZ]AENjɋk4R2bU0MAK⢾Q3"(h"l}^L_I9phE:`xיx9D-e9kK fMd~;ۓ%Nf { x +ℱ@Z[x@SW׀f@qMV0b 3FE_kF{MGopPXP_'-EhlЕ%f%,Jkz kRd v0lL@\NLĐY='\Mucufz*jO{ŘT,{TfE% tnJV LF" މ&|h;!)v| PlN"2g.NkX-n4xMӛJB[`xe6Μ`{򀴳xVHLd]kW':bexan4ޢC`8eUE2LVE "TG7PǰU;;=Xe󇇃rhQ/'ÎDR%f0O>yUW /,>-?DF;`NpSLRio'ΞǴ_kby?RZ"񒇌UV79W.n Ctڱbe;Q rw= #5T>E`%lUq[:Q_p3Bu2%Mɩ?`0GI~{,,/Ԁ,P=;~@Pvp*PB3;պ 7,^&)m5 OQMB^l6y]&M O} -5:9}&7CNlD?īMuP"-Bj}5 **4G WBeAse٫'{'hfʐ3e"@4^OF[HM)rQ&,CQT}@C; Q>Ia`YйCgqEq bٙC@D1ЁĢ}l)Wr"`~EM2zKƁݝ ,q=JrL1Qi(i,lHwTYq8s 68?ԶF qL.8!]aw3X`{f'oU›e_'f&WE80+N,w~GK֢hyTvc5mS?aŻq ާ4MrDs ]|wvũkŅnPf1T!>_^MAyA˒A9F,ʟ1T(tVće#yHoT(P~.eoy<bw ,ɝ$gaA-n7o]&!-i-*dՍ(*Z΅,dT$Tx&geݡ98U+L㨅d3#NYE>69-w H.m`ުBW&Y .\ 7 >3bIZ<-dO),H:f&\Wn0h VUl}QH/O9FZUI%ib#3·i\QSr7 O#gSL+F(^ :!:WnJG2F{,\2gi@rcsb_b ե<LPh3Ã'Mve7gyPTf1cͲGO~woϿ;π? HWEIF>?\7cQ+;+Լ G%̗G$n+\=2/c1xqۢcjii9 'o 8kEOA@e;D3R g*4+Jjڨsܩg,_" r})v:&".R*Trc2ڿ2"KA,WaH~1oc+70N3\lU>]ystsKO} *F/UK,AfMZw]=K  X+]J2- v5 5QxUu`WۮQ%ZiNQwqT0,ӝɳP`k%!/124(1􅽺xir|n"˜%KAi]3ʘi@FD,C_Zbza4 ̓PB7TB#k"LP̀09iA8_5O )Ы*ň4: ]yk*;Ou){pb2tqd3ӛ`$T9g4r9 cgR?'͛/Ż1”PS$ YMSSH,tFFcw.hގƢ'P ;Ȳyչ"^x\6 @KӟNh~(d 2Ǩu5xVNn C;Q[/=X+b9B[Sp;Sx${& x2'#/ 6\:Ra3mM{`MXSnRy3 ?!ԸpXn2! s4X}J6G͆G }]^Ⱦ")˳gU?"{Kw(%@57Vv2K-?<2J 5TY.J@g x "2.X0}SK6.~eogǙu+Lh n5m wmCJٽ81IهEiXk 횏'0?Pm'd aߋP76';=))C驨_W fph`؅aɐ{AIDdXǁd\0A@%+I%X#UBy md%ld9M _>8Ϳ?$liڂ#I,м?#@ @ŒT-ufv0ۇh!A2ŭx+џ%"3UT3 eo>jG. g i+#g i @*+И?2r N@NV6@oWLn>eJg&̢9Q368K!( >) fY+ٰ۔^i?}_fs4*e@Y9y |^pQIlK6)7 v!ih::\S‚fȔI $<7%R1n #^i ?f|4hڥ_"OAFY̾D|D#ބ*מ(edQm/n! S uCDCt3Y`H2IY|j0s|+!;ƃ4/l#+eutk [l$!ʼȖ?aA]oıds gժ!fpD.`\ O6hΩz*WDdU5pyz6K$pݽXfIPiima\xH,{@|62{[9v^H%XM zDZ=\q#PA!t2;/Z]Q9Z2\gxPR8 f@9A6gfa-Pb;zOBکvDGpenYlܼ]7сlkzv'"'|Wuց[aT3C^,P*d7'g(B ?\ }Maq ]|ģZG4bXin]hN!d} ذoDV̶5Usq]QT8C'IRwƒ2ЩQ U5D]l6q>` YGpȫV|΃LRWgbpC6CYkƭ[A#zIdZJ"nEmU+,GIx2Ts/t-jÚ՛l|a)| [nh}WW+0 2}U15 suݙMkz\{A6{Z HFJ'IKo-<<;>lfvrɒ<~mfjArJgEJ_;8->\{M7@Ҏn%:c]Hߚ,5:g'1nuk:G57fz|#ѝj'X, Z*/Mb >9E2%Mu^mƒ:3pQ`?!`5˺'҂yEFrtO ~i[B a!&dTPxq<|М7ձpu0|<.@ qs oOF}eL԰!ᓑ]  QfN/̵80G֠i-{oI ܀d S@kpv(e K/ȡjX[-HcSӲL,w- @iSA:"c!m^d] eH%nO"'_4fOpzghdKY~E5H:=h2| AŶUTj3_n=2|hSِ_eߴaGt#KRsk8/Q\ܵ*7?9~g0A8ץltQܰ,3b*4ŒO}(w1f,U`Tgm7ݬb![ s֜7˾v=_HAZb9tЫr풐KA0Βs?e"ΩiZ`el}R{ޗri! u|BP8D^4I ւi$F\4ڣZ+.%AR%1 VOG8q8R}nw0ns1rKYw/a1IԜߛ# _<{F3腈 />g4bjzItrY2?xs}y|L!]'P[fL׽/ƌ!*x[`etZ/˒?@vO7k387( 3Dy+UtQc6Xt &D~Z5f1NiYasqi&bjHpT& rE.B25vMםշ"d7]vʎql`DrbGRK0fIL_|l N \ζ^.^#f]_La3dQd;z$ K3Ygi#k:fEhLStq;"*xbW$9'1mO:K6cE˕5>Vrǖz=šU\d$G~m+joh>2ɀ0O,b/b2mm>(RfC(*k|;ں=|D_uhx=K&L[js\eNc<*~uDbOGAGv%? %o$%!ۭXm+mAtq)GSZgAr:RrmUPœ3 7E,d[Pnb2n!K C=0hfI`ȳD \8K~<ޗ "9>.c t>#rUx괿}_N yubD~^BX~Jmt2e}(>f+RsqLL&ы]ntoE%]H;S P2%2%s$e#k2JU@,mڕ"kL@JXի3$T)C$ j}:H;*|R_/H‡ ,cb /i2i9{Z%-(y řMT0ignFM1fZzvY_pawc+uSYR Q|WiuL1A?xȔVIud_.ix$J"?>xo a`(4"@Ip%zhRkof4jJfU:2zz664,`Z[TAS+eD3źKhumQyV c3) Oi@C@T#BؼWUe hΜqs3 Vh\V%Wt9DZD$T#apKȔoO NN^_&;fSWuVJS/~slcU};cEWT*UHvݝ&Rd2/;CBH:ϱ)A 4uu je޽g O$$5Sr&&C)3wA>2)*5ց/Ub7KA͕Vu*Z:N-?BmW_SywTB#fP&h[Yb,AZ5Ԍ=Y+p hҚ"Z2iV ,&4L'b6PӒRoE oÒ:Rɸ%|3ˬ8N40E)Yj8Te'[f3.3]M6bh!x3N "_{ku1T:{eƨ{JRdhU8P&~}viBPo6cߴ1r s5[F"`Gȥ\jd;BbO'ej-%;ZyƻTj*oTgX/ٓp1阎juVV_/]gb!c0w%{-sࢷu,|DePѿQ _f. "Q 1|  #zRʜbLQr!;BW;@_N# xT,7!k9WG!,| )/o|cF't8FSMa 580Ϸ T'5VDG)̯{RX=?Fj50!3|fLM Ka4˿N `׵ ;zydfGk3HmK4vE_}0Y$`H74p NT3c'QU [ڞ_*f56U$til4ŻGޕA9BNp|tP4<́ JK'h7BNJu 1[A Iw[&XK }$i^U1 fYs! 0)$!ž6gxJp3NMxӠvXe! q̗_޽,N^]+$cOһG넰[ԃJt隖Gf{)HßgMщSwPSZfgږK65aon&+tVC?0m9?--r~Us@;:,q{4CKZP}~ILcD8Q6ћje=;k8/GU~'p=0%uSn'Si H"'}NI~)9;9_Lr~&se ᛊ3R}BGgypr;dk?;f j&/chGygebZ93Si=d/oȖ|MypOᾅN-Vi2{dBd %ݨ\ۭsB",?7g0׿Wtx7CPFNK ߂8֋vR 6+Eepu`TkT,29};jjDlKI?1q~&$X_Q~?f&Zxz[oaiǶ?}+<8(Ȫl9O{+ PsS~$uuAgӌ/f}Pj@W`}_?$<3uÉSJ"ij쩞x%\S$ 7_c0) ѐtCJw.8y׼a-ҷہ ^J$fVlȎ 0t Ty &-7/UZ-[K@K*h]PHC˔{nh̏jsV_9&NasEqf9qwCKfjeYP/1 SGsC*nͭ;0$H aߣH-]h`z.Opd2ʈ]cJt9bb%+c]7ogu[^Q'SLѯ_(OjȵWx8AmUH*ΑNq=K'oiD MM+'9"0b3Qڠ!G۫*.--14jhQJ8g?`ҕc@ :0"ѕzý5ؐ)!ɷw\{Z+AĻK5듸WfkzeJZKzbzJ`dL4'B0sӢ؟E]+6M7f,3N>U%UMCZtӇqb#̢rpw`"H6~2KCV~WUلpߞ|kbA囪F FŬ_6whTŎUKneka~7FhLi@H7vIKSt*f!q^-*h72{-3ڭ#o~*^Hb{}"Bnbme/*B Q*,MMHִĝ# d ĐBÙ~w; _; ,ϯ0`,IBڣhֿ[;3URԦzH͠':ɀKdN^ݬNvdeAD:v_V?Ě|~lƆ`1^3[x1ze{#18/e_E-֎ރƐ LNk`mP _Y~!d2uzK?f~|g-‰'K,͂1GI[6GL+0.mj/OO5DLGզՓ J*NV1d?l^;q]2"h7nsMٙ <=la>J>|0>b+=. D0ï-C[E*cfN&{u$opܑa+XUf~C_*+C~x_]+o~#qnJ#ȅ(ۚɂ4c$pڀ4wM !qTjcQ+m.O=;D,;ӉDhB)v%ٮ(Ubj Ou(/ZDU7tXAht,Ӳ÷U؊YϹ@ꦿמ<6Q/"*&5wsZ5R-njW?; -ڍ5sNbR͆>ڝ,M-G­'H8g S4G~3pJNT_z?IȈY@!n}7L7;DM4mB5#ҐX f7l#Va!AwlӘq7U_49O+'물DLN6~.޳="ݪpzJhܤ y$,3=ڸb[! $pKfGP;Ag4db%dThM)gswA=XI}uOv&4n{޵eo \%g\98Vj: )oe"H8EJr1<L}ԝ 6$ֱȤ-LBx/=xs/J.Pt5ʐR#ꤎ0`'2!$4TٙU!f˾(3ITA~UP-IP [2 t'TH#̢? jdk[b,ƷڦZVN⦺Eഔ:Ul+@6sŞR_U Kn+ןRQsT0v/BjMw{n0&u h74yf8B!/<әsnȕ0E5"QXmU 6sWp:(=b]Ⱥ@R2w<2I-cyxc9?<pR[^Oaق~ GkiL!I;5CxMf&.Pȱuq.4G5،'T{F҃sOfWGiRrJ!!z EIJ˚x{{YtZ9HI&i @9b0e][ղW]¶^ 4G$rF&SLO$y+8!ݕ=[ P{ARgG+R_;m?[˴$ X:4yVUS+b)) JݖK=JF( l a<{n >X:k`OE{'abV'|VcVs{Z>9rcދ)@ V8ݝ$r] {5*N8u+34G )!"\Ү j 2ejygW+I be |^xx4e 1tf%Nɘ'7iwjkܺ3j|hC$65壻LH29^-o͘6Էw UY~B1t87>q* ]Odjp~>)?A1 ړ߬'p<"d_9iB>.ƻPjd2}ϭGZA&og_UAy /Κ~ܥE3c,`R5(. Z~u{~Z qխzw/\s;XNc!%Cௗ!ǀks3o'U% =jcB[zoqjsF9ٿjɿ |\vY)GdGZAK *C0J18> Kb3z2h+ﯪkDvu4՛b q 0E yt@T*UnhP #ݕzԥߟ:`3Z^=WU/ QbGwsFRO(vBvdnX?Ƴ*:pL9~,4 ɯ=ON tD(K*%vkY>"ϸ=x3_Ąh-Hȝؼi/=zݹoET*x3}I2$zطeVb(*Z`%ls:Ob[>O|k1m{/?c\̻g'w`@(n,HJs5N(~H7O+!XjhZv(a(bw4a*SzJ gny4n^1޻4n%rY'<$ Ёr4ryQArHy 7;8ڶ*:./ϸXWǸ ];h=Uг(gg1n5iDXxQtET!A#8_gK/# A鞚UL mq]W†(Y`#+GnC zW7YkI(72=p,ny%kcqNȭ,\V{|A 1v^{kc:I$gⴸ)Sg=z%[u}-m-~؁S]+D,.jM|rN@wlW[= HxG2sRd0IfZB 7}ὴ0Th=C:+/1O(%˅!*,yV%Jꘖ ʦIͫSm'.`M{f-$cW+ K#mS9z `q# f=V*&β-RM+֧SBIhN n .Rݕlcbet]V@Œ v4'D^iXh~ʓ[*+o\Z*jf_(Y+r!F~ #:5G U .:נ<V%ےuJEMsAV,L} +7N4_t> Y,U:Ն.#7f(u'.w83OTgYB)及OC֯o\h5Fo6?D$+1Zw fbƎCTs]DZ*n#MT3شïi!F;TzMW($3z==];wM g÷!Di[GG{}b!磹 ,aMh Øg%" ZTqJ1r)|T7YKfg4t9ASkGv )6UE4E+p!9<k֫ޘ?(plr LE՗'u06v75Tl6Yy18. kk$W v g%]Ov5lv׽ L6:MP5} '[x{6O)wKa|HIE_~!!xmN1DEIZ@GDP"Q r,o71't4Q`)ey3㟷ϛr2uQW~QhUg(( ShðZmYa2"yդrdo1. /,*=9?F-!Q0x$P1'/ KQ?S^t=0/Ff4h ga-o֘X./%婌^ESKi8`L+^埪JH2sSzb짆4oۿ`aՙȮϷsd4 ޘ7>~vvbN.F8 ^h I7gxg6GqE.m x?^6Fٮ#U,x;#b2*bbxl{s_=G6:sI> ^{};_ ,uS MYb4$ls)X& Ķǡlj`R3&p10;.5gocpI\}`rXB㮕E5]ͱ))!SuVײ pr,MT s˔Y@/q<3A$79M}/>ߜꛍ匚ecΉ($!fPߨ{9pՒ;oSČЙu\p\S]XON w2al5|1ao^Q[s0`tfYNB3#xb,bFZ; |FY,(b(`ՌPÇ"% 7ǣ?w"5DWʹ^m߿0:ԑ%y/Ĝ_XzCAwSDZ5 4,Q yK]3+ 0Ȩc&Jos܂ BʙZ k /[^I **pwPP%$t2ߎնXǢf$e{)WԍQ#2Ħ>u`'&ڽa2XQ+T;v YC%DނG c[bǏ#=E W{C@tAw* YE˙ГK B懒0e%ߙ(tι@R0l00;#Ճ8@s"Idq6*YiJ۽JTP龚JeV0y?iǺ-m8p{'o kB0S&cPv "1BMYA`h ^]{' p97P=ȥDWV_lDƄQVw'GCy+W}W} 6²c9kMӈ7''iU7q1ƑfP %bZXDW D{$(FROqCJ[X ~vT 3Duc0t*_5b0Q0_V׮txHYgMpNr{yO`;]AӷAp7f-b'6h[F¨B1+&IƆ=eJ{Q"VJ e.<8-O0f{VsEIm#7~qA<1ӡ\Vyv\-%^][J*+V+B x# wB¸1]br8ߺ`އ߾3Zuҍ _N [H.>gj2eI?%t?V 6jVIxk9YF4XV!:/NKLSzN>F` 6x 0?['skA]C I'EPS>gz%׬:Fj30h4` :)(*ap,^Qc[AF#^%l /E> j9ݿδ>#-g?`3vxθa<S3xk_xgY,jn~TWWVxo/.<8|zR   zNDXg)P =*}k]8?q![FMTsD LZΉc'\3ax}Vk$E& zG.fq ݬ6&!,骙.]Tդ'OxċAWiWcu1!}{_7?<˓~cz/M0HHrEbrѪJƛ$9-yQ\8lYYf* %{tۆj9UY\xz+j24Yr~0 N]}׷/OOs!m=FyVDf8jr$(CUbs/ $IaLDmT@ 'GtNAr:S@fFP5Hy{`5S;8O.WrkF [)'b"wG8ߧwxdnM.?5HILFZtzoZ'h&VOaM`#:+0O9buT\cXk_ZT5ڢwVعd<2Иa.U qU5450e̩h @=SA4C \sECI|qpTC]P59bpN 04wxV P4;Q\91aMV%+ qma$Ц ?+Kyb;jas㱈cW7i\LL@g[kF:B oYí}Efz3Lme9]^~3K}  DM-|) TD-ޡ:aze<MҋpZ,;h`ՙAyT0 qC2Bv;VOJDAkvCYf9\ONVR_w)Z^|$YùƁqoP&^[y! r}CS [#csY|v')Fc.BPk3oYdp%kfᅞYjٞYGΑשᇶbJwHDQ"Nq2ť1 XŸ!1ۑ~3!XΕ9|R?{9AuɈLԳXg k^$GY(5"ˊ&ן)p/'G{ĤP,MpJ'N1N]|O؆)B6a \=/BSptM~( :pxt."ӥL$/aH$_P\/Գקd–_Zjӆ`!"|tuY\Ef1#[D(pfL O,莠ƽn 'ǖǗNӯ?_ōrtx}U#E NStiiʚ ڂv^D:홲tdz&$"Bd+!;$g8tիzUj~>8^ |F顕jF1l qr2>{yA+JװBk 6%/_} S #)AwKu1t Z`y 9.1} )UodYNת^Q\L7|6VdtA/)Xcy!sn*QT{yn9zt-ZztBHv+|;䘕2ZYSJXXꕕվ=Qjǡj|V^Vj3TeoZCI$~0 Qn =[u*^~~Ꙏ_츟1g`9mx~Gͦo,y^A].IH1d, 5n&2kaSC;{(RNfJR eBՃ8Qr&,; %z6@/'7)=Rf&O \ځCVdf)X\x:-瀎5e/BNlxc$1#6:4RPB%I\ "*bpX # +-z.X8tKEF[G5Q12+j+4l^BܲݡwJ#-v\-*3 4X)On%SKtGchxGy }޷ Wf;}w2_&7y08,=aiZi,ʧ\gM5uk*."Χ9>vc^ G&iXnyVǃRMj~o9 WOԷH \!EҏH9& V̊w^%By8?4@(xqC\'_Pϴzf5,zEezy9clq xkxd5ㆉEi%p3m5m&SXXZ_YũPT7hkpBb^sBR~IHv6o~b=ɭ _zg))X*LטGlC8zO@6ʌj=7WtrI(g$[)'y\\mBpoHx;qj +CYk5j6zx}WϏGb7$VrX ^Yzw`EtL7TxGQGL\@# Hs$+{U3k,yTz?{~O,\W'{/,~ڦ23YR%l+%*ͅ*:5EVZ'\%BX=x+|Pon N &u`i❃Ȝ2I6NNkx?3V &8"eI:j<Ҙ=t-=XTKp8&Y9EZDo2 JO;Nj_Uojw憜T2^.?FW|W]^no9vo}깯Igsc#ד2ӽWGѡ2fMBPёm/W*.Wk.ӥ\\Ĺ̊&[2fP ;(@̧Z2#T:;:=럜F0XbSc;{x'J-lyZ5iq[,U*,V# [722fIēt3vz4_ #Ed 5`BXS,!9bf"Qc.6c.N"cT$L]MXk|vpxp"PSq2׀,46q%$pRt#Tu9RXCxT7P'2䞎<) ;}ԳRC%"Ae5s[@N0,ĈBȴfR}^EĻCe ho 6X<媩FЉj|&d|cd~.&Sd[&7|v *7lN6Gr[Uѱn[FnuD:]G3t`{k]Ө%sBTdWX(Ѵ(@S Qpe6;fKaa³i)% =<ruC,_BOs͒q ض @M 0l}{_0O \yZG =89FFZgƺ&5[_Rֱg5Éby?ك@njVcrA!BkB ஑Dt9/7QV8<Т,W㐦0_P4Q_"AkLqvת[PS@WtO^MWͤש}l꽦,ȩ&Ķ>Ͳ'tsqi&&+&q ?#0`]hb)HZMNeu; wz"J[!B e qTE+pHzM c lxV;ah1jgv'{k=~\0e,xNORSЗ^V$)@W@b_Z|pG/g^Z _|Q<_ls`q~{z.?ߤ~!1u Ω^ߩ|UʄcI)qw?쟰ZIg7n6h6MRӘbr7gA/UgGaZe~l|yͮgqn6Fw0MPrB+6 3'L"K0)gq@suɟB]^. E[~t/v}G2xk=8w 0͇TIn깑YZaJoU&Mɷ&K8>`^>ɆW:ռ˝xsz>sXRC-Ia)H"u! @ZUb x੄eMmvԬAI|0#U GR']MEz4󴄬LY`Nsh(1 ֊ Lɍ1Gm 4gY>Vѧn/_Ǿγľ%/\e UrpR](#lU,%O<`DMyx$B+ih*EALf: mebSj(MX|KP΍~[PL 2YG!/5s}?;9~a0UʛN k45V!\R- '[نuC02e.֑p z둚f,  @ lg(u8)x1) u%zMf̻= VR@ƮOm VY֒Kf^4 |pH8jY1\^g$aW OxtiC{}JjQfYjB&+%xh((((gg&[e(i**(Dあ:\ 9i@ RKRS t($fs#oTT rT9Z#F2xۣKiCRaibNfZfrbIf~BjEfqIBbBbNBbF. b̜JLҢԼTbԴ |ɧZ\wf} ^{dεSkoxMPGNn#L4bw2)ra #26aDC@|[Ih!З tΙ_B,}VC(iu?z#T^iS[]VbWl==T/zJ1'.*`e~AEYD?PLЮalZ09GbEO*؝im.~:[jLC~Is)8znw룢[u%0y?Eӊ "8zڽoǚ[vpnF%Պ "{FaEѣFOok+(.OM_ͩn_<7 \2/L{=Ʃ@Xu7?z,T{wqES!a/9KBnxU:AAG+<(m  Npח'IoPa2U'Ə'뤩V\*d_RڌKSB9%vҿq&!Xf_$Ap">,ζVl_5xF4vcF^2-G~a4F=z ~R![9ّIb"w+'+$px"@zEi^^bnjcAB~^B~BfBc£) ũ ՛0jgg&g(((%fIl{%L-\|xmTϋ#UffCsZftf{f]A&YfpǸ:AqKwua%ăW.9x DD x(6WU_}_u׿|kF#b(rF:[3WF>vＴT!2|BEeVa* Q7հ[.w4dR>(OS+8)=\jG"}\2TE8jHWLbXxy_u[I0έ#ZK"X䩣_HG73F4"|PxC0ii755QK,x eh,FX*2@"Mg 3⒱NǙIH맗]зq8}8J>7!A7j%= nvPC'EDlA觽zP0[|͌M(9nAIPS1+n$/_<Yi=E<^DA-fl*q^iQV6$Cx\Y*]]Cy֠F[,hlgZrRH 0 Bj Uaf[~khläʰ)D A/B'=t ]wVuh+z\F?\t\a0F;.){T"~)Vky1:TOx?.-I5葪?q ӝ]舓1t9_k 6Ֆ7e nwx[G ;8 KxuqJ ܉9 2JJ 6/`er6볱"' 8kju89ku6=4f}̓U6Qg\9msEWm;,W\T[-ؗi@#U(|8"yXC?LVKNKs,KnbQ/VHIIMO,ۜ*8&E%ɭ&_jHqLm(93OjQQ~Gb^JNjfAff#:,jxۖ.},"DEDxEAN0DJCWT}Q--+I~b#?N r΁8$ ϼyK4S>f `n0F.o8 pI{ɾtb+jqBO>,`\aҸZIZE4* ǧyV Ɣ^ah 6mQS æ36.k#hF`JR=Җq`\ ` i e-"b/UDQٗOazϮΰ%m>eib*hPY$K E%?_\b g,^$@3=Oͤ9n#xT]hUfB6錄Vͦ{f%dS$l-%m~ ꂊhs7;8;{q/b  hK|A}P J[;s'%lsw=\W~E)ETeˋ%z^\Tzݾb7oǭ*`Bxj.e Ĩ,'K˚D^ 62^F}Ge5 =FOD߆ 1 2>"Yy=.9:o_wzѨYmBظOߒѝxY9Pz3KR'kPN'G$trrk*T\g'PiOwz(}',eu5Ӟ+Ke?'Ԟk_~uo7 |;,@ n0lm2-giLi/sFZݳ[a"LPpAMޤ ARCe[SS ~xBƈ{\oVC-]";Dj APf6I$#mf׭7b`Q! `S·hc9)52SJ? S𼦪,HȦKF h`fA4i /نU n`B͏D[G~Vh^ @mú}g'brF>nCl:(Q=?ܔa_Ζ1O/ ̠p%תM%LYp ߎ:aG9?&i@ 6ݟ`V/̎ q!p4ꧨg6,w Kڞ[`wpwHz/U'oCm*N:64l`Zu z}q%SKWTZ+tt}jo-OҢܾBGW^ A/XdRxoEǕ*bP=/ͦZ#Z.Txwjf@07\@?#Bƅ+G$zy~|?;~w+??[;ڄ4Qf^1Rր>O|=[C/zR^Re.QzFj3}>Lzp_~=W7nիղry2 [/R3/[7A$,\p4( / ΍vކTC1&(9tBe T̤R%L!mHXoEK#A"JᏯ$FcFIѣX>~ujTtK-!MbG)=hMBqj Ip˩BGSmt@a4dȆ!5S[l D cuR\D%lT: fPT> v6En ޘ}QTLxTv|^Qjq}bߗ(~2sR۟4YpCF3]>f9G|kXH3@4}Ĉߋ3AeC7gUN&J} ȕ}Z#%0v@oa~ϵWlߨL5jz% ;OAR'v囶{z;Oƙ MkՋ%>rNvx51N@E.@8;pz]bXE pZ$I8G`ׁrWz;޿S) #7xl:MHN9Ct53"w9xRv ʻ$z50f2r)`ydé[E'ic7xMe(%[4б:oJ޹[#D$_lbT{/6 jsb_(.k>>o~qGxq9 E7wIN(K* R3u R2zBn(%fe,Ԃ U[4598U($j*-`X49U:kA6!3//%IT{ b6oMn]x]--KT.y;-:__@6#[H^t'Q100644 go.sum ~_+ bwe  4& x340031QH+)JL./I-.Kgzt&=>i +k|BԦ'Tȋ;^ Z{C?|>D@A__!3/%(53j}/3DM@'(ԓhx)tVh3@NiEZ~UbBoL+ xv%mCBOUdfaO~`PAbFdq~drJKizANOSDPv@AyBss|d@t p,H4oLssCT @T.r(xr--<_S:ܖ|DL'g# ATF6]کO핫g ,T5s]Y{ҚĀZ#Dv= 8~ x7{;+{UbAQAdwV/C\k x={;d?V/l x31Լdv!㸯eŦY&p% NP_v{׎.ffjCTd2aγq54{.삨(I-.))Mc+S:)yZYnjuLMDQUb%k5 V~-.u %?)5Dc |-aM#Q?Ax>Jtestplugin1'@|?i둋.w) Obx_}JMx[qE~INyB6\A镟2M @8?9fKf/#rS}vyNhK:x340031Q/ɩKg؝onݪ v.ۭlsC$$NkNɇΕu;ҿx[r#->­TiYJxFS#$9N5iAfitqM>>>IιI3N6V.kH4p=@GG2]ܦ+k\]17NhY:Mj[n2Cg~j2f[ ;::BܖnM^'haY-ma7KQz+c ogx<k󩼁LgBK Le-l0:]lfvy2->fcvnǭ]d.\YE217k[YΤtbk˛vϿN;X(j[͛%峰FsqljT./Dv8SbmZq ̛SY+bod[ZХn]rd!2H[kBʆܢزQQ@޽pZlmB{tٺYxMoDɜn_N-s[dO'IaHAome6'0T`bkf.a}"JvZqKR4+Z|a廊'N=pMl&jCk̑hvAƞV@|ܲStEfg*rs{^bMJ6,7<+ 1D[b<‡' 9jq6剸#|GTxt8oZOp lyW$ (.rV[Ev@C<"[*0XRWf )ޅPkez= >=b|rگd $WBw!ЛPb 9'!3|7>".>JC%d /+N'N{%vZ_ <H e!MY()JSnIpCTth+{>AKh瑘4ԣ$adbǓ].҃fzJ,RVkGd{oPci2:A gƳoK1HKWקNvz*ECjLՔ(befAם 郾bS dY MFp qa'qw'f9Y) yФD8,a⥖ rNHI%ڏi}`Gptp?F鰶!i(m$IW(F}H^"=:(769OMM'u.f+5KὋ0 v"atܹB3"zCԢ9le5¥@!IUY$q[1<ϕhD:; [gcJ|<}`>S2F8[F!!)xqGNC"ǀq #^^aOo+zt98tФ]6Ky]:pDw~s91Z $ؔWꮭB u,!|^ ˽x0)Iƕ 徧h"ǡC0@с׷}Jj?ȼf63 &]PtvWU dN5Lc.5x oċF!u7PR,Ά[f)`is#K'ně=F(z/0KDj1*̔U{@Y К؈èɡTl"CKɠKȩH$`~={>SY6ȌC `J8Z 䤯$x͌i>'3u*)(D ŇմW ve{7% Wzȃh{Qn ҭZ`wH8-`l;EZeBs$wp둜!k7rH(Kp1.$:ţȅUO/DŽIR -qe"ǸMNysf~KHOy`TNI53cw}sqy=ۧIfG=*mR*7 |gsAT%:/Kr$TJBt A4/ wrC.1=ofu!}{BJЛUzs/ww^4OJԵFar׏pn caK}"v Zg>;Q Cwz~2AAkRF[Ռ q>&f'cY"|rxػ{C3r Eڄ{];5UM\n&<47Y<''ӑ"k]}awȔUfw9^N9;2p7g>_.Ґ% fi?+e%zUyb1rU IvHCr=HK@39Y-Z 6s!Z?LLeV kܽrKu0 5wF7~N"ϦIG(FOfk釲b!Gsq<#J6weytn8_t^=6)X+x !DgfC,mTO_?nr_uĶӛ"Id(*Li6N֫YcXV;,Na &-,SBDCP2Ѫ#%[< UHˑTp&ʾVn˘(< u"q2a-- d}HxGM|SjelQ=ۖDdD:}ft!,?WS291sqVN7xtJ*L6 kkd":n`?s/߹^;LY[Y6)+U6|oI*GiEbOYVƲ$U0 Ȯ,VVn޾ms%M) fZ1U1Ndr FwDC6q6[ڕMuxd4 攈\v0*y@vnvp^-6q6 c nvq( "erU}8C"eC huV@uB!Z:H֞O(eWؐ\hU@зXnf_(=bAr#q2J7$N( jBCTEX bsX(H Ϙ/*[ʜ3,+4` ,%LY%?GRbidSexlu 1J[(DG*=z$3r'rB p5٨S0Dq$JS+Y6#e V-M u!-_ENq3%lv^{k C{4~vS/ BAZNL$݅LfC̳I b+Š[`jAqLƊtN9Y@ݐN0*#]*jܔcEq<.s/Nv%*4DB4y >W |]\9rcpgЏT"ao^x9(^3|miϖBesg:o)#.WFڤI7m4Lw0wY9.]^~Fݦb֊:%*y-J^DJJnBOCG7S);lj &k*^z剱ꇧdYt޶5߯9Un[Wc4b1z ~z$V٧>>ػfMͼoz~N>;e{>f&SBim?/]._v-ES&:!pLKT3hhh80T,SٷOb[N-$%= ^٣C~cf.g{vY͎;oeݛÌkLΡ'G(>׷|B!XUOm gTGGF|#Qn`lP r-[|33f?zqh5~/w4@Ku^%=qd|P)~~-V v6OwN V?_f#kxM1n0Ev_w]m.4/GdCC $W0*'paCWN%bO~9z?|!af@L0&%0. nB.#Ɉ\Ѹޔ0 $Ny"A⸣ !!p84:>OYT(KU;A;I,,1 =>E]q^6)qaL5K뺩rE,FG 6Мm Sj(jmjrδfZ_kWO]ڬADKP-VGJhqap9K?%Fc0TJ OyMI׳sTьQxUoEۂp)QC[mKqj4)D &ʇWBA>SgS"#qCrGrDH\@j‰uR;e5;{|iɝS\}]~A ;&+\_<{cҔ!Q cZ(A^ݯSCQPke +26 Ck-Ї \`4!$6Z8/h\v@mj U>P\F`έPo&%x[c$PR >͵eƐ5 $xa[ U4!Tৱ3λK.W:MonnWOKC/#L̤)`EQ_SWHi\=_|00ꆗbdzWn-Ysz~uǡBvW-$> j3`v87+)[C*91t}5 U6^/9N&~{Z-(Yզf+ r ӫ<Hp 3+Pʄ/_k̀VVϿE횼_lqdӜm&_(VI\("اMy TRD*ݣ%[F/gJ@a7Q8Oǒmo(5P8m3%U_iyTn$S^r2%9,) M5> 1Q*ڑ} e9ܚ+NwN;שmahUZ`\Z%AR%,oE{ k0셚G)fcƋo.`OX6\n%PcGG3ɌVUp),*!"UZl'-&iŠn>J7XGv1H22}:~LV/~3 dϪ: %֍ضgl,뙺-6p\tK$}=UIX:܃[xA-*"'J!,!8 fP[u \:#N])sh%C-`[nV{Rz&S,Pcu>`{izYgqa24py:XIY#e&#Hin <(_DRV]-Su;ibTd'eQ?$3t{fE0BGp9 e5BO8L e~8|Eܑ:p~X:$L$p+t~E$8}`I[(<+x{Pgn+][rUFAtiճP#39~ff"|ySgZ~,v)-ࠪ#*V պ-%5,֋};أ>jcJKtCY{nECޒ#Ood\ *k6-F׆7q -T]_UP9߱iݻ[‘$:jxRn1Ekeb%X8D"llk/%B8 s+>~_I#U#{Xyw޼y|r߾ʙꫵ{xސ9 yf'Xr{OWGToA>6,&"Ҳ=胈O3)[RO&=-&i dzS:lI 7ZpѺ 7A-._, ǏT0" -hg_or4B4OKRZ@a݃'ZKz}0LاxI u!xԓ0#j=)2!XtM(hT9YU ,)>PZ9tSP^%r-_x9U=>#L %4(`ⱯeuQWUDr:e!yx93)ObsBq$6U?LB/^F\1ψyVP/I8FlybQb]]e5?0 @$_oջ#BSڅs߀L|\Il)04Ou[f~~%~䌞CosIQ:k }UV-;O/Ζ8s?rtu69rmXBwLjBFY8C5QF KFhIS6t.|Q_/Tڎ<YhyUխ':=@ 2ĸ: 4)=NAݩ,ʗ[?d‡d4{t>t Q_FF 6: `H-o)q7!gvyJ*~ToQ5V~Аn9^ܬda.sf#X'}^-M0y;E#%okޠ;b53_Yt~|o @{)E+A@ŭԡkY\i[ES@S` dxPגfB\ǻMύr/n H:f7 w>KQ)gJu(8lU,\G1NmzPOAK}9{`ʥ&`B >&l[ڊ^vbO2KHٟ?b0 nQٙQu}6g^L$G(M z`"~5H)~Ps, I&WyKjTxռnk^r};y ]n9׫XsgÒfSnnIW.g3%3FXnxR6r'bdRСa 5ʑ0)|r8T񁦂>pnJPO*lcQwjdRleQϓ7aѶ8crgEE@+d?hpx:,,(,T5s]Y<{ҚĀZ#Dv= iDRsx%Bpg&YҼb|C$#XO,Y9((o:vͷ3Cx5αJA`N|T ǥ.E  "g%$p=fD /{mg~;:xbz{=_L.aƙ!醰 Q]- RJ J:&pNpAZp]vTcXt&.Zg2a%3lO|7u䉳Hj"@*Y^RO_q3>x[q yvk K28sJS}<2Ry A> iE % JIJ@4| ]V;yX}KJ6oqͱy_>(|x=1NA Et_V6 KX;NfY03*asH JKg}~_4 1d8Q8kPFbL\M{{X]@{|D%~$3bB- Ȯ~9 (( ֵ vt$jBIŐ :IϧJBNvJe]q\^ h6(txUAY;C0e DN.8861({jnjnh}|S}{'X{~f~ܦ!cgϟ J mNV<6i (nVTIBq&aMQgoKO<)-zR;}-Vvq s#=YZ~LQY}KJ639՜\>9\wr@KlDuKJ2R8NCsH\?8D4 (J/R,)VON.-*JKNlTszLdl~߰ dpmxmUn#EU-+[ eZVŲJ\ڃ ihh՞2=;cg@`8#)'|7z9f{j~wwYp,zݣ1(zW H( .BHpY,f (hpXt?H b`s2A IRcS@)G©v," ȳ u&gJ|KC" q %es~! ]ifƙHZ0T+=.<^̵ J~WM s̨p^QAɬ6##qĖV%]҆KfeϠN"x!mH*J $〈k▕(ef!%B[g s|]`ϰ?qŀ$YXIr:BZjϐګ !n]ʴU ҃NфF[!ldcCc" J1u쵮]!2QD-Fg%158pWW~yƍ(x7Vkk:Vy߯xxCܻan/>c;՚D^'!pHU;i RTip@Ӎ O_]M+!t{=ǫ"c"cUɱ2d{7Jfi7ͮ3۪Tȸ;شfwgfԅ;XxYӹQV5n,$K_)B ucJ;'.zDKU*>Ny [x7;_2l>xmJ@ƑZB$xSC\3_G#j? )s|A`!>@p!6 h˂r%"=d|yAow)g'xx>IsgXHJ퉅sD(Tu1$Bv A[CSUuI(1AL6/e-k E LMp7.8ml*Y" C5+VW1 FF͵#^XVVU@@C"t 8Jʬlrhc=% HL<=.Yk’Z;[ +=8C*DY2W{~QBi-J9]3 "KEhrPv^zɰ%Rq8\/'"@]ڦ/1<.Q'2\=_X/>V5!5DĚGaB>CGJYh*{iuޒϋ6h'fZݴ,y9rcdw!6HU4Kf눻?PDP^^'s.PF4`i1ԓ> ¥ĤRx ޱî:,uv]H4c [#9!g֏'W-FV" li+GS2t<@JdkCh6=86Lf Ey0Dtx#}|? )chm/M:n%㡻d.yϺ` sQP7b/kDi7Zi:+tHbc+B2xw!wEK~=] ?dDAxAqBb~^Br~nA~qfIf~BAbIBZ~BZQ~^If^r,V %%LfԜQK_uF:y|5&L e|ix۠]qG!Դ M=ǜɽlRgU Kx[i2d.ق<ǔ"+[T[D3=rdf*ܳوT,yDxl2h`r~Q^hqFniqFUfBbٚ\xB7aeǪNISs9O4nB<: EE V UĦ1L< -%xvsB*gZfRjRzfIFi^r~~UbnAQ~I>XNxb9o~i^ƥYXsAsYWB&{@Xdw7#_ʼ!t ~r."Ĕ~b\ڥE9 V %%Ey\iE : y ļTʬ ɛ=R@,MZ2V(3/X/( '191'G(d R''jiij III-IH,J/X\$  =_O_WǂĒT\+|ql#xysf=u$ٺxXr}bU eRKHL,R%2JX`wYiV#,Gr.=}9}g*ʅp*mhҩ{GKd\T-'PA֙\PZoW*DN]*S%Y!1, RPȪH]V9! +\mJ+rZeFYKhJ i!pK%F㗔̥NJeviU0?zN6<]BXX9SKe^bybM2emVA0?{e,N:Fq8pGÁ]bFչrqTlL'"&~|JHTv2ͳh,HQL߱Kqk p`qQcR k1N؞ŕv>E~z%g'qP*=D#oIBZ6r(~!"M.KC qxtP:/c\UuÇw$|H0S|oicn*cZyxPe2 +:!?Iqg\^qU%@,82<3KrT'-0Nx'`%~FNjiXL mt )Ȣl%7ȏ\+1h c8:>TY9yOR+N^<}KH{/$(|%$ESibY.⮦IvuVm-%R>.PpAmS|b\oQre_ā$F0) N[@\ G(ј9+yCM{ 8@=B`0"x¸'N"[qR*/㥝7 RU̟sx66aEH٣hz|͞jw;޼M]x(!ʔ%rȦbVEF2zaJdh)8\$  #g7GKH03֔- ; A#UU(g*U>o$̐/,҂7M"#@,QfޢT,2N_uӧc7'H-j,?u&mxF|5SeFk Nu#-t@i}_[ ?!l[^X U^Ntѥ{lgHNO &/W] !LHю&_$*, |lHEKF8ڀ?o^:~kK)Un֑T`͗вѰ-FNt7 iWBM -a">1EN(wn8A>E Է,uG$cP4ba(yRi0 4{!Zw]nx%kk>?<{n/ l۟[YJ\]E#K&RS"ɺl z[/(]@͇ ; `5h}^/Z'.*(^Z6V3 K-RƠioz|73۔~oYr2Ŝzo4N5y(o{e~0j/9k|E}KmN k =Lg&7 0buicX{"kJ8{y[?i^3Zo|b |~Qߣ%:Ol&X?Z`O_4mѾ~cGQH=\8CfiĈ'ouk^>?_) -DVw.Dz/o9d["5)<|y*([o ??FX]brecDٖ7Ƒ4 .Z uG௏|J+ɪ*9qB =qƌxڋL3PBx啠v,SsD뵄NJñٿ{+<E]8jF~)EdV=R6xyL&zO~@zi(Jog{uKߌ.I[QE ҉?c_4gm@Rb :m7 ͛6?2>Jx{}F{`F~q^hqFniqcAd+SLM9b䗗LSH-*RUq*Iд,'"% X))Un$c+Ex]n@ETj@D|pR=$=ZICP /x#ĝY'Qo~73]t=n|z:o4gZqfX)Je6^[/ǥ]\pX\YMJav7}`Τ|ᬧ.#m(m$Φ*f;wvwvZp@Ӌ`&t %p&M,yM.810X %ȩ)44CKŒ@;ZQ*T"j_+g;?4E. C=hc$ G)1%qbT=[M&IR6?砑YBlړ|eDID?:׸*7Cѯ) %4ΔDrWmSPaf.'%\M=ɩ>W_6+FcRt E͈Z/Z~lΫKȹUdy( gWM׃tx=1N@EEV4+U ( `c]kf @KM%r# NX[( 뇻KHV|Q1+*V#ޖЈ<]TUjY2 l5NݑbbЖ`(OLeH p}lՒJXN;vfBKգy|Dه|?sGe`TxVMG֮c+8AI0$/Yٱ{{Za-V+e堚b{:U5;p%;? sCC~$!H"!q{U=k+F3U{^Å>\לּ_>s_T<} ?f/mi?{KVLx9!&äS5充_}z|dI{ B*2IX,幕a9J;YU(VKr^ji9o*>Ȧ:,Iku׾NSЮ2_!A=qF7iQoeNJ HwwP.'lo,& ,`BI]9x&woq+OuUZw6B:̑$[K"2~~DW=iS=ُ;O,LRG@ YHHL=΋ST&9!#gV^-{^HpVpN'It`2Ng8%+]J_N 9Cd}Q!G'5ML>K([RXnw.w{,j=ݡp98lfwTբ\}Uoߌn\rQRVƅ)%UOȺJF*.plsY#kF\7l_d2!yOd83V/Ў?>T:7zzҏ=$TNS[.AQl?+排9&:>|X&V-Wٙh(X4!S*,5>!jCgWل4F::7CX3F| I|\V|i&XA'FlW>q b.D+J:WF͓ <͔{\RV=i?- QUڮr) 5L1Y)Ph֜ajZGy*K[K?Hsp~9Nv/_% RΓS/{N4n'L]\;]_}UnѶâyrݽõ돿43cZ!W0>a[2Ei' %dgfV쾱=ڼuڑtW{m Ɵ6s3hA"y)@H#HnGUXY9kn9H 航b_Im* 9wvoGtƵ77wdF@,J #zCƘf[)G@-;>2;k\(F + 7N=wDbi0Q9;ұrAP9+2(ӻ> h{]KŃl@ ;Gb*9H U,fnBa|\ѣm h)t>wdue 3m-\{x-9_. S!< cw*_.2дe0#S*A7$qW8˜k4՝]~Las{96%+j:lq! @3xSȩiun,,IBQjZbCž |Q[Ϝh&5s7zo>U9p* )4ݹAx}?L(TԲ0ӑIoZ^.ϱLOW_qP3IAQFqP=S{YDp,'J\/H+8v`lTzUvс?c;cܒ 1Zx<&)DcHm,O56jӻybdtl#2]zW6{h<* ! wZ|J^${_L)l RAyU=ۜi]El􌽊,X,#CY;%(C‹"M~BuTB툂ڻWUT+ʕ.AO30 ,u,-۳i tj#01:JU`EҖ[?um1n=TQ묓3޺{?{m˖abrUmqB'7x:/\uL~Z!s0f ɝ xїO*P(n I-o~{OӁ%,sl<<zR3c۱U4?N<Ϟn&m ,Heɛϫ[FYMA-&\u4CQ9gycs(> I=j E"<򢷃j {_=O\'왰ĜZ'YS'/3m۽Q (2U">\c,/F[z;Pe7jQkj$-˒;dxsplјq06|-8&q8,sZHNZ@=-F hƊ̄W:# <)sSW %'x  ,T.àNc>sXǷ >Pzϝ]_}_gxdl x{Z7vm)xQ=K@BT@<b0acVdAxJHgkOw6Q}͛7OȊ؅& _ɒg7JPZ3lU; Fm: 13%)Z'~dG.~O~OXwB*RGaGm_T\9Djn/5>8V7}]mgǙ;*x,,J4f#4 r= ެ^6'tF> ܌Ϩ100644 go.sum] {!u2:4AdǽT/ 7\tZ{ <,40000 internal꛱ۯlKLnq  CG2-RӣUDQ<|H/<zg~iKi:6ÿ${]<B hzx}ToEVJCd6 EB$ (J,IXA:ޝYffmoȽĥh/ # 7.HH8S!v}osoߤ݀ʇ\ڛbB1S&|aBcKS3n@IK8_z. 2]|Rt4  66rl{?߅D%(c7 >5pR!#nl|%C= rou|x۷67LmSY`pcitgox.klIS2MTx*#' !p5 I?zVCv ) rQ0f)֣poI"]K&a8aLZ{NYWj dPň= T3?F>0ߢn9PqW)Q`,f]*! J9&e}ZLs'OSp V)2q J ւ\:_YD ِVQlb쎜 B^oAL3՝hBγZ F%+u6ԇЕ<TrA|7u4ct TW|hpw2?.^oX)W)VVcp1WfxL#{WU_zq1=hm vL#Dj9RQ`eߜLrTǧ;G;G>M=bZAoHBKSr'B9CY" /G7dT |0.tvƑ:Y, jGS!Y].ۻkt qT{ 41ό{9*b 鎼!%'dY RgW;4&tQmK^iz.l-lnWk1Y(j2*/Ӥ~;EDDYT LO,XEL-wUph;֗6Q5_+K;8\qO!1oi[3z\<Nu9]h:vIG6N*)bɻ0pJ7r1:Obc+Ebe?EL'x340031QMKghjڵsO j.¤ x){̌y9YEM'/ljh29Qfs'DF"flFF*1HgqeB UZQMtK,7exUnf8@' Fu xIIi%$ E REJ"%m~ k[ hjoK׶C@/Vy~~#=b̌K˦/^Z"N6'yv]vb!amO_nG& J $?^ٚҵ3c_M)ӫE1 NqI3@>|xn{rOV9FѝʖjkpmO1]ZUCrFJ=T7 == vdڎPXE:F=FliVj7([]&1t5 =eϾ*|B.&\v4:AG%%3؍{-~K*[E: c7l4 6[}DRQճ~#=#DoVn]\HDnpsmi  _H6'&>] &8&tMsA[5$qW3|h9:`rdƎ1BSXQw+V.ԥܦ܏ ޴\2 B _ tb V3)MIDM6Ź{?֎R3pˈp&ÎQ8W3 +y@2$kOҚst=Sqv512Hy'TVPy%F5k+%^0qx]=n`t0N$~AA n E> L@^zjj}<%3-lԓ|VK˙v2=TƖ/Ҍ!0 pDE@DK=Y$%b{0#UH FeV}<GX?EOVri|a6Vיƣ0GD*[ʷSԍ,*ɮZŽ*lS9Lz:4hEd0S|ߘBq~A:@QdQ1bIE nu'$W2gR-+mjQ/H}C7YDxSMo@=bʥP9\[djՏTIsjaإ';)Jf{(՝l4=C!0ZY􀹠V.*e(dz`sQ Qpq~xhc<86^**~O9qAY〾bK= \g {$,9ZkmnKjW`tX3gv\Dxqj'ʺ2{)7lbH64M% NmV0ЁZW!z&:`5mt d Ǜvz)IE*!:Ra!Yd8=;gc%%מ[z |m(8tZupp:g}|뺷mudB[좢NjHF@fF-IF|ic/~vqH6) S( P:Gf@Uk6ړN&?'{~2slHQvvWXnNMnR'ZI9LS_wksfM~ k.c];\[Vzέ {UՏtE"_tg㻠2?҇Gt 喯X,ջl1Wx++jpl1 u69gLJh߰}dy>6:z d}UCK8 d, B҅7@\1r޳  *HLD6+Pٗ㽆'}-4i4J |%fLx!adow_test.go2_ _@Y gq+E=b#"|)$ǼGiT~껓^>Fcv5XEm{,'0ndEts#/k%'ͬzxZr7}aåb?*ZmʢJdJR6Y`F4j?bpdOw3CR#[8Fqi ~s~ON'](~g;u4.~<\e#_{I9t*-p4V/Oj*-rQViPZc4P{jH U.*׹I˕5&dOۄ{~W34eJ;NK80AT1~S[ϝd):{8Y]~wi{yA'K=db1ٖcR0ySῼ]iSH'\L^HggʦxKMG׵x_}%ff E1;LhXq/ YwB4A/eUX~eKL L3]`G'7GXo%|iE۫~-<@I L%cmK|Wz2{d 0΍U4}j7u:5xc d -PVz 6yX׼d_i'J' ٠w ?$ E z}|J2!­3Y3צXd"|Ͼzy q&\cn.و%zV:qߔD"n^Ziqg՚iK3 V\.l tWX Vߑh$e1\?V)%=dKGٹ(@>|(0g0;`OIXܐ~kMeGxE7=)[cr)Ct/{6{o1sfAUkX=U_d_zDzFly\9eYϒE\? En Mަ&Kj `Yi"BR/R2ux0>^ i'M''烫,R2-k6$ަWit;Eꆎ<ϸ@2;{L(LVVVrIa(ڷ+xf,(en>QAˏ[ Gkz=l ~FV(J@XAe&`~%f>z@i!7i92fi)eDw~>)__$cA8lu&طg."̛(5p #, #"UUG] jQO .FoNF}`S*4Gf8vL5~Ⲿ.ǥ~EG;Drח@xV8*Z E퇵J. Ě%,:d(Z^uEF%KgVt_[K"]:0_3g&l p +ߪv1wðM swNovY@# o:34Z*٣Y=cLE%pisY"L FA661En|4&cz!5IۦZ-k($5AF5>^o(n^''W@Y ?ABdK^w~c4ϣ))ݠ\X ;R"NAp-7iMX'{mRڑJv DQ^( DRЪ,*ERxBO"KiutT NXk ݁|؟&I!tRʎr3ӬbǛ?+9!VJD˵MBzg!U^g N#j!wԙ0ż sʘvKO߰e;3|uǶ^%2{\-IIΞ5 7ȾШ<>~#Rﭽ֧p?|}oa鶎v&ExSOk{[0xyz~A8-{Xdn:X2fU !rJDU? vw+ i bWP?_^Ÿ"]ꆳI4sUB[:O㩅-S< JȸsXLZ-^/舔'ZAp;J{Dj|tbi_TzS!6@EMf7TءSJ4rwAy{-"F%ZND%TaC=xWhVAH ޙO0 $e=i&AT:ը޸sE&YbL{Ӻ1(ot@s3#}ɀR|*nJ$$g3H%5'$`)Ҷa%yxly&ꘓ]&gQjIiQB9f!aFͻm62Mfl(! A M-pP9(T+eajjdx {6a˚Z4$Pcr]BrZ&W-@lux[As \|$e xx*),P졏cFaxaFL.|sxT<[e {zi RE f r $NQPb"Emb A,Uug8GDi/1bx% '7/=;{s"r Kx_h !%6" V# x# = "X-User-Owner  ,.)*'/,X5l:9<jdxm1N@D \OI`P(V8NVZݿJ DsG\f{r1:DK 0 7UQG{[ h7qx8v&մ:BT\=|I%7=&o<xj1ѓ9)q2}i7zSf*A'3CwmxmUE BQ\w B:d 쵈]ӺqwͭKB!]ha9BBrBD`G|^';U^Wӫ<yP&uI6*rriJR:"6EՂ)EOʑ׺ d)N0| ])f4T")"f"xkTY*X @p:,┋ c;ņj$.X[d]L %u>H)Pk3JISb,<鍮V fJ ֪H&׍lg@XJ,2D((|Oġ _frTkTt@j>U+_am|D GΔ(:n֪3f a?G[crч8E+A37Z&]Q>IqXZLQ9&.amcj ʭgKU*:0}` UX p0}6ɌnRj dz . 5߮**f/2:;I%T>SIjF_]~Fxc`_'fU?ǷfCώǢ~-Ӧ >Jvt +hXw1k;P4LI0 di#њ4(EXʓ ]Md{7$)r8yiҢ =N"*J\AfCarq9 eA.^7_jVFbӧ ?†钼KG^xS. g!6whWߜ^8s G_~{o̵+~^{xɍ܂lTxۖ eCߙ+D x@`r sQBmLEɓÅ&o,J-)-SؼFXo#쌵93Y`}px8+Ap FGMTM)H8NOjnx{1qj?ㆻb7H04ax('U'>zKt]pMFbk408&`)2n-wnPӃųd3c+!=˸qt =openapi.go2S#/_ ӌ-W I"Γ;RRQ5kG,</ Nzs[8 AXC-Z:cE'ulnUx;xI Kn8)?PCx;57krWH m.Iby3 en'秤*X*E4 KKJu 4899 R Sbl&'ʉ%y'j ҴIM[ $jRsSA||Mm(A,Ii.^AŚ %y \#$'WI '*UT:f* v: ) ?kc<ܘs3,f[LgN>4yd lzNLS ((*mL i%7+Le7d x[4kaVVĴXcNEx{1n6, 6oS7x''m4ka=H S ×U\ê+}: j 76g,V+|o t1.K<*,9yo^nQ`ϓh.B oaֲ|ЄEԁQ{T [ zmp $lCuj29LUJ`ZڛVH40000 wsxHq(fIUklxyC]dh QxWnFbB - tK^ u@.$] 01y$ L03C+>>>~ I1ݛ6R4tjvQIqG:,=5!otMM!zc7.RxΦHp<}h8WdΗT[mMNyW7G5/XgԭMJ U[t6; `%ͷB[:K8l`MS@o@Oe [kDsA.;Wr,)r?/^)Wē-Iܹmwӕw BwlbT!;-)#-/}eWXNNpLa ;_~Zmk:{yݴʕ-BVX蜅@ֵ3򞥼W'WL׭- r.zii^\yTϺ(V3i:(t`7Pa,{]!ɡlGkZ.SPImƎIV5|!qY=C:$䂕tE ^^,W7 [UTh?ǢAnUκ2g u@.p|[ڰ6I''j?eٱ\e&ttf #U[\Gb>;<TLpS♁ȬɉpMb񣎺qӉ[a1@߷WO z7Wk~{$‚kzm>kD I9 TwXش|=K~@Fq/9!&6U}YR𩠑5H!>K%C̙Σ`FeQCOoC'x,5[@̀;TV+&р)y;CZXsj!}I4ϬSۺv-93gmҌ@xI+ -"$So4JsTtPbR(mcB1hxo@[t`8*pxJ#Sv]At-nqcgx T]Z21MrOqOdՆ,yG4t^.zƃY~Œr٫7g%/LT{~TG:eȡc !Th!"~s^Cnv/|q>L/'({}lzO cu]xۖ~1ejd%x4<RrR47ߗؼ_;3 8x{8DÉ6*3E7sl~e DC yx[q &7V^w[>Q]4Bx]kAI[ZwhBڦ6=4(AA$zE&/١ufҰPY]Xost.goۨ<q:'Șʋ40000 internalFs9P +QFd4-6 j'~/bd뀂p^1Waxküq3듏|1Z d Yxb~hV-ǂX3ק+%kh*Tsqrf))X*$di$kZm2s9S\42 2KK RSt2RKJ6Ƹ/2,x[͸qB{蛘3 N:0 vL'z dx340031QMKgpYF ]+ߜ:,g6GxEϊ@Ə$,dp̮W9 8au?uҕIݙYɛA}W5r_}U?_v= A4 XCuP[GWR:k[yhMPht| '2T·HBh k?u NXN@@.׆˿1UL0SyPEh2o#,SM/`,4\U<Ceo4 fpvvw(Ɍ@1bpyg. OL:9"(2.^."z(&Ǖ2]ctxE˘ilMdj̡Jtz5:&ZcL * JނRgPr dbQ1Xy(U¶ ij5-ڢ7T,[hڜV'HEڂՉvȳ yB9* )$Ni{y*)o%<Ɨ4vyZɈ$_!߿.XKs}FB8$]3k'Į@l%o)ijkf*[]թIpCHL"?7sHr H(wCP n^UϮ}{^g?g^f;uD#WQ #s5*jj'N]\UʋץxeDj%tE7 F"8AXWg&E,EqNz|O(8f,j$x$# ŕ4f_QwkQ;[+u"F¿*a5{":Q-r_ 0AZXX-/C(֫>*|3"zM0b!D®Vw (nvHN"S5sA'\z,ko~)0JVV@F@!. ɑ|3ǿ׳!NT,)x%a- J:E!(L ޝVd?%({Q!:SlB߫3ǟOW_b<3`u+N (!AxSzʦӳ\bxT;J&Hp ,CTVcуw ׋tsWoIp qT#eS&$e'3*@ @fYŹsL)݆*:RBBR\'&I դ nTA 8` M_je\lWv_w3V깲'O;mcT~$QE'#1AnM*nG]RAF-*KuHk(۸pF ,S椅@ŕ(Wɸy)!>'xq(z&$&ڲLt($\ص@sǁUkUI 7 H:$ְ==U 3y*! g bq\_-, m9g>XԒn.hvA$'hߒu3(zO#bM(Jv(,J6.1VEAr*.Pg&AH8 ;[ga]qy$ʖF8˷]Fo*HM kԷpHPA VPyr. ڍ GI&ZVw G BܡyJq_g n=J-lJ {Z/L]tSѥPóh`j%lQ^wsT%zwL!7#$H39stfI".] JvpGfpCп[t '.@ˁ,Bg{zN]flpp!<%2A prO)JqBk [caTL3TU7)D!*[vG7ϦSr 4.J^Oz:'aH9WǞjCfP8?ԧqʠeԌ[e-w*㺾ϟ<Gx gu,K.փQJy')DJ6&?j|=jOcPƣ>ߡ>_+!k2ȟ y. `L8)i@(֐9= ^JsF8Ls`nDK7T8 wyEc<:L*՛@pI텀!  E@Q~h2GE].rS ?QbO-5KK+ q:q4K5Z!@ibCl[<@jkU(7q{oZ XK#@&#BDPhט2gs06^ HiKS$IȯMT@b~ W^; pG.xDS]S{1!z,^βxNפVÎ2 ?@"zٵhCy|%9$D+NQ i!4Ҥs1[3[TeU=QmMDaQG\ty(y_ƒ6 ˛TĿX (*UJC}iܻ%IcriDP&4vӡsPThv},o\-k!XI8!WI;i3А׫9 >@vrN~^yr<1\YR 4W>%tЫ85f^ {џ|IM?jڹ|yPXL l o:0|Wm[O{:TzSCe G?xJ-=vmv u[b.>w+$!NOMhnDCnIV/-^f4@b$!E}2nԼE5pu4@1垢{ 8.Kٽ̵u!+Ҩ4@`ͰhCRe_.; Xʷ '2死1L[ #zIcUo_Fd5#g׹|` N}R&{6o噊; ,mu͔Q"! [r RApN[e}Kj$hU, hsE-L44[I"dv^Ӄ}x^BέRHGU#1VG6B8k瑧Gm7) /ޟFelvߧhJz*R.>PHQ!;Fp &1Ѡmaq}QOCÁJkW/yD8VGh0 Ș廆!6[s`hCi&bJ<>< Ւ쥾@Y>&!ۊ.}|@Y1ŗٴ:s|=tfҥT-=Q}{q?/X(8I1j*z0^ Jj7cR}zh'f'Щ>̝Q*i Tji}hSSv_Z#5ZcnʱKw[ΧVk:]Rgd܅MgBAuj~~bPC b𛇯.7 G;s'O'gTco/: bϼ8PZ7B/ ^\Y[__]D[KJp<\ۡocyK ]}Ey S6*_m@C՝NqDXg[;ѽ$E"xn%%)=HwӬxAecj =(FYｨW y ͑VhgD*ȓf `߽X:;[#ĞeKULګ( ofu9~Bޝr>mujp d100644 generation_test.go@=og>*r<G vCP& c:Elϰ? 1 9bd 100644 remote.goVHTrLw?哋 ;*:!_WMΌ$͒WU^{Uw]ݺ`;5yJ=tׇcUx]vs՚ZRoN[yNgKKBWjɹ2ansvXtH?s7/_u*wum;K$yS^q_TIr^ݶ56(ݨ4u0uUeh:MVN(W80AF]nlI7*KQ6*diC`d򍭊震{^mU`x׷TOiq0n:/QAf28Fz\>~RUg[iJ SF˜KmR+sى h`me-i\ub74qjre{y"[T๹0~֦1iR~ØusI]]1X# #{{3u\vƏ^w~$IO]W}i9^~P00?s̜0mHjbN',8*g]ƛCm>,HI 6Y[oBR6S0>0BaAb.;j%omkdD 7@UR`poL5H؀kיϗᣙ9b*Z\ه)Ƶ&Vu3P-Ǩ6(B<\ mt4귟7RshXvEjgZg|I!̫PYWPLBjogT <ϻX#0Dc$# e'*0IYOjcb&tLC"/~neO]5?_їbx7ؤ7KXK] >*#;ɐ֥Q0H-(ΐɀF$J!N=yJGrY6q쒁/֠փN?7&sA1(m&J 2i `˒ILDz 0q}|#bQJSʔE=R)y} cް\EH_1xP.Y"} nQ^_C$%\ 6r҂. 2+[c^=ރ!Wdi!K~̿=8{7y$1l:7Gh ?ga ?P 9Kj[\/uk8+}ނģk^bq4]&5?ځ2ܰԶQ6dBZЫsew`ퟪ_#\xn|k3XV]pK"I 9Bw珇uv[t#vBdf Pٔv>bM,qj{~kk  l'm\T %{PɥngsS|\`;Ƅ7M#q-C]Z8q%u`oD! g1,QT׿{}ThfF&Ċ\ UVdww|]w+""mljE %(@k$k&$bhWԄ Rā<-;Ne ]W'mHUX9%\DZ;HG׭Х^{w Cְp/./7.h %cvO1>X 6}¦Qr0}8 :v$.^6 f8_`y|w {Vs7{mLA_Lc8qL"c 7!%Tͨ20T1-8u;o]@B$!6 tmivev"\ Mml BI{l|0HB _ˆ+@}9X;Rr#t'= E* ; Z{ޅ9cvR, Ep!X%ߘK Q=QNTӑ|K T? V0~4us5E+WDAl@Iu)H/|b QD8O!|omed`4/fY87[QnbB|d?M{l/Sd̟Uf+4JyYQ5l6QԿt-AvɤxGz8HޭjMYBKź$M ZJcۧ@ߍn ߀ಙHS`7snI -o>ǂIxQꀀGbBn LIb[&/.L0]~abVLO)Ȩ1d*X8w_kЊ F_[n{Bd;ӞK _61;j+ͥJb6a׋R^Fir =_vw rGv3 'JHۋ|`V\CNndfڢԿ'~-#BLОPr3Ҭ=L|Fa[$,C!<{k;TNs\89PYM' (%AT;` '/o6al{ahYgʗza83Ka^%B$d¶5rARk1Eն3 )FV  |Bg0 w14x1ǽ?*NL(;*Cwo4#Zey kK!;]1/|}rL.tJuQ!v46#wb"c찁 en*+YIjoHeƨ(*xuk@FjUˮO-tC zz!Ͱq'.z9yB^gə 34&# (6D `J1Lcd"l4#PvT^9{D_0vįV'ˡT}؀3 %?ߵ{R9f1Ђ&{qYLI]ڻb^5L#NfN2oW4uC<Җ/5IUjd7Km`p,H&! >T휰rTb^SZ1jjWSm9w! ͓T"]V?.h!m Vc?^ՠ85-i kgk%OYݷw՗%bJiN!%.|i]]&xu7LDmRּ>j_x;0krWH m.XPQCü 18xAKAljM mMe yY(̚eS=JZfblfd6 5<{. Jz- Pni%!yy~ޤ|M!F1σw 9'#ҩTնFq8rpL 쓬aZ@ur7u;DXbUa.Wu\'+ֶxbv9iC8h]zQwppF1!?-,j!+ǹ&<[qBO%ޤ}dN{h>ϯ Ek39y-ψ5yCQ9mpwH%)}Sȗ3gNO5}*Y(cM(۹ŢeCy j:b> v=3J:7 5KdNDȩ2=+?(:Y{XW4{#-'tݼoyym.Gߊ~0>?x[x'al[3YSS2K46( uHexre97Y0Y+X*%楧*d$ih*Tsqrf)$(g9 Hfn\k 7ph$edOv|F.-SX7Ko^pu]*}8xB X'ln< nadԢ"+[ĜlM.̴ɎR|muAJS8 |ҒTɋ|mk7me(tSxsqǂc6 OP"rsd7 ?xmXoKyIq$!7NIfq2(!S wg Yf gV}iARէJV*o-# R9wf?\Ļ;sw~G~_~VɃ8][]jGfN$v*"/_84aWNC|IOUK׊P T4UM/wy}E4it ]tZ:8'2CqAqr"Hqa5k)(]?@>s rA/(;Փ\.&TzZN$Ηُ/?M{=X;42ksb5jLV" b}iqmZ׮!t=`$4rj%9xvnNuW*d[T" 5;Q4=LhW[#p:vW7>P jA4=o/ꗟAي`O`8o~NstrZ."xzXÁN{ʺ,NsUE&'mv]Sgz'LNSY5aRrFYLEI“03q;f@Hr54V}csMoZYtCV ENhi5drQ^\, aΡ#P5xSŒ&1QL=VSdK"|JM:<`.a<{թG*xONG_cݒhl?sڮϏ$34=b%ruO/{FA-_y!OU@bNUQ&9 7]?ëw8}x!-xi&@#r5rt͏*=zq݋S.z5{UG~n̾x۷GhJj{-7p#<=8.nL?Cqh Ѯ jt}yuycymc._N~gOzK8ykް: /@TS ,-6huEFqQޭh7CjYd PIY ?}7 @oOz/SZfY3QTq̯ aj:;3{֊ Um}}J"fwWLݵt" OFOr6 K^iD q&_~TܚpJ33p>~Dڮs|hΈ w;YL ,&{m-e~Z{6G"/*\ƌ⮘¬CtÛ<e+4z yU2Q!Lh~3C1'NXx{1q6, 6ov,(s/JL+|F@H [xr$#)-۞>GE,"QpؘY]I{X R$q&!y֌" *vh!eN;Njô"#[Iv]_p r4/#'^>.|o4Q̓rp$"X8v)$"L;W:*MPgMYky˚Ja +WfGoP! D,d^9eecbG{X;G jIIRbcueNz_2&`a? # q]wd\rڕjzݘi,=l6gȣssh)|Vi3zI$>KP.#Tk[/Ž_C ZZ ;#yULmRuj[A^N6/Z5{cv󽍼C4Md㿵;q9=HC<4Y!fgkz>+'5}(8oϮ+hSQE\7I<:֡9ԏ\Rz"ʧIJ=$BJn0z V)thӠj#d(D3}/9EnKX{$+ ^j.͓TK 9@ez5bq2j(*hidՀv`5*ϑDĚcX?\i ijSiW1UdxL0X6l=ȝ&;ZRApo#ϔVVhfO?қ"izݤuvϋFT7 eI:+k((Ʉ9M>.W(r0Of YA pY5נ:hPs!3EbX"m岙A !gY!Қ\w U1DՠEl4ՀLC{b lr2N/U!]!o#bM^@EQFp; Z6ɃLN.]g,L&ْ.OD#W8'CA'zp.zU1Ql7aH8ARIL#oЖ*rʠJ"qhYNLc0"DWÕSIDBg0gX2-Q7\сi\fڝyD~pGuo]I 8 z[2ʗo~lY+!$h fAdI`-11o֦J&G~d-2rB BU25's]EP_FYVkJ6@T.hmYڥ󺠌ӉFӠBO^4-hFo tFJ@vG ]z H-Qr˻ۏr5(,8m,<,϶YlmP;tA埶M5"4ɑ8E''ͦ>1:fM2@Z)8V{[ 1*K]XA5+$zoa3Dm@d) 3tbV -P␑IS\,K*'h6ַOу&b2^ [kՕV90&QZP (\hXa>8t7zjhr:z.މnOwܽ}|7ӐCx2GkuEW?] :B |rkoTS87¿ͼ': ~wT8\P:YS+ctzDi%~=cJjt@2m.ѷ aWDn|<@ Wl. z ui9_6ږUE@@'.jOi j2$*=(olqax|/CgCAJW]xiD_;D.!hJ7֖xpuY'?HyvZuK ]DIa҄ x8ܪlK7+q~01$GqȈw}Z*dh+IgkL㆗PMo8ZG&dʫP9>T{ *2IxS 鿏UL B` 1 CwԳ蓆Mj-vĸa0moꒇRe=l>τ^σ\S \"өZiM肎iLԙfo~F|RNGKZ.'яnL6u7bz}'x|HyC/ YExYwm3[iVt] 887SqUxq lizy%%żYSZxS##uEpjd p5O4u <[,@zFzWE'z&3xOkAYAi*mO/Xh"VmA z+ͻ:3Ro^I^Y~ޝU/:P Өͪz~OmNtgxq;s><^ "BlxmRk@f+RvEh/ZBeVa^Dd$C3dӵx' lZL}{v݆dJh01Bd40|lÏwXZOӗ%0ڀ/Ԩ!&n3$| =I@B !!*bՐءcUҙdh)LKnFTQ9*BMc6o]@ t퀖cJ!I6,V2)jZSY@/I?eDGOIE*UxS,c; ز9<,7WAw6%3URkZ vҭ&<49" e Fr cjjY \aGJWr;@>zOF,e4)|WJ(WKJVvrC͐.[4JU Cm*IF#!Ej8]^7#Gz,S!Eȣ#:ncگ%7L,"XDa2tNb}ׁPTYHzpjIn%i[0z\,-_M|8 g|}Qu+9;VWL]P?^.|yx6_~u=xq' ^R:  V z9y~)y@r2 ^-L%yZ#9Dxq' W&{LHc3Y׀k?O <;xxq SZdN,2}e&izx##Rkw]mWX1G%MYdfqx\J@4PǂbulqO*tW`h ^W'=zuVۮN,<[+zhI>_a ާK6C x7B*p{100644 mcp_compose_test.go/C_"c7$>P}\q r3Lׅ]LO][ :@ 2 ͜;xm[gY{k>x!d1 W'x%`CPNfYSifN^~r@v[6IG<0lx[0}A݆ ,+u`x[4AvT|7L'1d%̒TD̲T? MԢ"M.Z.D̼Ĝt@~BIQi*gQjIiQB^foO` x E%E  jj 9yz9y!9œဩ% ͍$F mP,mŕ“c?2%m8)cT'?9[C3%5-H.(J-)-mf3y6u@EiE :  V Ey 8rqr%9畤Vhl^LJ^/K-*KMݬt6E٘xnxqZ \A%E#q7G tI)X*$!$8sr&fJNыŵROwdOVћ';D"ۊ/fxJPFKM@iψ@ICDGoȟJ D_|!$6u{z~3 moD !,.`&*M"_Ð(GFS+Y#?ْP*'aAZǾ4ť8EsTTXʖ^!#74&! MBi &hPt=&F7Ȏx1lnfaO=kD^w hsGnCZYH3&pՆ$0u Y#rm.Zf2u-ch>]  %>.h`bJ>ˤ֧͙"JjjGt+Z,.;ć,ςV2|mL !UiM q ̂tI[ptfs r̒=(67H)Žߩ-`I`1ȘCbNm=F )Jtc Jj>\ڔh 8: s? Kv<]a'{DLƇokgk?->,XD1٢/hy<.YZ~}5H]( #mGN[/b.l<8yqvi1Thb:G ﾿_;E>I04 :9IRQu`tO cԒ4~}srKG,z~j蒭_?sc@2β#' $=$zez y&JH"qfwph`و IV;5aOV)R8§Hܝ}͋L4gCts%oZ*SvÕ?u~HU]É=~E0WW7oȇ%7 j#7r6(/N>ܺPiVpO3 ea T,c"uuu lO WlfZp03lSCZ2(z֥$ 61TP$:ؠgI3N)U hxw+Pxs!o)(j%Sp"˪aIX6;]TJym* e-Jzd 1>)i?hnz`/,UlΛ Sl% {dnn}BYhAbԔHZ  3iƽob2K~Xy_]Y/xk3geibҒgÄ6:8s+  x##w@2Iʛňy9`=-fET1k45P?D?@>8>Ƴz}fz[a[l,RK 9U~ICU(=M100644 remote.gohPi9^0:2 ˾EVZ;Y]drv *[,)z6xi%z\- 2A'` x[=#uCSZY&w*2+TsMT|3 lx{cfQkL% +x zTb~²1 %E\)%\zI9)y@ĜsdRJ2SIiE@-eEřyz))6nKIQWU\4'/D$@!547(hOfqIjBQjA~QIBfd!uɗ4ͅY铟rnQjIiQB:W-=mHt5x^mDy8&|KVA\/3//H/8U#XOOOZ((O\kG^͡<{9oq xeUoEV#BDVu[DAN"p'5Imġxg1;c;Eέ D/HRp'z,ͮ"(|}ߝ;}| o{E7V.Cծ{} j$hOʄ w9<>b x„4%ȡ#xG!u]9Da?| ZKzcӝ!;]TK``&U" Č\]H E` ,ϵ~|mb>7b Hzt"%Du>Wu;ѐ <jd/z+ICiIIr%:_&! TS*ƒg߲Ϯ~\ƿLCOV n6N39Wr!T54ώchB(q"1i  þ+ PGlztn{۵l<E1zn01\VI~CPxXdS耹XQ3jPUFQT,C jmQzp̂߯kn~t$rNSʌW&?/3 $:'ٷ[f_v`fx["'_)B =x%yCoFjNBnbvXJJ@bJJwjF^njIF~d(N42B @M֓uu ''3yr&ڱ L-.졫`PP_ZZ^̥_P\/H,Lnյ;n4F 7ptGyAxxq&f?Jh%dqq%8(f敘pq&fNe+$m Z[XP_WPPYPP d$(U3Kt]\8!r i`- -PS2&))d&%*gX()& OWS[ʼnpbtqIj+%5E_Hnsx;ʸJ 1AO/`x;Mi#43ȏ4vYv[38fh``fbXZ_Y_Z\!zcʎbgD=dkMvbJaxi_-þM}nnJgܼQ [y\sS}ar ˡɽ"+谺6dub1>/`=I 'KNg?rFQ/kN׷,k;%n9(1^{OX>U?fqTMvE9{usw,|y\PxjBN~b ܀Lw8Lk -\wNzHAעLnYBN U/]a޵ͿʂvL%ruf'ܮ" .s|%ooU<@s-mY!+9R>s5?&OqJ\_2,1k+|z(57$۔÷tbWoFQeK%m9+l}:97\.,3lXJUpS˅ [n3sJ,%$Z7'ҧgN\/U<+z `g&$ඖPJB<z =n[Nd>Ce u Ԓ+|gKDPJ6_$߉.CW[-$,C`^{L;n|)= e ` ^UQ=R[ _  k y42Kp}]H ED$8:s8G<|iliGh/i;{dE>% gd+g&+@u8aT8v݆9!7H c]8gx1YVJz 'Ci ,l0=сx\'b lƺ ;'<և+'8"YLnt &pdҤאvYc<1ZS+|'egԺH3j<0D)􄊇\S OKq2$T,RS@mh;cԂKh]l 0ƞ5ZU i!`变 Z?Bw;U#wۋy̱"\h (rv:Fq; y5mٳ.ʅHx}SecNarcQՐ{gVh}a٦waS|-{7Fȷ_N[#F zO?DY_3iGxi ӣ/ -LI앑쵏BgLe<[(ܿ퟇#yxF!\n+~ƢQ٨8ehW>)xS*xTMQ"xwa@rFfN^@QjAbQrfue 7)ʊvbT trUZҽ0%v߄_@1gRon'ӳGmeT+]*=P?_0?~ Ci߃9~ AIcb L:ԇx}EvF 7;pTJMF?,x;?IFDԂĢTɽl%E3Z *x7/jf`^&< x::)Lwq]vFS?{}A|]Gx[ϼygnO4=qu 7m x340031QMKgH'QV<ݏ k6Xjh_֊ xYrܶz zҬ5?r왭DjlIz:%$Zo>:}>a P+L3K"@~{.luLF|ݎc#ta7ZsxYv~>k}52vpEg0m ƚ|UV)1ݪ Ԝ㫫C;s7):˜v6ҤEV0Vຩu!|Эlg66ue\X>Ћyug Wdz؍wKn^7vw+\Ef]Y3=mHFV[5~wHU;2wXjCţYau'SYtyͪ?\20NA25˚9k =ڵ3HFrXhyo7-f;k\ޕ P BuMޯ욦!>=z}a_y嶪L[Yd7e+-%LzV~lέz)S :<1gȌw~)cnrU[ۭw9wƘ#Y伀ee7F ;pW}79eY4V+۸zvWc}()' @urBd)jJ?4k!؍3a٩SXv8:5B&ŪTcPkf˰ٶB0- aDpyҋ$k4, X+2^BUļ:E*'=˛viqw7䀨Uk Rjvͻ.m%cߤd?`B$(R%CH,lXdg=[._ F[XԌU"MlYOƧ{8lbexQ; =#Qzz;n7he]wCG>yTw79 ]w&&~ǢQQRtxe0I5 f`@0&e͵G12nBYa `ndxko! -SC ,LF R@O͒OmQi3I4B,Rz`jM [V)An{СFuȚ ~DA*mB S1%QZ6l R,pHgk(h(%WX_/aVbߣHLhN e+b-02HYs=hx2Uia_C4"'GO`HIq+(6\ubZXWn _/[M$]Z}` &&Dh!UW]{rU*)V}'/w""^Cpc -`Nd=[\Zst~#՚s_ASjhgv+5E{>ց`/Tb˶%BHl`XيSr tVU&ΗbR< %+ C :ٞ8tvi/OC()Eh 5@ .F˦WR%@@py끶Zzr )}D mӣ4Hi-ssoƝbZm|)jPMX*NT>;2&π;Uflm)AQUgի Br&sGIcP ZC څk⡿dLPm\_̵ o(b0(<Cn҇U~~  Tif^q e5݊G AF2Y{J/a'[B84]MJpA7d֖cH fsWgHsԭp)$SgShlqAm\/n'H髭2cW+%f~s|}r)*2  aȊQSq&'\Gj 0QY=JAWy(% s$뀌pWqc0g'gG[j,IQ$Hscbkm1o/At"Q"G)Y CRRy*+d$&nZy@Ny].\+ެ{Ĉґ,˹Bz2 %1PŽjri(ԼPV4!.\r"m tڍD<ܨިi1J\Q@,YFnǯȗ`0Ol/rώ75cEx)^2(Z|F?2~Q+73bugam'})B CMEqZ؉F#6spgz[+ϝUc# ams8G4TBDtTT:. 0O^b$B͔ ;Q: Ǭ'%N jX1';AnHNbhG]1N@l ;LZ4R)xEv!=KЀ1͟AeTJy:(pN S `5xbi߮Z[ŸyGbo Y>r<շS<S):M&2U>;$`zcp"t~T@P%GrwlTϞ]7/wO.Sq"@>k쯸K8>G banS"K82JTU dC/-ƉϡӑV=[ 7Tr:d+f .ZVbV:AAAsN jZ =6 ZL^Or|^w{Z:0lƒKOKIɽŇ_?`&W2$ W!,6c&%vo g };duՂgJH:nLt[W#l&I; qӀu^нnfz'~Gr+|l*hzu#mV!B+8"k ;"NB 7,r04\l sfts."]GPPu=K^ͫf.nr1 \5(y!?601óC`ejwœem3KTihD@ h,/Ia0y|Tc CZl)Ad[lI +لwuPչglŏffH/8>Fz-4M$~?d p+ I4Ź%t60W\r}/wU)2)t i@08xURK@Fo +@Wjbg" m2i;t2@I^ċ<gNuWߣI*Ō)AvGV8uһޭGե;U&<|W<aH=ԭJ7UqjF@xh;?NyeM<@iWy~k 27-KUrJv,z&tlG&_&;ɴ Jف t'D챶9OΰlfA apϥ7%߳lRޫABۿhqX lnoդWn?@mx[bCf7nO'R b &WxTn0}nbXb-Yԇ"^JAO6&vd;G| glJDQ9T}Tf( GZ5}\nG_ٟLd)jF[GL)*Q-21pPt,adE#L7Zw<)y1j7Yj;>Y8L;4y!!x5ʁԭP,C ɏVnyܳ&elMQU6^k:cOk@͖ Y#-U~>âSzڝ+_mZ܍cީ+Z=l-ȗf}睱ogg3'Qhhkq8 8-dP~^}v}seY(lt Q?T1lk<ѧr>2p(H :轁~N+pF[4蚽(4ihEj!"9sZSBl -"9yz6; Kpn3aBk[ \Stnc|L Ud_z^gv`C]mc7{f'Q4ÅʝÁ?*&Qdeϯ?vGG : *1go;ZYKTY`c\лdVxx@0 QJPNڈLaE-ഈk R #XF9%@q ,m[и4QfQE]BnVyyiNSow!ߧU%0_X 6dR+12;koPd)I-pI #.2+䧆PU%|W'>/ƇM LaXYJpyx@֯"p~1jI`KWa>ANն ̟߱M:SF}Z7 HC%Mhc;0hB hߡG%#$ڬPgC}'WKj UU=_>]U wEW1|EgQ5 㗢EGO8B2+2tMZœ2*Ҭ縄^WI5Pxz]z'Ԓ#4iX-zIקdg?9~"TJ>)䛠VA 2e}nJ?XaatNZJ>ijQ⭭rw7Œ Gw뛆6 bta4gI6<>a,]]*7lx|0qC捚+]xy""M`~q:3XzsDžT󓥊_0 g1ـ"meq1<@TXN‚w 1n>;$VZXt`FЏ{r,d _7llέY$$&;.I/l`.6@x[͸qt~m>W}@-r Aex2tUz8|8D  d480D@ N B6x""=ad_i/ ;?;HFׅr0rl@xtKeL>r}Y*91:NCӰe;2<" Ac>[c ^v   T(5rJ̌:P,RƳ \n`mJ[bȔEwZ+7vMطO'TonOxM=N@%H= gc2 ؅enaWY]m-D8hrD)'M6W_~z}yL]3GpejtaDZig?:+M<8=^kPHvDI,]5#VҁO<"{R{`ڃ 6iFqneXceG`UtsV^Ew( SH"%p%r0sJ8S$չDnR>B8<[?<h`k_T2~⢩eGD<'ef.Z&K)y+4%:ڐ6FxxN$B'# `(I3Us&5!3Zht{$p7HDwӌx`(1 qE9NN`:ʸY%7BbaqdJV)ʅGdefLCFjA X~m$>t|ӟv{BW|JEE:8 .L+^H!>׸;j̶45l$P2 ̠674dt_EB_#B6cʅCzjej APki8bҙNj Q1x1yEMQ ] wZD ±݄@8:DHA@Hϼơ_CFz%<'v6W7uBCM chPX_%Ӫ(3kwmUjOOt_2t ;e/fE۷Kot\AAmB3~0R*[ߟ6 '뤄μ50b{i^<}jW~SQ7:}онAD# Rll|h*g!uS7ONr\:ɛeNmqÈ&9Ԋ-q_& :ZSpGKus8'NG<2;{Lc@+Ã:g eDZ#MP>H)/pf8T^Ă/ Q Dϒvp޽y2!]:k'HS0d8:IT(_+SCBꪨ И)4 + 4OmSXA.Q1dSC4V= {6-ϳsi;QXvp&_bV@ެ# o[ӝK_%8.ц#Oq/.]NȏIjի/bjQ3F+&RwZ_Y8)C8e;op,__۞~n2ݓQz@ܩuo~Umu{/Q-gxeR@56/aS$EWtWbmUֳ$>H/A:HH4~}/QZ b6}<A8kO  H BT#N-`r?Mdb5%?|4" R.)fDFeS Jo#--`tgDHK$2ʎQhTB)d]2E&ц҄~D˲ND99dyCiK9[y!*l-Ý٭K,z/B7[}z $ՑXxvLM.pkM3(xq 7 ,/+NMH-J0М)I> H`s07_"d_BrerNH"5e=;F4eE >0b7z#K0Pt5CrI'L~an OCSDϵ((MCIX!X!/"G SJ2 fj [ZXVZ$e&'_2I_fiBiEŸ\c VP$9-rSR0 e%甦d+$B}49êf;`&嗀ݳz9N r|ABr:Ѷn07tɌ)9u#'<(6#qMo(88':ojn~fqj^r*uM^؄!Ʌ/J9%}r f㌩z+VN#t#8}x{ef^qIbNs~^IQ~Ͷ\BE1 P 7x{}O}F(δ"L+[k m`dbhk+Tsqrf)%de'hh*)9RZ .M IM-0RRؼu pF~q^qjbFFjQd9):(Tx/At ND̤Ԣk9X͗9u ^x}J@iADPLŖP+.!L9t=5Ueޕ6! z:ZbӳP6t,cÙ`"8ñn |^hj\PinTT*G"B_r1 $vtx6@VSz/f{g)<:ɠȺc׻|:f(>(Vfr5. p~<9-5R36*M|r V¨E1L|VllsH7x4_i 7&?Y7=^ nxt Ir;:Nxey TkA[hDcm6Pfa6HT(Kn"$\H"mW Q9gF9g9{1Filg7\sTSjPmF(67eH% ~uNf¼qٴW2̣J܃ѳfDWڷ$!NN'N`.h7/3ԿO3W -^fu.{C[Y x2 `vNy'c!u'k܌Z;iۏ mH#^Py&vR&LSb f,>L_wcijAA;2 H!9#ѲW1!O(⅞: -:EqV3In֦SeωNIL~1|$=h-PAJk&ǐ,/T7Z b6$s9Q >?yw^#J)wp^w4< :.݃YE?PQo3: H'DS@ y0<֗?X`9R`$Z0vT1+cRKR(sS̃dv_ӷ-"ҵM1&1eVqM8"d!G?[`[F` Ɖ_QjZoג;YzՇ&ͧ=1Gvp%dZ0IL?&tkR}XȻs2"Hҵ.&U!<4D^0>Vnu-0 S)UEdx*E~]Ձ0$ Nk)cY17U) ovu*~%ܽrWM _z;6f=SSz6-T%#}+k2Pei`*H3!e,Y+ glMB 47U!&@ٍ`$ٹEfPr*]+Bptgnd-]SN/]Q:i ObIw; ~/ϹW( ﷔}Xɦ~6)1X [շoUj&Q_$HAӔZAL+*w칗dl>bDd˹/kI;-1-mDUdR!,g^ߕG#CH7 [+\L*މ;wmG;*,>nzZϲbk`q0>ji7n5z Y(;1qj$$4.0JA {(Fd[mǞ#/LcL@A{LxkJ-) ̢S6Y=gVڬov!͍yz/-y0r &S%$~_"9Ƶ XpLS:5Ȼ=X'3`}:Q'BG/4Ȣe3h}nC Ϙ27L',_o&`<ʠ0#tsRw^Vo"[b3x#G~˧|߃LHfE*M'30"!Euz'Nx glť4T]o(J_"!*g7BL PHA&U[?1׻L͘BwRD[NϩzbMK8a%V +!"$LE@NPr/.Jv}Q/`bRyX^{釔{/,94a[<H1x`iUVpBh,)|].i{yuU+RSr\;nWF)O m5gZV -{w/Q5-j Boi,StfDmӥy7+ℌ 9B[9yMN'xU`DP b Y:b{uI2606>`v3uLkUP+! Ο(m[Uo#Sq`u3Fqh7D("5Q]*n>}ܖe՜vpFQ\`\_4PXR=}L:=?t?UM %̶ Ě+Q8.TC,pcϯcCd!e6׋lHb`J!-wqH6I!=_']VBStF`cO`i/|I|* ;{ēCx2[Edx5g;}&|M >ޅ9ZL}p`ZWl'l iAo|n$rHC?oƳ'@ٙrbC^ E =g  8ּTjKEܠ 7]Mo#D7b|wprk*&Eg~-O|K Kl Ye'1Ay{R# 1BC"M6rֵ.:nOYE({iG]J5[{͌B~[น&?Uj٣#xad7C ܊,} $v+Zk4[``ϼvg%zvxY A݊3H׫)Ƒ;hU.ߵ.*@8~ V<:Bӊ#*aRN+3 ~}w=LJݮ/BAm]&qc A1TRC.Uv{ uZS͇#k2=ӵr٭" uP\Ӳ5W,CHVbD=OLe.䷡.ʳ)#_#S4 B MY2>> k;I[x[57kCGQjzfqIQ$\V怜8% xSR3K*558u lS 6_tNP =x{=nJZfRjcJFtlqIQf^zunjIF~JBAbIBfe̛0o/x!-H!^G!@V(1/=U!Q(5=hLB5'gfBH2/17U#@(h6Ba1fQkLH.3x3Ua/catZ,3-zi.L{LGJD#{Mx340031QMKg3XHC{g>i?xۯCa.y'flYiE ~x[iDy{8؂KKR&3rM+Z#PZ$QiPZRZPP5#PvEDMjE+X t//-((JMˬQ@6ZG DrA̟^'-3 f1FDx{i3⒢X$xœW*-POxlgGQjzfqIQS"iIEE qx;$|@xGQjzfqIQf+FVx[ՙᄎFbA^QjzfqIQ"_ɵ 6CxZfRjcJFt,P>3/:7$#?VG $CG!#1/%'H -&]oxa 6 ;g0g9Eqr100644 ops_test.go7zab=)8M'WzSq \>!ٹ@ ?OmRY'))l xV}tQgĸ.xPx"!qs#c#ȌFT ?$b8Lx[͸qt͂Mu2=3v+|~ʺay x x340031QH,KgXg4%'>[t%UCdGj˺D6腮3TU%`w6%jv6|!P֜gJ3M @"%$$4Dvc_״=<?! x5E-)~ˑIN!sx8!I)bu Njxk忡lr5Y, %s^x340031QHKKg8rI`&`mxU{8{7s2[?!DvLb.Y]삖b|]x =j!%6P=eW681Y\[P#:'era5}[luEp=lphgBF8ZL:r²b%DKm@R2>Bb֛ttcA,ki蠐!XD;?jF|> fN^AǂΎt!o=  AO2nf31zFYhBV+:, ՐH1&faEDya+u-ԥs"@5rd_*+`mC纕OY8GBpGoJ47H*X+pNtΰ![rm\:{ig(B&V bÆFX+WJf4չ=Ni kadaFE19mx ,huf}.DO"4,>DВ`V5:eޖ67JR!04E*zjgQ o1w&F/N.S{U# wI_q>8 %-7)8vWy^ Mnri;q箫[-&o0m}KH'1Ri|ljᨼAvgKO)(CrF ;Cq\N}Z9ڕlxLuNxkFޅ5Ԟ%sEFW)`.CvL)g!Y?#v4a0gIU`,-}:xk6h,akZ>汻$))hNmz5</WU>-7T/m2.&b'#I"f"#"AA|oḣFַyC?Ј&c g*`ԚGV?*>"7*^RޠLޙc`#އOIgȑ-+bul[lGBGpH$sS9r+Gʇ9&5phأFTTt-BᎠ^:Zv%+sjb}R.2{=--c-x4x>Jtestplugina/catZ,3-z.g5f,sƧeh?bxM ['MAu:G 5x;Q!ߖFv-pIey`/ٯI6rP$Fgx[-3Ud( @RxY9VvvG  x340031QH,KgXg4%'>[t%UCdC?}z.C-xG/I-+2\z֊VYdHEJbI"gs<o+i;9xr05B? snvQ ^xk=嵡tr5Y, 6J tbx[8!Ln#֨ffU|TbmubF x340031QHKKgOVMԽBo<A lOx{[qC;%l(`x;Q!ߖFv-pIey.y3z?CF7 x[͸qt΋ggN8^5 ϧ x340031QH,KgXg4%'>[t%UCd_s_T6Ulw'5lKRJCNKx= BKC׾11ĒD}37/vf݆O <0qx*A:D';I? argm?-.rQx;uC j9FͳXy6[ yQxbb&w)NZ'f) *x340031QHKKgH6g/](us[7lPx8]n+fMK!/x;Q!ߖFv-pIeyčtx7Փsݳ\Wd[x6A_Ks u x340031QH,KgXg4%'>[t%UCdx3k].Rj>bRaΥ+cs~NĎ M @"%$!{_.|t=SQxM1K1Wuz8/`.)ZANPp7y1ϗg5^a 2],tpJ(LT s#uPR( 5h\ʬ\x)3 Ѝ8aVhw^^VrdY w\i01K x340031QHKKg^dԾ[haO%։ r1xxBlBZ\/ o|>ur?[fΉ, ~#x;Q!ߖFv-pIey:o0y OOx[͸qteF) SBd_tƂ3_   x340031QH,KgXg4%'>[t%UCd*s:5K~zIIuK BKRJ80G*@dJiԖ[]71ĒDi9u[{/k= rx-1JAqBa`O,Dp7`n°;3<و6B#'D^?^?{/ｏ|A<W1;}^Ҁb4$6kv 4!`;#&t9R@)<%:2UziJ^aC4ƫ&ޗޕHN♶OEg"+ D8"b1/yS2Bx;uEwC+3gbBf^Nf^#\@nZjQQjB~^jgIBAQ~qBfd1F,rƛgae,\%PRWZPP\RYa\"ɉEE@S+Kr*ʋ2KJR83S&_&*m>ǭϸZ(.@R T J HjdC qv@_MP<_BbdoK&[=YZJә%_Rbxv??^o#Gq>I͗\?uRdzֈZMV onУw(XWŦޫ$B6"3=ty:r癉#vr=~ g I?B)D3';@cLxy3 7w(*+MO)IMb3THl7x[q3 ;d2 6S@ $x{̴g,E%E?H"x9mlYߑ/K__ 19;1=urbbB^bnBHy>LX!7R!)$z=WN̢Oǵbd5w%T+ɕٓ_{谀=OXm5ntx{xqfOqY.8xX;3,?;U&c]m@ů vsxVxQgĬ6hPcx:vSZd0[Z t ~rgU}7hwCT-xqJ Ges3sSSlr K2csk'7)UJ.-0J*PYZRZd1T~s?e &Xx~lDkfLɉ99 y%[S7`~Y\۬˝$I-*J"~x&ѝ끯a]ij",}x3UٓjgJi.Hv2ddTǢؠC1#&x340031QMKgД͵6֫{o zxۯH|5dmh&:l'CxW,c}5dH\TD'u$nIxq+ 26$ yx-MkQ4M#LzHLi!bLhiVPn;df3Jixĝ..⮔.FA y3qw8ys\l~TmcBt۩J'gp7SQCw-5]cp,7u{z/o◂oYp%_w#Y 3x[*]I8M0S fF_G:%IKyVVqK̀ ~R~z |'.Q8 BeHe ulΉ]`=&C\g6|ơK'*wïJGǣVQn}J+Hɝ2j$=0gRR8 nHќ4э8ꏋx񨜮݊1ž"^>ߝWk-m}w?V.x[Y|$C wANiol.=ϸLX _ux!VLDE\ȹ_7x T 3x[͸qtO&zϊ.v|V42U x340031QH,KgXg4%'>[t%UCdv߸!o|;]faQUŗlHLrtĆ61ĒDi9u[{q>Sx4* d.Doc.Text(-!return .."RP=xKy}|bX|2K<3S6Oa]Dzy3 /H"<(;$/iuxoxSvyGjn>,ܨ}pV" h@+Lhʪ5Iͭ%=(_S疡'$Ex{4u6'GnrOfqn6K77rpLl$yk_-96ɘJpgxkcF`Q{x[Y wC wANioL.uKNUHT+.IuR/S/(ן^X(_ZYPX dJrq&d(d%'n6P*)$7xZ"s@J>fb9G6uu ) D075HHڄ] ï#yi[hQp' 1 @5$O*x=? iE V @FDϯ4-35'EC(PəRR e)(yVCr&d敦87F- %x[# :ړM\$4YGDžS__!9(35erD$1xqf%L55HLPh\"WW T^;Yrsan!VBވn^YRX2rx[{1 B'gkhnh8x{lFnŬlJJ~J,JU(,HMQ/(V(WH(/Nln1y#RNjF^QjzfqIQB5'gQjIiQgd b%4嚛Y$1M.1U(RHhhn6bܩ2y(gJjq-5zE\?jHCdlR\̢̂|@T e&U]7GM^S)h1kPsf9}sjL 6si`o Oc rx;8qLm4Լ[[j.NN΢ԒҢ<ע4 ScRo R2+4*k@ uR l&Жxhd &oՁZlZ1QG!a, @7M~~0:kUx[Y|5c?fbB9龥 ŕyz% *%q [xo]wQ0]R'3X@s3bsaC8ON62GSoC{ |u$>$PAeJ_=  ٴ dA@ ]t vH0 AHx{*Tf-HZCI'aONDR& nxq )) V iyyIM'ˬl'[?@xF edS*5 |SK2S48993ByHO~!hMML, [t%UCd3^ ܡ)O덍gU|61⒔ĒDd>b|OG+6x[:h/C L %٩y ɻ"MXŒ*KRҊSK2J2K&mVQbdO( Q29&:&3Ptr] DV#-E/17d-ɜũ y@Iɿe'[9Mc ,H .HMVLQ74T=%X)Ex{>^ߋ|w±)x340031QH,(+)fe*nݝ}rنyz f,weӷޜ 䏤$$&;.I/l/2xF.0FM$1'c1 $403\0C+42c_ F6 05i6 5.xlf6a's~AƃYAliIEz%/E7r Jl}?x[?C+{Qi^Ifn"R }'xc=w]f11O~ɝZZ491DQirk ~J~r1H| mo%x340031QrutuMaڠj^'`n˥ ?6 4(J*KI/I-.Kgmjo'zL.82843'5_{j7H&$PU <;G4z;_6 z K4#duU--9{„R ԄYfyU/fTQqUU2H_uk]>uxnp+))5}v{L=,^u/DRWZQ3F[ΈEk zC瀌<5g*9y*)J-,,J˜P~anūnTA# uN'ϛoƎ(-'=?ҵ]9$3l𥚉d;zR6TUYepS'fwM޸{'Q]iPx9q=sjݼIk;j{T<Bqf`hx< %0DYx"SWY*@4$37u#^cײCxmnEFҼ͗ep 3G .!ח8x2ca){Qi^IfnLViIE_12$6;G:eك.{ˑkxk2h)9:=$4I/9?W*@($_*@'?1%(VA_ҜX.}}`VjrIf~BbBIFPBQ~~Lb%(֪%xŶm93GQi^Ifn*1'x8%gfq ײnV?ôYQ[is #xؓ!RS$XV! 5/EH6kʳQ x[Y5b3fҼ/y򋊕8+77r91 pq:%*eořZSZd LLq =\@R?0 s䔦*([ZZy s4y>-x cG3"0lkc8;őw10no G$p 7ⱼ7C^|W'YAy40000 examplesSzEu#W[~ت\7n棎yU ViЊѼktܓN۔aX`F ~M3I:SK:Qx'_m厶 )lݤSmL e|K M4R,' ';kpxJmC~Qi^IfnO~bJjQBqBIF^AJB[VHx[ɸqB.m~b5ֲZfI/2^  dx!$> \/q v]!stS.E~P< TǝGtd9I( I_U c52d}>2B,yMK2B>sײ'yy֙V˩k5q+7¯LxadgqҼXX,C2R2JRb.N}}ĒJԊ=Ĕ"8XA'OTSHI-PSH̫OOJ,Nj<V/I,JO-l.3Tr,(Q(.)KQLII-O,JTV(J-)-SHQPRQMƞtENWx Apr~A?RSl M(KZ((&PXP`X=?Q 4x8!-rOπN)ǥ {<>TET`R[100644 call_test.go/xopHW s yLsnOY泙Vvc`M}8Ⱏ5H,^pϜ3ǓVBж'y,?=lYq'q ⚨^nlx[q= يT4x%bDĉ Yyy(1yBZ^@bQbnR~䓒'_֜+cȜZT49DG((+O#ds ӵ r2K2AJ82AT2Nmh㝑`eZT_T]ř$u^h^nbQqFbFR~JBF5XB^fBM PhrPoF^pIbIiB5''Hh{# GY>xkx5}69mYLiSx;˸q¤KkBxk3lb61VaBxIa@X7;39قYyyzyE98D7pl׍e5{x&KLgU # Q C3n(xuq1  .;4^<OxX(\?" a~ڼ~s蚦HT@Q`ճDڿZflf,ƉUY jC)TFx[lUo8X*#x*'4% L֕Tq=*! 9srRk'O>9YUMor/jYmZ8x,9YrCQܰesZ$\F}|x[øq ۟b c=|,JA! x340031QH,KgXg4%'>[t%UCdbަϑN;n֧d;hb %%)% /6 ?3}8 z?E)x;؞!_pl՛ 7?^üy?Śd}rxR3C{Q2L"ݳ6qw*xڥgX{8[&w}FF\b01 M -ǂ⒢̼t̔ĢTMj.D\AQjZfBf^^jB033 *okYZRZbH^yQbg-Vy< Qʼn\\ gO,pF5#xQJ@F +!"*dfn!k(K;$ZY9{=yغ;&vOtVo39D𺺙\E`E4 m\B\  y \98dҁAK 3j#̄vAi ;9Ն,CHIJ&9Z),Lu)yʈmzfa(PrGE۫/SD<l!=PFZ0WM̺3 NGҩ׵8Յє]ڬm;*XqIR IBg2@M Gd,vǏSsU/]u:K+bQ:jY53\oxp.`RbABAQjZfByQbB~^~AHbQzjdu/xY@ &;04Y.x{.AbBH;gG~},6m=[ub-ooWs5F1QNLC3 WG_W/ݽa[.տ{9ć?713&Yocԃ:*yg88&$dƗ3f>Hb_[oHir#BYqAj2Hޛs6\BO^b1?1=^O5}~̋XE.P]y1ψ٬"5k QVyaEze2F6}ʿu)18죳u77-Idӹq%> <{ɭ"o Ͻ9#wCyA_3~Q7^!aˌm<޳V?,)? LLs2$SS1CcwA(+.HMZ{Vžyk'STs4y&|46OX^}OǓvm^& 3b^O%#-E_^59$(= VlGx6<%ȣ؏ȕ?l7Q~v׆l#|m'>l^Q$b.HBI[kLd]tۋ8҂kI,t+}E$6~uж!׹NB&s Yx%WS:ܖ|DL'gk? ILnx==KP+."8lMVZ?B)䤉^ν-T nn.fWGg'q7LP:9xk|VW`#+9*k)8 &APSb_t\?mLh0$ <U$,Ap$A+p*MrJ2&.=ƣ $ZA2Vz!rr1ŬD\CĸtcvZ4:s.X(QSmfr xmWo\GJUJt䴍(HNl@jG M];{ޝ3,-O<"HUB2?7]ǎx|Z'|vYVU{I+lzE$iry9R~ރ/?tS~ 6VprJjU~#VU+,iGRzMRU>IM52otaMgKkG7U,Clq5j__g|_>xF"~&q~ڨzZ\e%xm[i_G7,.P>}5s5ce<}LI:el's"W26CiR謠BP&ZÄ/)!]eUWZL2U2ۇ5ԯ晕z-+m 1(D_xDeXow̦D~o^NIXPoSf͠q*OdL@F4ӹ Xde18U!N싗?CKҴﾆPS+^Q*__%t3Ʋ^o ^c4n&7c"1Kk(s=Gti9+ d(l{EJ3ɯ1w kWfi"RMq1#x+PѠcT&QI}<3nȡ8t׸PÁt]:w wP<+8baX oRV-&'*ޚBLժޮޣan$ɍ %sv@S*3jhg@HJj"=h6AÔn(p4 at3X(C.cYn0~Hӹ e^!e2@t-lt1R'ߪg8֙,Y*h(dA,m }dR\BkUVFQ\?7& w*EJN`! ]EzrfoveYKV6kT2S.΃@rY}>,P+Ydhh\ci)HEN4Y3K}♭@1M3P7δ ).2j<ZtjzeDwġ)!Q}2Oz~۫sZ08;ZJ#l8fEKU/˳ @hGuȎT%D}/''ЅwSzxlfqXal<fL~C>Br^fJHCeT͢(Tk)Gf|d;*|dς#&0"@l J݆U*CX𜕔l,:GP6Bʴ?-&a3hu fy x缨QTs9SŹ|:ϕI@))f>>᧏#pL d"8LGt3ng9;,„Qroju@n^Rt FbI#V[2{~T_D3^4)qC'> XaPtz$Ɖ@]X2l0V*gxQzn&7@49N(à gaMɍk(AOHIJh͸Ve[b=arťzqlcNJʰRƚuS,PsP7Rvئ7gS&. #4ԉo3@109<$ 3>B8>ş*SQ|:Xy 2G@l6ۻew .c2Nm#BvEI _X & f:DŽYaDIhi}9X^X\y P]fa wzh${oUSȬQQ?_x74[ &զ*_*̇$t_'z(ZgH٣x340031QMKgXs*ɲ!+_E,;ۆ 7xUOJ@F7M,f>x340031QMKgXzBMq[îo8ree;j x340031QH+K/HKgP`v่ʭåGW6}3(()))XӲf%|>AR_Z\RWڵYo&UUWXPT RQw:Ɋ]\Sxڭ??;# x36>J08?*4ҴcJ9!l!.aFൊxUn8=[_15P6m@nHr(-,J@q"~~a3ZN#>y[leȮAuI2okݒ֋h=O$Y.ArWW[#H PZRՂ4T8I&"XK?H@ߢ77+H %{Prx8ߣt5"|\F0S [ڐZ.G l+[t][tO š[Y"@ /zlg`]>ТI 5HO žՂ>%/f^O cq*^!׳AQ!EKvOºE/HF*GW.6t'%D%IkRCz6XpO|hH j߀zzco++2y#?UXꊺG@ס<8lߒ(Ey,ס$O9 9[d[o%דTEUgYYu%IO_B)桮,Kfc N +4ㄊ { d˥1j,H%m^уK)dmqBD^^ h )kw?mAp+ZYLi%gᓁ>&tvc/V\?Gl=pdvw4.Wax7itE )y>jG8mf+" O7 x:xMvBLA6 pp򶮐q3g7 SK#5P``0OmN1-?ha׻8̗a[ y,v0>jp`E-OO7Ng%|[NL9c?FEmcFnPgVݑQ0?P,pDKОqf ⮳xVnF}bJYTC8uQ$$ 9vݕl%1ЏKz"Qr y0,-g̜9s^45Gћ2qTd|uyk6eQWNWrf!,n҆Eˆ6R9[bjϝ"KHZjJ6[&aVº^ YM9$Bǃ5 V {aZi0oYP*aCARY*,sرue5Z]hgf/ o4Jy64ăsfj;0c s, " ͦ7wB1="rkb'N*y2Pym^:-2 6'b ƃ0+Bz0  izPG[/=Ԓ(B(CniyaN=0%DKz׵kxziKGZps 5:ƍD(멶Ƚ*P{1>lx-3,lSMP1wǐp?e8w&=q%1"Fa3'/#E#U។4!5h8w &-Ww0!{'ڨ|rBƗ~6mjLo&dՙqFqڀcRL(n Tuת;@>-O=7~34 86f/:,=l8 @o h P@,#[$^qXI:`y1&3"vca>69Fyp<_/?@@Z"j1h>{ ^LP4V]Q"`"~d6gν@ F[1h [߆ /((l^r_|cO.0o:' .3ܹJ$*7?I$1riRnIכ)tB+嗶iI8O\?Q,&im>zו~$Δ$gt#WJd]_Rv*6?kiZ{*F/ڥaL3%'u풑A^x&뜮0KF`ML'=پlQ@d~FնQ3Fx簘Ş M^ٚKNp8itڦ;RCZMllU}bqpBFaFMzY ÎpAb\}cN[ӫj!!''٭ U"u $J+儾nù\Cs_f(9N-x $i;ipLc"9gԶ^c\ntsX2咆8,m-G TnTX"bj ^}#gׁ}rCW7O?^]0o 'B<|:v\K0kP/umz,dҢ~6 ;j'm$aBK_7>I*n*4ckK }IU R^cu"X ˵X"`UT)+.J+zFkXWk#E ,,a}R- (($#C1FeZ% #۫Tf}ɓYWѨ&SYGY OGA7j_ )7s"Q $}K uy kfWfa9;Bkqc\6 \f4:ʹ\4ڨF<*HKY`9X:;*@ٟ_^^o(lezK&sȕ: 8a x/aA ^/"W8};3 [%($ݼvH}7p^IƺD̏FR@Ybxd1?԰0";eL5lGɾdS爊7/WWŕs׶tAe1_\\}eQ^:KxҠ=bE2(M!6`@V hL)bqI2S)mA&=IRDaƶ8hfّw,z}0~ԡ-|=aF00Vfl'x |Vx5f;I ,Wx{0i+Qt)6nGBj#GM0F]9s:RűhJkqQTeO18o?(OPDցc!idJF=yڠ'T'${4? ?P KH2 ˜!YQvg|/\ d+SxM(J^)IM b?Tm.ےNW@*6Foʅlm2vͬf~'d|5Sգz[b9+cd`^Yy|x}G` V31Ce3u.o"P`U‡REcLXM9?ozpx~(S^`{G㒺F+%optarget_test.go#:p ~;1*Tw4!ͺckMOkJ1=V aBT '.7rxk _yxR KSKS*'(d($sqO^+9Oep:#԰bوbUVgUw!mȿA-@xm"#9  &`ar&bKldO2YM%5'$53OGD!12V]fM6> $6JqsX%)$T*D&Urqrf)䦖d((*(()! y:(mS4AJIKx{#7Yf, Ԝ=3XpP oOx۩MnC$/ N3OHx{jW{Diw&po~µy# 2l!x [(1*xD9kɹVUL᯿M100644 README.md}x)tDz .emh|dO )x5QnA9192"!&,bO$ n}7W]L@P EE O ]KIOh(hݙ7o{r]LYU:J!@L%&P YW؇sk[hЦA GTT@8dDf\ǘZwsg疖+PON3OwH!`F!-eГaĸZ;7þL IRۭ|;(8wb[ ܤ5 1=_gD*7"YphiDƐM%!SБ# ydR>)HVXҁ 5cȤE^ TB9azVXd,?n=L.{wo6+V#{2l[׮4#(\ F\k=*5D[~VtS\:#1ko09A.^cdщ(f-md.. wYy7O?Q$~-Uxn1ƕ"FҦ=p\ͦ%(P$HPcn۲-BJ C_̆@)_f>{hYf@2mh[@2*m,ͨ&-X  Pdnt.pޗWHmu⮫^j;rY RQY3FmFBE*Z}`ZK {a4GW:OT4Vs4-1N-QVxNڸ&O[O"xpsIu}S%z~PCJ-ۥZ rrX48Zäp^d\38iZΫq+Ǔg(ϴF4T tAC5;z8_M H;YMA%H@*i!M^KUG܇ew2b,?Ox:h<{̂BGUJ-dЉCxMUꤎ`bf ïx31Ԋb<ݪ?)RcJ:y@$eŒԜ|G5xwüj/!E%iEI uTzʭKG[L7MuzRnʙhVy?Xg1L۰#Tγ{]gٻ8@槔嗖3V>X!~JC䔂 RXg76y^5adwkT⒢̼tXT&z[g;SPuIŕ%y% \ SW>?2rc@T&'g0KpƛNe\ԉ|u*@ 5fk7ԾhNtfZ .24~x[ϼy#$&_!Ǻ;nۖym(,W xm100644 app.ts>Äxچݛ9100644 main.go[&Qbz>S100644 main_test.gos;0F;S؛.B;x}RjAe3q1.T^[bXCp!F\`11CM"=UmUua?Ms!lw~ _ӐZU{,}?4ԍwS |o,, (jv@ ΎLa]PV׾󜕛a$b+U LԈ %KeÇ$j/miCx=@c!vF& '-<~)cMsFjA7ÔGݥNoWLݪ#VSw[8a0VP&̽oP8   q[;Rm0q-G]H+-8sdϙ`|qrta n 2/݄Uede*b}I;@tb - k4Ef;Zyۯ6]cvty;q!Sd~!㿇4{{x lk>4aPM2PvĖB1[S Tcn8fۖ„}Y캢?O蓘lx$f&!`Zl/0UFj4N#'BW||MKU541VR76xqZH>#ն$ZŦ{5b#ݡ6Z?j¨\Jz$dѵUO`%lI!Ivgb9vs3ipw@?ʾ?d3=V=+Gi%)e: ꜕)#;tYu YQ1v_?x&KWm [j0,:胕zޫDceB&"E:Qj]ި>>1ߖ|ˍ[x;re>RFII&W-wM2x340031QMKg0rM_~+_lx340031QMKg`:p]ßݹewLx340031QMKgпavS/[s%Jlx-J@PMԋ{])DKAE'ok6L@-Ňsff>73?d"((NgPXԩMj+Sjb 荛'Q]r$=%0!2QO+A}QR0AC[9:f2EK Bc<G{Bxbs,[P~5SЈ+gěe 7.Bp5CZ ¼wd\#ZQ$0UfV>z&]E}){?(wW?ry  bB e)x̱cRFII&W-t`x340031QrutuMaX8fUo>쓎&@3M~q=T0.[Q_\Wr+?=Rquy0#,أx340031QMKghϓYo۹^3x{$pmT<.܂Lϳ8p$蹧hLaO+KHVЪ,s.TH-*/R,J-)-SH 020QM,..)KM̫)VLQRP+7TQPJN+)+1BV"mlUS\ *A u\KKJAV)%g$(mڜy[ߣx340031QMKgʜ{c}~v0Dbx{!6[xBYSNcVLLsO-PHM)PQH+KHVЪ,s.TH-*/R,J-)-SH 020QM,..)KPJ%%JV JJo3ȧ)x340031QMKgeop/er&SFfx{sm?=BB4, , 45j*x;vm9RFII&W-z3Ox340031QMKg8%oۼT|+rE2B. Tx{#rgL'˳u֗+X*$h(ŕ48 =UfBZi^FVUfsIBjQQ~B5'gQjIiQBWBnbAtqIQf^z,TdXkeҁRzE`ZgvFFjbNIFT\XRZ O)?[Vs_hFA %+  %MMZ.l'_exgRFII&W-x340031QMKgp]kk!1M0)SxuuBL.L!!JVJ\\X*x;zu.& +}}+  %MMZ.P!xwޕNe#g䑋!x340031QMKgw-~ԓ~ޜ *x[$~s9XFUS&[3Iq&蹧h(ꧤ뗥gMbe+Y)@Y\ ZPX U(H,P(JMLHMQ,Sp̮ V[PPYRPXP?yXFIFpI3V`̒A@"R!'??{'ՓuG{Sx%J0Aŋ/ ?9 -uU*II&]V}|̶o:_o"Ed6u>~| U.:\MytO!ە)tX4i#0##01c6`]6daTPM;ߨ3uR0E^B7ۖdj;>C"1ݮ^[ g`x:7< uhGsJ"/h踟F > I4ux?`BI7?B@xn9kɹVUL᯿M100644 README.md}x)tDz .emh|d*~y, )V(OiŸ::a#8\]vRd100644 cli_test.goʵ"C1È+ӟ100644 clispec.go@&•wqؐmWTh<{̂BGUJ-dЉCxMUꤎ`b`G<|!@x *7< uhGsJ" 9:i%3kpwڽ:*gXճ^1@}[- /h踟F > IQChx6bs~idV&&LZU*Yx]AKAY쩵J_ֆ&qjCJMi{ޤ0}ɮ΄Y%Hя Rބ'X x)݈41o.~j?e1>ӏl/GWN@Fl0T0=u,Xczt6 F,xz}GB/=s$AyϽ<][Z^@8іVOruG[/8ʐS0DSuU}Ht*,rÕ6W􆉰ej1p6-j[x߱Rp|HΚ Jà:?wڎ`Ԉ6>J9@&#"]3 *xJav 'zR![V|W!c]UIq.I*y6LNX]>0xn%Q>xeOJAE"B.i| ;SdU$'7ف:3kX/p[!6Xxgv9wefp-_'M L#p5Q t( QZLkƑ BjWp-zt1 =mu<`clM (obӘR(vŀTr3f6!HeFn1SJ(FJ<) <TYHCz9ݠ>ܹG htJtJTGqs(AX}fF;4{vmՠDK0!z?WbPJZ!U1{oogOlf Z+}r6߅0cx;_{C @pjQYfr()Lg1%)+fq6vF ~xk3k1(^撟_RYX]\RWY]9]y1+E\sx}ToESDu8B^6')U!J)jP a"Xg)۝Y課_ *ĩ^း of7{3k;/\>16,xV"ƶ;6Ϩ|rdAO^Xli#_NmhAjr4bW33dYc6ead*фLss$?L~+ފH$x~%g,-4!V$bϨ zٕAГ?,!6tǑ46uЁQE¹i/-&tnQWcH~ GTr۲p"CY`[ 78venqIVWϫXN]„C'/zȤa8aPKlн*Zܙ6Ks|<ܫe1ŞqHC>;7[ =FU)}A?9}(dC[!uCnՌO-BzGjNÉ@p;n$&]Sq5m5ևkznCd\?ZLʧ)j.kۜ_q B?x3W+$""I)uz4(heY54Қ-m "1eac~ wtA>IHOρݍ/Tmsz?-YD8qc28Skscr9Q{kVW%MЉF*򸆲9s8vMoݬī ^kKx{8xHvLDx[eCib^BIFsBI~~BbNBr~nBZQ~.P6XO!3,?;U!z5&f\: #&'P(*Z\P2.os4K_B<)X*e9h$빧h(e)i(((irqrf)*())TE8!|4=? (PP;?s~^IjEqF|RxyTA+[<ԜT4/srRJR+J4'W* Xx9=#u<] o`100644 README.mdBͤ@'׺K$[#Ʊ#K/4%_M{tW)Ao ):el%$hj{635dn{rKO?s100644 mcp.goO`9&?ܳZ`{_T ^+*Ԕ6KGAU'= UNѓ =7@Rҍx?&%0  T]Mx^N+٨ '%i x;R?rf96Ғ癟l.9" PQPP\WSEH!-$Ibr䉆›X63Zf!Qx{fz`n~֒7ki%hiM0R@U&A?7 A!X!1O!(%3/R($Ugr`;\.xuq1  &_tV+OV U7I%kxM6+ e — one schema, two surfaces|V op.Summary=\tbRx[msDfZfǔ"[%C#s= 420T|U|Db8Dx;"SfZf񌒒ǔ"+[T[DsyR.A #xN=xԮfnhAZ-pTE˞mԨ́4y?zwP][% n7`Oe/^8&^AK4yqaS2wq FokXGCq؃ÖG`a`[\ ϥ^]/7 -pQFue2 (҈IƱz=ѵ]]?ߘ3RīB:&I,wŲD:iBIUS gek1}/m5xD?MH0᫉~7Fo=>|vr&sw}^z>?e Uly$[&jRrNf|Ijq HNmUtn{p2!&T=砶[ oLȽ<Жb+m[ÒsX?5T;9~oߒpM|?PsSfP|net4Nwr*{"j4/UQbYjEbnANj1Cw>y=K7Cbw\njļ|ceatDWtwy3bJf^IjQ^bÅ΃W|%}NĦ;نݶBԢ 3O}Π@N~b <| `ʮwe 2B&TI!WxZ{|/_P7HִJ[dC͗ZX RPfe5QGOP#mƳ_fȺ+U% 3!?4'n) n_|7{Z{XNnsg$N{ֻ+S& C(H,(H,J̅Rz|5ڻJ+=yWf7,_o݄o !_TWʠ\ܧ}۸5s. ;Wy:E=(K|A7%TS+"^ɲ|):IlE8 {7ğ.ܫ~<"|!~s+,Os* kK/v?gwP;Ux瞸ogHogEܟgo_G+lhxk7"6 L xt i_H>b|_^m3wfB^rN~qjJ'4X`e -.HM*IHTS0P9e)*a%@%%}}<ԊrĢJ̼b"T..Z.μԊԢ",VOcY<Ūsrɝ76orJPRFTixkx`5 x[_u/fSͅ{9xH^k*懔GDLa~~V[HCw[2r6BRX0.[NDtĩ100644 go.sum VAI0tXj#+4f9$fVp1's(]W7ٜfC(1VUQ6TDoM;IFB5b'r 䚆6 =ŵ[3$+ڵLV 'rlnx;ol*,!SIx[f=7?4'UartUfWz)WQjaifQd=fK& YDcQQ빤AoAe4b?)ϥj Bf^ P((!$f.Tή.t]UM$SM#܂3GMMS@M䝀&(q1lA] .&VBqRh Qir x[Ø9AcH7 KgW9nF*x̜*voj ?OLR7,޾9 . xu3eԍnM:7YSx2plas&0ghfI1k&% V iz!z%JYyJ\i I[[%%j.N΢ԒҢ7L➲s('|K-rJ.[!DĚI^ƺֳS>x;* ٌ1pidl~  wxygP}L(TڣBn0!`AZeĭ_^kd100644 pathparam_test.goϝQT1:2 6%O/g=w?V&c! r' I7x{}R{wAbIBAbQbnd+>.N}}ĢԼlf|̒b Axr:p^n=ԒE[%w%55TQWG,.>!JsgfLS/'jQX[``P9_ I\3-H!SG@V(1/=U" )9љ/rOe/`0N$]9[u0c9BxhܢZD03M!'5O (1XSAvr:m"l% h F&_xMQOkA?$*YX-Ą" )[)ըTԢO:ɾdvgنj@c+ȁi-lͫ5J\sRs54uR3K*'{Vc"kr<iizWThngC2+'IXQuxRWJM ľeݫN-ݱ 3R1HMZwP\Ym=Gԉws2ӳz9R(Ex{Ty7;_AQjZfB@Nizf8vyF"Ē=[84&PR0070PH,|"x340031QrutuMaexߪr:ҴgM @!)3''3/gf9՛z.L`\0S"#a93L!2K8]W)5#%mxKK$\,j|"듔iy3Y>x WlYx(w7͓9&/gx340031QMKg8ѴrcؙIYyVgl2[S lx-c&737-f` ox;{]vB77e< x,Yx>H#U#&:3ߛY Xx{| 3Zlg-Q <Vxc< 2#vKp%*100644 load_test.go>Ӊ:!Q!OhCm+Xb7h^e,$x;q 7%0n,^:ry V zɥEz>){JNޣ;9^Ar*w40rqfMj0&dcm1!D_pI~QFfٓ Ԕ'$M>5y-[&+E 17Oۮ 2i(x9qD =RzwxVi"d&1΀Դ ⒢̼t<+<zy:\PV z`ҢTh1 K-*H,$]xTG*w1;MuJA60jA55vɅO:sf5i9=սIϨ*e32ܪ~dRȁ6Gt 4~&Du((a#,?#[o / BӲGyʈ8Uij%e`SV ;njW;7VSrCG.卓.yPAsV(Ջep HΠQK˽dNiD:eT Cg֖#pHsS2"s!*xOoJ~ovR~Kˑ4v'L 9-hux9qJ+ULx{$}N&̼ԜĔɯn>? x{Q \nQ<{ tBԭT3j] )x7o ~~RfNNf^d?Va,KY}aQ̪Ehs?k;#qx̜*ȋj& \t3 cx340031QMKgXrvoOWW:6;}Ck x;̹m>!,J hx[̸atqIQf^:gAQjZf[\YL]14/Y'?1EEBB@NizfdMYʌ 'NnPbPVT^33MdcJJB5 r@%q)m*<9[wR=L^n~i^IXf"@JSK47S"u7Dx{qMލӋXy SRst& (2N793xrl/1Umς[: &ܲVB5z%'ʪnaFmI:ʈMFv3l }k7K*100644 load_test.goW6A5('|9y%\%)%46HM>##y ەgLN8ȞP\_YW8}fBAQjB^ri^pybF^f5DBVSj(hrqnVbdqO.~ID@g=xuj%'x8ckj@SgؾZ wyy I3vHUckgx;~Rm7Ҽ9R7| j xVnF|6@@Qҕɇ/.`Il G@W䑸K.E+|D/%%Gi@({vU &5J_?}Gm<@azҾSAғȳ蒩Tq֘=Bm6(c9pgrGnRhǂ[Zzi8ONj͑κ@ir4C i,5/6;՝t[Ght hLX7KDv3pXAS]Vᬃ%G\. #'T\i][pWsr" 5, `n*X 6UԴ8PkO,_ѠY4Ga*^DIs |TgƤZBw9iu/ei%GC &MK:5eG㳩JZ2,^ g!Oݠ [ ߊtp(Q3;g3z@68꣝@-o15[OC ;m;㕾7RNkM 5n dDX1&n^2H`pζsf奚jmNtcץ2 /v`-H'RKZw%<ؐa%8~!bD:Aman9'S_#:=ycˇ:&82K%d$,'n=ig`ZNo8yլLᰟ> iM~;sj-lA;=K7?߈ c NF+t11)-W Ky+`HⅅZ5/d'i4oPLEsz>HCt?c ;dl:x}S@E)]s($RbT@"HDž"sމZs) Yx((iY'!"ra7{Fk&`<\z[-m`}?`u'M7?N3#@8\4K)4) RpXތZ'O㤈^0א9]nl=yXI%嘭:dTSxP2o)(-G0qWqHֆd'eIalr1=4SணXyCp jC`ՏS"X!>A2,wy|$pmqVW . Ԕٙ [*#ied) glZ԰moARQpu7|x땾d?;_z78xI<D'f+o100644 load_test.go HJ=zi  pfxMJAAFkEyM"qR0'pR$o_솞CwOtpep@2'^[=YVGU'b^ơȆLkr O(5@I&50"$(c]+A"dF߀t ,H)Ry;IPc$*Rhvu\בt NTum?kp'xwd`G"y>5<+gezb\\`j\xyZox=q\*jx*>V53Kn]$l9Ւ 6gx[n< *xT\*Cg?YI{``ɣ[LVbNeI4qeC7#>+(#-x;}PkU&\i8& )n4x[t|BwxCX6 ?HK9x)D",B2'Y!'J!_dxowP(eM U]7,,iab#Yq( ;l/lfCQ'aq\3Q?Ce_AEQ`hj9W)e{,ZxM1KQ4B b,k |m-${m?_6{l330{zRp-^K$ǜJVhj+CF Քen*D=SK&ٸoE`j:')!71p}Bxbfiwfz{ֆ#/{mxxv~1< iYUwGteg -^Yax{{WM__1%$X!-H!(3/R+2K@:LxȽ{+cN~Njzbr~rFx ,hx rm'E6+sW;}Sx["dTTX~s6 {7Dԓz100644 go.sum `4V{ȗZ۳+&x-1N@E{7HN$% ^aXk[N!rnB()YGOs}]?Z,REvѪxo$g)gu0N?"cbݽPj`lo66Zf"^PȊ#NюU#RcIG OsBʍTH ITc8ºS჌{Ŏ7ڔ6N'k)5Rr=*gq x[͵k&F--f#=,W<l2x;odC*,'x{$H` ~NOU{) q2v^ ZxTqHHyBfnA~qI~QBjEfqd}F ɞl: y)\3(e)dd+gp(dPRRS2KRS2RJ r2KR7g2h/jEx{$p@`[x$ÕVa@;Z)Kn๲l#j7x[_i sb5 1 rg mbWῌPT48TZdb?eR@eF.ѓw ;5!±LTTY*nIrn]Nq/bT@\f?Mߑ2A`Z'dd.xtxx۩OnvLb̒ ̔kײM" :P[xu?K@NNN'^pXhF;䲐.,D-ZY[l V~ ;ae߼?7nVk [gQidE#p,$s w'ڐż2[rq/5gkfSf,2L+4ѩK/d$Ƃi=WxW y#0Duq JlM4?dtVT^]\yXdQr^$7,X_Tq?H> BKNIx[͵k&F--f#=,W<lox;o~xͫUX' qx[iS}PqIQf^zRIjq =uVa 6Ix-puwN K-)J+./*<ˉyvvdx;;l _jyHQb^qA~Qf+JtܛW?Wyq8xUݎDV%(JZ TZ*^鏔VYV". Nqw\ pC؎,r7}sΗ~7_b-ۣ [T>xTDuRA"񽂐(i*dh.P&$U ݍ[M" 9ŤC"1B;IV3eIlw>lP(ɘN<$58%ᜰ Eap1/ N$ӚrPHYta S2])t9,9<2rƩ>iwhx@m4ܺߧJJ 9!:7DlS@PMSr bl0>cS)ӴWÔw%gkjx YG~ Rz>`[`FJA~Pq4>xE Պк >44pի$a~j+Ӡe+7CB[ptNy7~sy-NDpe֦ڝKv˩VFLQS؇ ok/?g?՜Y7T.H+=yCe!(-Vo#]Ȏ\cn4icuhh3!\Jdt7= Tg):VPaCL]1A#Gٲ# >σOUv!`$c 9g1VX{ &+yyܿ?/k>cjQNZĵ8 b $5QU,@ }}=w0M71 熫'\vwJ|* A^,)mPq|&\%|lVFTлb蚖l#/);FVhQrFw5!ڦz=蛄";rI]&8*-F\%5䓱(sѕI{Gcv6QA^ff51VRbfc9-ob iPw0@lX` 95/?bQ<"w4 ܻ f5xC"fJ.gy54N&9wbht pѬDY'צu'Rxk;Χdb z%I _*8֫߫R]K&UC3ļ|\[yW:-6rfK,]WAx[Un/Ey iy:\x9sr@xz7[`gkifx[!`eA2RׄB`;x;wO3K2Jׄ.,dZ1&?-v0ߨN~@x31촜b^%x® d<1e2 Qx340031QHNӫaXm.豺Dg1M~WK3DRWa VftBzC\^SvrC,dSef`emXkY+5>2s1G%o8mYSiҷ&eE`+%M,gs*m[{^UlY~ɋ7r݉Rj$cR4\ϼvLNup}M{Vk]Zu}TMAQ~R*X}CíoȺЛ(8Ɵwj xe;yӆ+x51 {^qz*bNEA#EifvFk`dIP2Шk6.3ى&6>%ɖ ܘe.TI>kI=b+!b?xH'x5˹ 0 @>SxH&  HTy1T{8d[$GۓXB4t |-zȷ @Ľ6ʩHl&#x5˹ 0 @>SxH"  HTy1T{8d[$GۓXB4t |-zȷ @Ľ6ʩHl&#x5˹ 0 @>SxH)  HTy1T{8d[$GۓXB4t |-zȷ @Ľ6ʩHl&#x5˹ 0 @>SxDM HTy1TR&#I']q []uoAl=woYm&n+6#y$x5˹ 0 @>SxHAM HTy1TR;8,cIWB4xu>`AD[l [OVʩHl7$кx5˹ 0 @>SxHCM HTy1TR;8,cIWB4xu>`AD[l [OVʩHl$.x[|i#Knbf>F1.v.gx;ƴi!# m^x%A0 yݷ|J+Bىx=n-4Ç:vð*+JFjnnn =-!x;wO3K2J2*{e.)s8t*JY"5x;wO3K2J 18T&(]27#KmM93}Ǜʦ7SoSx̘ǥW㐛+9Hx;wO3K2JB]+mQTh9PwLGFTGx31촜b>=w>2<ܗ֕5qj xa8`c @x;wO3K2JcڥXb㠶A)xa8@&39E27e׉&;-qd;F?)6UXx;wO3K2Jz7\ |3aVoTRedx31촜b+r*xx&$׏%Bx340031QHLNѫa`uNoGD>eQSP Vdpp5.;&}ߪ x;wO3K2JN,r"$o}FwGT7x31촜bI:ǽp"x340031QHLNѫaP{RIn(?)Ⱦ֏7y?kd]vM'5;x;wO3K2JcկڷfIN8a*;^BФx31촜bV_gM[vp絫 .5x340031QHLNѫa<坚"G`xܶ(?)Ⱦ֏7y?kd]vM8knx;wO3K2JExit-˿f(۹yKnTRedx31촜b) ǣ/s5],>Lx340031QHLNѫa:VwӜ7_ M4o%x[iœ&35+oxT,Q`xP(7^(b%@t/nt~ ͕=t?\82kaD/5FE>M''"EYxW߰ $cG6Y6Xg2a80{ Ƒr!88\O6mf+b)x}MkQ)vp2snjAܸ5s7ùwZ1U?ܻ]x'$hpu}|p7?>~qIpr]~QZ"dh,ejcU;,Thl;%h`Y )ؾLx Ԟ|:jQFD_ .`Y'|Mz*u^,%^[kC&m4- é[68ƃRD9vZawλ9_MF+82 5V7+m0UpKdT+':GiBiXJzoa{.g[xuƗ.!ߧ1_R@H=~ &bac%*DD1(fwA A+Իa(y]ۿ{^Y:aBR%>b<"hNE=,it mP)um8ў?jF,HhYħն1vxOnv}yN֏2rBNr4[z@Hw|rX5vLyxHcY7Ԝ9P9ToF T19ꇒ̤.h9iTQ ӞOcS@{32=JNyPkp*C6*s&Wz΁!F`j _@YЗo3ѧg?~2{xkȻAqc&Λ imүZh-u5pf{L Ox]1N1EdB #A EAHT"XJpdz'*܂;JE9z?/'ǟrFaA5> 18(hM+Ahpb.V׊54d:&@pQ.|6|Znvh6b'emZE'cO*􈐧"_ͯVU1}|/oϖ<T!iC Yxl NBD.wL Nbc0?Gp-J-[wM uUVP|; i%sּ^۵9I81{x; N8?qTL1{l}dVKbc[ zmp $lCug)x[v9x{c{z+G SJ2RsJS]Ģ].}}"S!#51%HG D!3/9J<#5O(85d20H SZQ:ٖ[nfnKai?,,~x]AN0EHG$6v{ \;ؓ4Z {H%XF͛t9:PPi^;|a~b5ao)vg]\AF'bӓ&ؒW%YX,i],\ԏO lI0,ZRp t]9C,A&.J`P\ųَǙvThlxȻwC6VoF 6xt N`ۨSW|/ٙ{ bzj ZR2!JdR.D$ZyFƋ$x,r>da4zבwb3\P*}8GC&KS7;'[:Yx{cf1fbDkծp a#',x'[f'vļҒTD $#U!9#13K__824 P,w&GPONj&D_T+e鹧hE E%Ey Ž*K2u20y )'dBbIr>34GhwII-IbbEn1~lZx1;HbU/#&o#)1oXFAQjZf<J5iN'o Țuд-NӘOX6PB4 T(P;YSr2޶@x-Hj'vĒbT<|.}}2pQjzfqIjQjBRj^jbIBffN| yxc8`C£) %\ y 剕 % % y %yřy@9*Ă= #!7$#?% $#A!-(W!hړϲ2دXU' )٦l#4AMl6 9% [t skSsSJtrSSS4R&odQx6IA),1GIs?d͋9-B(x?!Q=D $C(3/]G!Ca$ d&e YƤ $1`q6fu i McvV /-I((JMˬVQ.ܼy7#PK#Z^b|̤"ļ"DĂ;4'_T|UI) ]Y #`1 b Ē bfhisII a}&HML!FI1ʜBxp !cN7_4g4 .n5 58l'RL( )M^"3[c_# ̋.x;!Gd '6lcG6 xE1 @EQSv9 ,I\0ILwX jsݷ5Gطlz6@9Mj-R<1rPZ2)1'|.?QFR(mY8hhQp-dBV?ҾԊJ("Gw>@G x1 A6Zޤ*SJgUbbY^&kO[r5K!2O71yoT 8ZgeDw Fn0m@Y7˓d=4uȺbJlr? UP' |9Q)“75`\xN$<*nC1b`^# *xh'b˓'WxtVi|BbAo~i^FAQjZfBFIIGb^JNjVw{d|x[ɸq:6h.qb` lAx[{gY Xx6 )Ƴ-Uh?!&шB[|cxI'`swldxg ͎ 1%@\xU `5ٺ쵊y1j#g&t7zp.K+0eK/ ]*rK˗rUuc긳R#:.(.x[rIyCo~i^~NjzbrBfBb^BBUfcJbA_jGHHH.99dz>v/arxuJ1Q] ?,鵲bEtmL`& ɝwXF=|"4߽|}kui1xV ѷLQ< v.oCP~u{T:sm& IsPcLM9HR8jBms}{^Yu0]#N: GFQ$)YV80:1x:=Aguq!6"R TbG&3tIȍv1lm"bؓϿ';×o$p x>bs#:e)\bwchi]=nxӢF#ʣYOx340031QMKgx^PU{o3oZP x[us ^Ҽ MԼʍ{$U "J9ɕJ: Izy)9Eœ١Z7W21[qq&Ҝ\RT];; )x340031QMKg+5a@ߓK 7<"FS=x[νk o~@;Xd\3K2K2R2 2RrR8 jJ4sR+32t լ:67x` losers.go9о bHٟ-hY Ii{>%s2HM(([C6*~ѓ 'և+۲ x]PN0<_1P9;(Tq8W&ٴm꿳NBHlN0͋>mPU]Rj \}$D9$ځ0ֿ9]VxzelDhֻkOH8Xnp ]Z&.A̞K|TXg>CWTq 0}E J::1M[[s`vgIyBUIi'/{HOaLN?5^/rb3[w>UŴYCtAFxU1n1.Br$ (`G@R:Y֊EWr܁`,Ho]ǧϓKrEޡ<T$Sak4J=ζ[ Va( 9/ZgB5:ޛ uc <1$gmL МUߵupV x8cɧ&fّP2ӹ8sS  S RB@ ̤"=ǂ.b*JM,.I-JMJ&C%J54R%ʠr ŕyz%yK2J J'KI(%M hWUH+*sX7_Z\(((qlpFiIJ~yPC-@ԴҜJWlKRRS*K*&;8YvP)P7J o*c̸Q!ɂxkj皐 ]M;+}apd2 ˢ (xZnFϧ((J":)J m[%E%r(JX!$}gHJvbؠLj.g;9GcZ:Λ(X|nTEQ^j꺊z]T7jf*r5JRC.ߙyTWgMũvr՛R'jI+㫳eV^e4J:7)6˲,Y酷wqzq"JyZ8|+FcM;\ccUNDd0p0 gSF XDi8"(Q{`K,/E=8<ݾ$T/(.?_u:~;hwb+?TwԦ>c'J׺v{\GY= pc5}۾UUT,SzY*NM]g^ޱ7FP|Ȯ}HeW={~#qDyacC\DpYE5ÐW3 %wX͢vx4y&wW9dXHuw_UDW+=>:.zO\Ѣ*]DF}\]]0:;}q=R4Pi8`t[Qi@_UBsAUjT= QYN cLߟC5^?Xqv\WPƥα:)u Yi&h6b|sZAR&; @niQS41C ~!`3bre+oeib&(EGT0Ѣ lߠ -o +fQac<)PPcTB繄yazkIS2c\'W ĥ~PYozrEk-oAWFq7宣*Y!GY-t1GNhDU/]#~rQW+"CK*()ʃ[".*/㾯v߫*MfMB,'~^PxlKІ<7fNo'iPXZ8Tb:XN5a9h`]3:ms餈ot*tmnoYwv%6F[Lp BDɤUZSfKֲHtD\"`KJخa]gz?*t #ao frӎQC3N4{~R~R΀[6 )Ll̅ܫwXO( pyԧez ?i! cDDjUVk: >S^!ʀuѲG I@NmDVQqghm{ L!ǸqCd& o|Ǔ7Fu]mHdtl̈́]n8BQDT1PO+UF]עH9)˄M#3wP3]~lNA)YX }ai11Ʌ1vq@2 AȤ"ALvH]ci\h/¡ c4OܾUlkv BZH)#k|D2<%|^Ca-NtC7:11D\3S8umTJ1þ @i>c}h?ÂgQڑyqN{)>; >TʝyOg|?{.q.5-DTʛR/:KHڗ 29 @,p.vVާzZqpE '4abjˑym,fhw2pBdS⧷  ENk>Ք+paZDFFA ̑ HA\ ێIjiG`V$$%׈FKrޱ#r7VO7&US"ELL_'nLG  d'Mz񥒤c.8*5  6kl,栍rmI"U߁lX|$˺(@yZ jڝ!}=nO"zӊq8 j:># e_4%wGE;Y37UM hۃ$̖toVh<[3kpa2FFh0FzpиɢW|WK5k  =&Zvd (mhP:٠!I3IAnFjrm?Jhn[y=:664Ӭd7Rt sdTL7rzxZxFd*P@5u=Ahs83$4z#FR0be|u.=FZzv4||P&b{ 6 A 3“!#eWF:/qV퍰DXB[v< yH, ݆@ =Y)XG9:U 6 ֨1gIPЊhE٫1WB>_B-L2a(Ȋ]#e}l77Ts`Zf9؎s?h럚ɦi㜷[HR1mmXX.%}u)7[.t(`UxFMU4;bDI ܐ\mYO(nSH̛jfA _NWّ 2 ~V`&NqǸ -'{;a)-"l;~D%{/YќW?׵E;y|+QwlUٴ>xT½;暜-ŁX_^JdRd sҔ;Utj̆2F'U|'\rAvi|>Q&3ہy!` @ .[8L6lv 1o > 4' &k'Rk B.=_gmC/Hs\AfJwU 'U e?w: lM\P8P-Yh4T6˵MceJaKϺ;Ԧ@(k{kt7/2&T:O7ws;É$\jO{v2ilJ7{.dC5EE͹h1\p tN}1M*jb]iOD3`xI{^@{;՗EQӷO/"Z2\O7eAf#m nad*>ܙ˓S\}=6`Z@|$5(9ӡP9V M}/KIû? (iR; (̵wAQUm MJ"Pw=шުG@g v`.5TّHh-eM7Sy Ԫ!"q<^VưC - U Vэ[`a0>m,[: 0`1qgh Ck " 8LP6!5hTGNexC[d4w6@%OU͓2u j{cZiHʛx!' Yvt$$'a #TP2kI(maR(|#j5u(po IQnKǨ VBrz&=:'M";{<`d]O*<wcHh4&,%u F5}`Hŧc* VBk 0sy c}EKAyepvt.xWN֫#@wYC|x^Bby.yRT.iyybKr |QO-|{XB5/sF3P6MEl)XH w]-'=&V5hR=nF-x,yw>䃹nBHN nΩ\ Z`vƕ L>ͮ\<~>xX 83QLuDtL}cي9o100644 router.goGqE}Kp[x40000 runtimei " P"|6+W¯.WDB< YGߓXR6&:Jrﮯ100644 zip.goUh@“Fw_RN/X'f-=xoC#{z~ZfRjbF6WR: xkhZ1p4@ +xcc *rEΆ.lloLe [x340031QH,(+)fe*nݝ}rنyz M=o<;%e򇂑ėJ[Yv@muC7f~,Lx#KfF̤ԢWyX yx;od%]ZfRj~BBUAZ_@s^qfRiGcxPPaIIdQW4#rS@&y'${dx:&zDe'EDdd皀LλٍgrZ#Ck-rC *}BMK""=2B=,ʳ|+ - M |'3MV ,ڻy [GBlbxirx͡b*,'!x`<7?4'U!=$4I/9?W*@($_*+=_PLτ(4(UAs%汨Jv%- V)X9~.MT<*| y)@P) y%t!MNk^T6.94\y0y1 U@3J]7y4E5QDyFIIBPjQcT=9yzEy% zhKn(![(B\>x;_k){z~ZfRjF;fQD9;x[t|{z~ZfRjF0wxCX6 ? #x;!vLl2{z~ZfRjFnAWxJ?ĵk V';100644 handler_test.go{ddY /k6md\!Jx*Yn{z~ZfRjFO|CHH x340031QH+K/HKgP`v่ʭåGW6}3(()))1cyǶmߥX II|Ijq H-tq|:_I]PuUE EO)RNk=߲n|C< x8qBHGy%+W8v sMi x,Qp{z~ZfRjF?Hx1cf̤ԢX )xM Ax/f:AF5E*q100644 transport_test.go,)GCf]& .xiRmvI4Ĕ" XYoZx`6EfFܛIX10xH 6N3f sl}|100644 go.sum}JrˇDVq޶!HEmHx[ɵkC `k_ox[cȃy_4i='ꘈh:~ίEn,bo0H[nN꾐37yqZ-+L^R 5E/=Ab#VJz63%Vz̮f&& U e)w~!E%iEI s)>Wy,UbwcQpϫ۽Pq(+N-,J3dy=83B槔嗖3l~bRHQW\[\R,oҳb_"NVo+M*,.I/+abao__ٚoDeyjRq~rvj o3ٽ!Ԋ5U%) s^n)R}m)KnʽYx340031QH,(+)fe*nݝ}rنyz z~ƥN>9j aHJKRK@d٭,; lպ!x,x%]fGHH&W-_!8x340031QMKg(?חt;n)/Vx340031QMKg{ ǖK>~/tfWxysQA %+  %MMZ.m5x340031QMKgH|Zݖoxx[ʵk GHH&W-Ụx340031QMKgX(afRE{v<2x340031QMKg('v)/'憝4i< ox{ vWlC''GHHIJ٣x340031QMKg_93F4/&5?2j x340031QMKg8$|nY!:UL9 ߣx340031QMKgWv˘>ίVJaeE x340031QMKg(Ǭ ]P.g;b > _x,wYbAjcBzj^jQbIf~^B~BAjBIeAjBQ~iIdA훹XD'aS̛ħ/生R``P99G.iZThRE%Eykqւ@XPP\RT\P^7d-^C.=Ԋ ɱʓAνxUn6=G_1[Y޼&]lKCI-D"U #!e;qE/%oy3lE~+VTmUM8:*4x*f~ /];m6jvzKhE1-גzZlէy4Z U$d;|\~:)`5ˋIjFvBIh5>Βm-rHTYr~=?; g4}\.wt*DM_)uPlgFo#upҏڭC nDꙥxxr$mi|F|-/0\_3'>]!b+L 4Vu$6iST̤ħVTE+hSJR;JHz;◍R YOh; 7HBB^ޒpx"e%w/:dbe!6϶.1m> $/"l'B®S$ vk u3P+d)U+|HD% }4ch|(RƵ>8!W'ƐӍN ~ڶ]rH}}.s=>hO 0>~V֦Ϟ;r3ܛM!nFxXvX1.y8]YVH[/K~q,xuyFԢT %+K3Sc%70-adOOLJ-|YK* @A)=$4I/9?W([P_y sT2ӹ8sSrJ+L=0$46VP_ lcAg~A>AشҼd MԢ|r- uE % Q EE 9%yE: ũ% I >`"A@+|KKR+6 ecJN.6ImaBxr100644 go.modcxPB!p'j kF100644 go.sumT` @ Nݕ|ni100644 zip.goH`bX=92b100644 zip_test.goW .YlA" 7+5x[>Ac#d=&d&3sf(LeĔ:y-s 'NNa*J-ILNU(*hkbrwxr4! $CZH O\  21.0 h1:DDGhuTBNqkmNax7QV/VvkInJR7hiOcybwUjN3YBt8fgQgo v1.1;o1 ).xxK// Package zip is the ZAP-native web framework for every Lux/Hanzo Go binary // (all nodes — luxd/hanzod/zood/parsd — the gateway, and all cloud services). // // One framework, one way: gofiber v3 for routing + middleware, served over ZAP // as the PRIMARY transport, with a plain-HTTP listener as an optional extra. // Because the transport is ZAP, ZAP + MCP ride on top natively for free. // // a := zip.New() // a.Fiber().Get("/v1/health", healthz) // static routes + middleware // a.MountFast("/v1/bc/C", chainHandler) // runtime chain mounts (post-Listen) // a.Serve(":9632", ":9630") // ZAP primary + HTTP extra package zip import ( "net/http" "sort" "strings" "sync" "github.com/gofiber/fiber/v3" "github.com/valyala/fasthttp" "github.com/valyala/fasthttp/fasthttpadaptor" zaphttp "github.com/zap-proto/http" ) // Config aliases fiber.Config so the router is configured in one place. type Config = fiber.Config // Handler aliases the fiber v3 handler (func(fiber.Ctx) error). type Handler = fiber.Handler // App is a ZAP-native web application. type App struct { fiber *fiber.App mu sync.RWMutex dyn []dynRoute // longest-prefix first zap *zaphttp.Server } type dynRoute struct { prefix string h fasthttp.RequestHandler } // New builds an App. Optional Config passes straight through to fiber. func New(cfg ...Config) *App { a := &App{} a.fiber = fiber.New(cfg...) // Runtime dynamic dispatch, ahead of the static routes: longest-prefix match // over a mutable registry. This is how a node registers chain handlers AFTER // the listeners are already serving — Fiber's static tree can't take routes // post-Listen, this registry can. a.fiber.Use(func(c fiber.Ctx) error { if h := a.match(c.Path()); h != nil { h(c.RequestCtx()) return nil } return c.Next() }) return a } func (a *App) match(path string) fasthttp.RequestHandler { a.mu.RLock() defer a.mu.RUnlock() for i := range a.dyn { // sorted longest-prefix first if strings.HasPrefix(path, a.dyn[i].prefix) { return a.dyn[i].h } } return nil } // Fiber exposes the underlying router for static Get/Post/Group/Use registration. func (a *App) Fiber() *fiber.App { return a.fiber } // Handler is the fasthttp handler both listeners serve. func (a *App) Handler() fasthttp.RequestHandler { return a.fiber.Handler() } // Mount attaches a net/http.Handler at prefix. VM and chain handlers are // net/http — this is the ONE net/http boundary, adapted to fasthttp. func (a *App) Mount(prefix string, h http.Handler) { a.MountFast(prefix, fasthttpadaptor.NewFastHTTPHandler(h)) } // MountFast registers/replaces a fasthttp handler at prefix. Safe to call at // runtime after the listeners are serving. Longest matching prefix wins. func (a *App) MountFast(prefix string, h fasthttp.RequestHandler) { a.mu.Lock() defer a.mu.Unlock() for i := range a.dyn { if a.dyn[i].prefix == prefix { a.dyn[i].h = h return } } a.dyn = append(a.dyn, dynRoute{prefix: prefix, h: h}) sort.Slice(a.dyn, func(i, j int) bool { return len(a.dyn[i].prefix) > len(a.dyn[j].prefix) }) } // Unmount removes a mounted prefix. func (a *App) Unmount(prefix string) { a.mu.Lock() defer a.mu.Unlock() out := a.dyn[:0] for _, r := range a.dyn { if r.prefix != prefix { out = append(out, r) } } a.dyn = out } // ListenZAP serves over ZAP — the PRIMARY transport. Blocks until Shutdown. func (a *App) ListenZAP(addr string) error { s := &zaphttp.Server{Addr: addr, Handler: a.fiber.Handler()} a.mu.Lock() a.zap = s a.mu.Unlock() return s.ListenAndServe() } // ListenHTTP serves plain HTTP — the optional EXTRA transport. Blocks. func (a *App) ListenHTTP(addr string) error { return a.fiber.Listen(addr) } // Serve runs ZAP (primary) and, when httpAddr != "", HTTP (extra) concurrently, // returning the first listener error. func (a *App) Serve(zapAddr, httpAddr string) error { errc := make(chan error, 2) go func() { errc <- a.ListenZAP(zapAddr) }() if httpAddr != "" { go func() { errc <- a.ListenHTTP(httpAddr) }() } return <-errc } // Shutdown stops both listeners. func (a *App) Shutdown() error { a.mu.RLock() z := a.zap a.mu.RUnlock() if z != nil { _ = z.Close() } return a.fiber.Shutdown() } `Ix \package zip import ( "io" "net" "net/http" "testing" "time" "github.com/gofiber/fiber/v3" "github.com/valyala/fasthttp" zaphttp "github.com/zap-proto/http" ) // call drives the app's fasthttp handler in-process (no network). func call(a *App, method, path string) (int, string) { ctx := &fasthttp.RequestCtx{} ctx.Request.Header.SetMethod(method) ctx.Request.SetRequestURI(path) a.Handler()(ctx) return ctx.Response.StatusCode(), string(ctx.Response.Body()) } func TestStaticRoute(t *testing.T) { a := New() a.Fiber().Get("/v1/health", func(c fiber.Ctx) error { return c.SendString("ok") }) if code, body := call(a, "GET", "/v1/health"); code != 200 || body != "ok" { t.Fatalf("static route: got %d %q", code, body) } } func TestDynamicMountAndUnmount(t *testing.T) { a := New() a.MountFast("/v1/bc/C", func(ctx *fasthttp.RequestCtx) { ctx.SetStatusCode(200) ctx.SetBodyString("C-chain") }) if code, body := call(a, "POST", "/v1/bc/C/rpc"); code != 200 || body != "C-chain" { t.Fatalf("dynamic mount: got %d %q", code, body) } a.Unmount("/v1/bc/C") if code, _ := call(a, "POST", "/v1/bc/C/rpc"); code == 200 { t.Fatalf("after unmount expected non-200, got %d", code) } } func TestNetHTTPMount(t *testing.T) { a := New() a.Mount("/v1/info", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(200) _, _ = io.WriteString(w, "info-ok") })) if code, body := call(a, "GET", "/v1/info"); code != 200 || body != "info-ok" { t.Fatalf("net/http mount: got %d %q", code, body) } } func TestLongestPrefixWins(t *testing.T) { a := New() a.MountFast("/v1", func(ctx *fasthttp.RequestCtx) { ctx.SetBodyString("root") }) a.MountFast("/v1/bc/C", func(ctx *fasthttp.RequestCtx) { ctx.SetBodyString("cchain") }) if _, body := call(a, "GET", "/v1/bc/C/rpc"); body != "cchain" { t.Fatalf("longest-prefix: got %q", body) } if _, body := call(a, "GET", "/v1/status"); body != "root" { t.Fatalf("prefix fallback: got %q", body) } } // TestZAPPrimaryRoundTrip proves the SAME app served over the ZAP transport // returns identical results — ZAP is the primary path. func TestZAPPrimaryRoundTrip(t *testing.T) { a := New() a.MountFast("/v1/ping", func(ctx *fasthttp.RequestCtx) { ctx.SetBodyString("pong") }) ln, err := net.Listen("tcp", "127.0.0.1:0") if err != nil { t.Fatal(err) } srv := &zaphttp.Server{Handler: a.Handler()} go func() { _ = srv.Serve(ln) }() defer srv.Close() time.Sleep(50 * time.Millisecond) tr := zaphttp.NewTransport(ln.Addr().String()) defer tr.CloseIdleConnections() req := fasthttp.AcquireRequest() resp := fasthttp.AcquireResponse() defer fasthttp.ReleaseRequest(req) defer fasthttp.ReleaseResponse(resp) req.SetRequestURI("http://zap/v1/ping") req.Header.SetMethod("GET") if err := tr.Do(req, resp); err != nil { t.Fatalf("zap round-trip: %v", err) } if got := string(resp.Body()); got != "pong" { t.Fatalf("zap round-trip: got %q want pong", got) } } n W?=OZCJ.