@pikku/cli 0.12.105 → 0.12.107

package/surface.json

@@ -0,0 +1,4464 @@
+{
+  "version": "0.12.107",
+  "entryPoints": [
+    {
+      "id": "app",
+      "job": "build an app",
+      "summary": "This is the door you open to build a service. The CLI generates a barrel per concern into .pikku, package.json maps #pikku onto it, and everything below runs in the order you actually meet it while building — write a function, give it what it needs, decide how the world reaches it, say who may call it, compose it, then drive the whole thing in a test.",
+      "specifierBase": "#pikku",
+      "leaves": [
+        {
+          "specifier": "#pikku/function",
+          "name": "function",
+          "step": "create a function",
+          "summary": "The function definers every wiring eventually points at, and the types they are written against.",
+          "symbols": [
+            {
+              "name": "InferSchemaOutput",
+              "kind": "type",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "Helper type to infer the output type from a Standard Schema",
+              "docs": "Helper type to infer the output type from a Standard Schema"
+            },
+            {
+              "name": "NodeConfig",
+              "kind": "type",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "Inline node configuration for function definitions.",
+              "docs": "Inline node configuration for function definitions."
+            },
+            {
+              "name": "pikkuApprovalDescription",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "Factory function for creating approval description functions with tree-shaking support.",
+              "docs": "Factory function for creating approval description functions with tree-shaking support."
+            },
+            {
+              "name": "PikkuApprovalDescription",
+              "kind": "type",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "A function that generates a human-readable description of a pending approval action. Used by AI agents to show meaningful approval prompts instead of raw tool arguments.",
+              "docs": "A function that generates a human-readable description of a pending approval action.\nUsed by AI agents to show meaningful approval prompts instead of raw tool arguments."
+            },
+            {
+              "name": "pikkuFunc",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "Creates a Pikku function that can be either session-aware or sessionless. This is the main function wrapper for creating API endpoints.",
+              "docs": "Creates a Pikku function that can be either session-aware or sessionless.\nThis is the main function wrapper for creating API endpoints.\n\nDefine the input and output with Zod schemas — the function's types are\ninferred from them, and the schemas double as runtime validation."
+            },
+            {
+              "name": "PikkuFunction",
+              "kind": "type",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "A session-aware API function that requires user authentication. Use this for protected endpoints that need access to user session data.",
+              "docs": "A session-aware API function that requires user authentication.\nUse this for protected endpoints that need access to user session data."
+            },
+            {
+              "name": "PikkuFunctionConfig",
+              "kind": "type",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "Configuration object for Pikku functions with optional middleware, permissions, tags, and documentation. This type wraps CorePikkuFunctionConfig with the user's custom types.",
+              "docs": "Configuration object for Pikku functions with optional middleware, permissions, tags, and documentation.\nThis type wraps CorePikkuFunctionConfig with the user's custom types."
+            },
+            {
+              "name": "PikkuFunctionSessionless",
+              "kind": "type",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "A sessionless API function that doesn't require user authentication. Use this for public endpoints, health checks, or operations that don't need user context.",
+              "docs": "A sessionless API function that doesn't require user authentication.\nUse this for public endpoints, health checks, or operations that don't need user context."
+            },
+            {
+              "name": "pikkuListFunc",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              }
+            },
+            {
+              "name": "pikkuRemoteChannelFunc",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "Declares a capability the connected client answers, reachable from any `wireChannel` function as `channel.remote(name, input)`.",
+              "docs": "Declares a capability the connected client answers, reachable from any\n`wireChannel` function as `channel.remote(name, input)`.\n\nThere is no `func`: this side owns the contract, the client owns the body.\nThe `description` is what a person is shown when asked to approve the call,\nso write it for them rather than for the caller."
+            },
+            {
+              "name": "pikkuSessionlessFunc",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "Creates a sessionless Pikku function that doesn't require user authentication. Use this for public endpoints, webhooks, or background tasks.",
+              "docs": "Creates a sessionless Pikku function that doesn't require user authentication.\nUse this for public endpoints, webhooks, or background tasks.\n\nDefine the input and output with Zod schemas — the function's types are\ninferred from them, and the schemas double as runtime validation."
+            },
+            {
+              "name": "pikkuVoidFunc",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "Creates a function that takes no input and returns no output. Useful for health checks, triggers, or cleanup operations.",
+              "docs": "Creates a function that takes no input and returns no output.\nUseful for health checks, triggers, or cleanup operations."
+            },
+            {
+              "name": "ref",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "References a registered function by name for use in any wiring. Works for both local and addon functions — resolves via RPC at runtime.",
+              "docs": "References a registered function by name for use in any wiring.\nWorks for both local and addon functions — resolves via RPC at runtime."
+            },
+            {
+              "name": "refChannel",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              }
+            },
+            {
+              "name": "refCLI",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              }
+            },
+            {
+              "name": "refHTTP",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              }
+            },
+            {
+              "name": "Services",
+              "kind": "interface",
+              "origin": {
+                "via": "package",
+                "packageName": "@pikku/templates-functions"
+              }
+            },
+            {
+              "name": "Session",
+              "kind": "type",
+              "origin": {
+                "via": "generated"
+              }
+            },
+            {
+              "name": "SingletonServices",
+              "kind": "interface",
+              "origin": {
+                "via": "package",
+                "packageName": "@pikku/templates-functions"
+              }
+            },
+            {
+              "name": "WiredServices",
+              "kind": "type",
+              "origin": {
+                "via": "generated"
+              }
+            },
+            {
+              "name": "WiredSingletonServices",
+              "kind": "type",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "The services a wired function actually receives. The inspector records which services each wired `func`, `permissions` and `middleware` destructures and emits them as `RequiredSingletonServices`; intersecting that here makes those services **non-optional** at every call site. A service is optional only when nothing destructures it — in which case it is never created either. This is why an `if (!service)` guard inside a function body is always dead code.",
+              "docs": "The services a wired function actually receives. The inspector records which\nservices each wired `func`, `permissions` and `middleware` destructures and\nemits them as `RequiredSingletonServices`; intersecting that here makes those\nservices **non-optional** at every call site. A service is optional only when\nnothing destructures it — in which case it is never created either. This is\nwhy an `if (!service)` guard inside a function body is always dead code."
+            }
+          ]
+        },
+        {
+          "specifier": "#pikku/setup",
+          "name": "setup",
+          "step": "create a function",
+          "summary": "The three factories a project declares exactly once — its config, its singleton services and its per-wire services. An addon declares the same three in its own flavour, handed the logger, variables and secrets the host application already built. Everything else on this page is imported by features; these are imported by bootstrap and then left alone.",
+          "symbols": [
+            {
+              "name": "Config",
+              "kind": "interface",
+              "origin": {
+                "via": "package",
+                "packageName": "@pikku/templates-functions"
+              }
+            },
+            {
+              "name": "pikkuConfig",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "Creates a Pikku config factory. Use this to define your application's configuration factory.",
+              "docs": "Creates a Pikku config factory.\nUse this to define your application's configuration factory."
+            },
+            {
+              "name": "pikkuServices",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "Creates a Pikku singleton services factory. Use this to define services that are created once and shared across all requests.",
+              "docs": "Creates a Pikku singleton services factory.\nUse this to define services that are created once and shared across all requests."
+            },
+            {
+              "name": "pikkuWireServices",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "Creates a Pikku wire services factory. Use this to define services that are created per-request/session.",
+              "docs": "Creates a Pikku wire services factory.\nUse this to define services that are created per-request/session."
+            }
+          ]
+        },
+        {
+          "specifier": "#pikku/addon",
+          "name": "addon",
+          "step": "enhance it",
+          "summary": "Installs an addon into this application, on its own or over rpc against a remote one.",
+          "symbols": [
+            {
+              "name": "wireAddon",
+              "kind": "function",
+              "origin": {
+                "via": "core",
+                "subpath": "./addon"
+              }
+            },
+            {
+              "name": "wireRemoteAddon",
+              "kind": "function",
+              "origin": {
+                "via": "core",
+                "subpath": "./addon"
+              }
+            }
+          ]
+        },
+        {
+          "specifier": "#pikku/error",
+          "name": "error",
+          "step": "enhance it",
+          "summary": "The errors your functions throw and the HTTP status each one maps to, so a thrown error is part of the contract rather than a stack trace.",
+          "symbols": [
+            {
+              "name": "addError",
+              "kind": "function",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "AIProviderAuthError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "AIProviderNotConfiguredError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "BadGatewayError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "BadRequestError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "ConflictError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "ErrorDetails",
+              "kind": "interface",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "ExpectationFailedError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "ForbiddenError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "GatewayTimeoutError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "GoneError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "HTTPVersionNotSupportedError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "InternalServerError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "InvalidMiddlewareWireError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "InvalidOriginError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "InvalidSessionError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "isExpectedError",
+              "kind": "function",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              },
+              "summary": "A `PikkuError`, or any error carrying `expected: true` — the marker that survives serialization across a workflow step boundary and rehydration as a plain `Error`. Callers log the message alone for these, the full stack for everything else.",
+              "docs": "A `PikkuError`, or any error carrying `expected: true` — the marker that\nsurvives serialization across a workflow step boundary and rehydration as a\nplain `Error`. Callers log the message alone for these, the full stack for\neverything else."
+            },
+            {
+              "name": "LengthRequiredError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "LocalEnvironmentOnlyError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "LockedError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "MaxComputeTimeReachedError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "MethodNotAllowedError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "MissingCredentialError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "MissingSchemaError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "MissingScopeError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "MissingServiceError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "MissingSessionError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "NotAcceptableError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "NotFoundError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "NotImplementedError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "PayloadTooLargeError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "PaymentRequiredError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "PikkuError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "PikkuMissingMetaError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "PreconditionFailedError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "ProxyAuthenticationRequiredError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "RangeNotSatisfiableError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "ReadonlySessionError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "RequestTimeoutError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "SerializedError",
+              "kind": "interface",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "ServiceUnavailableError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "SystemRoleImmutableError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              },
+              "summary": "An administrative operation targeted a role that is declared in code.",
+              "docs": "An administrative operation targeted a role that is declared in code.\n\nSystem roles ship with the product: the console may show and grant them, but\nrenaming, re-scoping or deleting one would let a UI action silently change\nwhat a declared persona means, and what every scenario written against that\nrole is actually testing."
+            },
+            {
+              "name": "SystemRoleShadowedError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              },
+              "summary": "A role was created with the name of a role declared in code.",
+              "docs": "A role was created with the name of a role declared in code.\n\nShadowing is refused rather than merged: two rows answering to one name make\n\"does Susan hold `buyer`?\" depend on which one the store happened to return."
+            },
+            {
+              "name": "TooManyRequestsError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "UnauthorizedError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "UnprocessableContentError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "UnsupportedMediaTypeError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "URITooLongError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "WeakKeyMaterialError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            }
+          ]
+        },
+        {
+          "specifier": "#pikku/middleware",
+          "name": "middleware",
+          "step": "enhance it",
+          "summary": "Middleware is one concept regardless of what it ends up attached to, so it is one import: define it here, then register it globally, against a tag, or against an HTTP route or channel.",
+          "symbols": [
+            {
+              "name": "addChannelMiddleware",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              }
+            },
+            {
+              "name": "addGlobalMiddleware",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "Wire-agnostic global middleware. Runs at the top of every wiring's middleware chain — before wire-, tag-, and function-level entries.",
+              "docs": "Wire-agnostic global middleware. Runs at the top of every wiring's\nmiddleware chain — before wire-, tag-, and function-level entries.\n\nResolution order: global -> wire -> tag -> function."
+            },
+            {
+              "name": "addHTTPMiddleware",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "Registers HTTP middleware either globally or for a specific route pattern.",
+              "docs": "Registers HTTP middleware either globally or for a specific route pattern.\n\nWhen a string route pattern is provided along with middleware, the middleware\nis applied only to that route. Otherwise, if an array is provided, it is treated\nas global middleware (applied to all routes)."
+            },
+            {
+              "name": "addTagMiddleware",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "Tag-scoped middleware. Applies to any wiring that carries the matching tag.",
+              "docs": "Tag-scoped middleware. Applies to any wiring that carries the matching tag."
+            },
+            {
+              "name": "cors",
+              "kind": "function",
+              "origin": {
+                "via": "core",
+                "subpath": "./middleware"
+              },
+              "summary": "Sets CORS headers on every response and short-circuits OPTIONS preflight with a 204. `origin: true` reflects the request origin; an array reflects a matching origin and otherwise sends no `Access-Control-Allow-Origin` at all, so the browser reports \"origin not allowed\" rather than an origin mismatch against whichever entry happened to be first.",
+              "docs": "Sets CORS headers on every response and short-circuits OPTIONS preflight\nwith a 204. `origin: true` reflects the request origin; an array reflects a\nmatching origin and otherwise sends no `Access-Control-Allow-Origin` at all,\nso the browser reports \"origin not allowed\" rather than an origin mismatch\nagainst whichever entry happened to be first."
+            },
+            {
+              "name": "MiddlewarePriority",
+              "kind": "type",
+              "origin": {
+                "via": "core",
+                "subpath": "./middleware"
+              },
+              "summary": "Execution order: `highest` runs first (outermost in the onion), `lowest` runs last, closest to the function.",
+              "docs": "Execution order: `highest` runs first (outermost in the onion), `lowest`\nruns last, closest to the function."
+            },
+            {
+              "name": "pikkuAgentMiddleware",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              }
+            },
+            {
+              "name": "pikkuChannelMiddleware",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              }
+            },
+            {
+              "name": "PikkuChannelMiddleware",
+              "kind": "type",
+              "origin": {
+                "via": "generated"
+              }
+            },
+            {
+              "name": "pikkuChannelMiddlewareFactory",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              }
+            },
+            {
+              "name": "pikkuMiddleware",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "Factory function for creating middleware with tree-shaking support. Supports both direct function and configuration object syntax.",
+              "docs": "Factory function for creating middleware with tree-shaking support.\nSupports both direct function and configuration object syntax."
+            },
+            {
+              "name": "PikkuMiddleware",
+              "kind": "type",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "Type-safe middleware definition that can access your application's services and session. Use this to define reusable middleware that can be applied to multiple wirings.",
+              "docs": "Type-safe middleware definition that can access your application's services and session.\nUse this to define reusable middleware that can be applied to multiple wirings."
+            },
+            {
+              "name": "pikkuMiddlewareFactory",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "Factory function for creating middleware factories Use this when your middleware needs configuration/input parameters",
+              "docs": "Factory function for creating middleware factories\nUse this when your middleware needs configuration/input parameters"
+            }
+          ]
+        },
+        {
+          "specifier": "#pikku/secrets",
+          "name": "secrets",
+          "step": "enhance it",
+          "summary": "Secrets a function can use without ever holding, declared here and resolved by the secrets service at runtime.",
+          "symbols": [
+            {
+              "name": "CredentialsMap",
+              "kind": "type",
+              "origin": {
+                "via": "generated"
+              }
+            },
+            {
+              "name": "defineSecret",
+              "kind": "function",
+              "origin": {
+                "via": "core",
+                "subpath": "./secret"
+              }
+            },
+            {
+              "name": "TypedSecretService",
+              "kind": "class",
+              "origin": {
+                "via": "generated"
+              }
+            }
+          ]
+        },
+        {
+          "specifier": "#pikku/variables",
+          "name": "variables",
+          "step": "enhance it",
+          "summary": "Configuration a function reads through the variables service, declared once so a deployment can be checked for what it is missing.",
+          "symbols": [
+            {
+              "name": "defineVariable",
+              "kind": "function",
+              "origin": {
+                "via": "core",
+                "subpath": "./variable"
+              }
+            },
+            {
+              "name": "TypedVariablesService",
+              "kind": "class",
+              "origin": {
+                "via": "generated"
+              }
+            },
+            {
+              "name": "VariablesMap",
+              "kind": "interface",
+              "origin": {
+                "via": "generated"
+              }
+            }
+          ]
+        },
+        {
+          "specifier": "#pikku/channel",
+          "name": "channel",
+          "step": "wire it up",
+          "summary": "Wires a function to a websocket channel, its message routes and its pub/sub topics.",
+          "symbols": [
+            {
+              "name": "defineChannelRoutes",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "Type-safe helper for defining channel message routes that can be composed. Returns the routes record as-is for use with wireChannel's onMessageWiring.",
+              "docs": "Type-safe helper for defining channel message routes that can be composed.\nReturns the routes record as-is for use with wireChannel's onMessageWiring."
+            },
+            {
+              "name": "pikkuChannelConnectionFunc",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "Creates a function that handles WebSocket channel connections. Called when a client connects to a channel.",
+              "docs": "Creates a function that handles WebSocket channel connections.\nCalled when a client connects to a channel."
+            },
+            {
+              "name": "pikkuChannelDisconnectionFunc",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "Creates a function that handles WebSocket channel disconnections. Called when a client disconnects from a channel.",
+              "docs": "Creates a function that handles WebSocket channel disconnections.\nCalled when a client disconnects from a channel."
+            },
+            {
+              "name": "pikkuChannelFunc",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "Creates a function that handles WebSocket channel messages. Called when a message is received on a channel.",
+              "docs": "Creates a function that handles WebSocket channel messages.\nCalled when a message is received on a channel.\n\nSupports two patterns:\n1. Generic types: `pikkuChannelFunc<Input, Output>({ func: ... })`\n2. Zod schemas: `pikkuChannelFunc({ input: z.object(...), func: ... })`"
+            },
+            {
+              "name": "wireChannel",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "Registers a WebSocket channel with the Pikku framework.",
+              "docs": "Registers a WebSocket channel with the Pikku framework."
+            }
+          ]
+        },
+        {
+          "specifier": "#pikku/cli",
+          "name": "cli",
+          "step": "wire it up",
+          "summary": "Wires a function as a command, with its flags and arguments derived from the function input.",
+          "symbols": [
+            {
+              "name": "defineCLICommands",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "Type-safe helper for defining CLI commands that can be composed and spread into wireCLI.",
+              "docs": "Type-safe helper for defining CLI commands that can be composed and spread into wireCLI."
+            },
+            {
+              "name": "pikkuCLICommand",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "Creates a CLI command definition with automatic option inference from the function's input type. This allows TypeScript to automatically derive CLI options from the function signature.",
+              "docs": "Creates a CLI command definition with automatic option inference from the function's input type.\nThis allows TypeScript to automatically derive CLI options from the function signature."
+            },
+            {
+              "name": "pikkuCLIRender",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "Creates a type-safe CLI renderer with access to your application's singleton services. The renderer receives the full singleton services and output data to format and display results.",
+              "docs": "Creates a type-safe CLI renderer with access to your application's singleton services.\nThe renderer receives the full singleton services and output data to format and display results."
+            },
+            {
+              "name": "wireCLI",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "Registers a CLI application with the Pikku framework. Creates command-line interfaces with type-safe commands and options.",
+              "docs": "Registers a CLI application with the Pikku framework.\nCreates command-line interfaces with type-safe commands and options."
+            }
+          ]
+        },
+        {
+          "specifier": "#pikku/gateway",
+          "name": "gateway",
+          "step": "wire it up",
+          "summary": "Wires a function behind a gateway that receives requests on behalf of another system.",
+          "symbols": [
+            {
+              "name": "GatewayAdapter",
+              "kind": "interface",
+              "origin": {
+                "via": "core",
+                "subpath": "./gateway"
+              }
+            },
+            {
+              "name": "GatewayInboundMessage",
+              "kind": "interface",
+              "origin": {
+                "via": "core",
+                "subpath": "./gateway"
+              }
+            },
+            {
+              "name": "GatewayOutboundMessage",
+              "kind": "interface",
+              "origin": {
+                "via": "core",
+                "subpath": "./gateway"
+              }
+            },
+            {
+              "name": "GatewayTransportType",
+              "kind": "type",
+              "origin": {
+                "via": "core",
+                "subpath": "./gateway"
+              },
+              "summary": "'webhook' the platform POSTs to us, 'websocket' the client connects to us, 'listener' no route at all.",
+              "docs": "'webhook' the platform POSTs to us, 'websocket' the client connects to us, 'listener' no route at all."
+            },
+            {
+              "name": "GatewayWiring",
+              "kind": "type",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "Type definition for gateway wirings. Declares a gateway name, its transport and its target pikku function.",
+              "docs": "Type definition for gateway wirings.\nDeclares a gateway name, its transport and its target pikku function."
+            },
+            {
+              "name": "PikkuGatewayAdapterFactory",
+              "kind": "type",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "Builds a {@link GatewayAdapter} from your application's services. The core factory type is handed `CoreSingletonServices`; this one receives the services your project actually registered.",
+              "docs": "Builds a {@link GatewayAdapter} from your application's services.\nThe core factory type is handed `CoreSingletonServices`; this one receives\nthe services your project actually registered."
+            },
+            {
+              "name": "WebhookVerificationResult",
+              "kind": "type",
+              "origin": {
+                "via": "core",
+                "subpath": "./gateway"
+              }
+            },
+            {
+              "name": "wireGateway",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "Registers a gateway with the Pikku framework. Runs everywhere — inspector extracts at build time.",
+              "docs": "Registers a gateway with the Pikku framework.\nRuns everywhere — inspector extracts at build time."
+            }
+          ]
+        },
+        {
+          "specifier": "#pikku/http",
+          "name": "http",
+          "step": "wire it up",
+          "summary": "Wires a function to an HTTP route, with the path parameters checked against the function input.",
+          "symbols": [
+            {
+              "name": "defineHTTPRoutes",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "Type-safe helper for defining route contracts that can be composed.",
+              "docs": "Type-safe helper for defining route contracts that can be composed."
+            },
+            {
+              "name": "wireHTTP",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "Registers an HTTP wiring with the Pikku framework.",
+              "docs": "Registers an HTTP wiring with the Pikku framework."
+            },
+            {
+              "name": "wireHTTPRoutes",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "Wires multiple HTTP routes from a nested map or array configuration.",
+              "docs": "Wires multiple HTTP routes from a nested map or array configuration."
+            }
+          ]
+        },
+        {
+          "specifier": "#pikku/mcp",
+          "name": "mcp",
+          "step": "wire it up",
+          "summary": "Wires a function as an MCP tool, resource or prompt for a model to call.",
+          "symbols": [
+            {
+              "name": "pikkuMCPPromptFunc",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "Creates a function for handling MCP prompt requests. These functions generate prompt templates for AI models.",
+              "docs": "Creates a function for handling MCP prompt requests.\nThese functions generate prompt templates for AI models.\n\nSupports two patterns:\n1. Generic types: `pikkuMCPPromptFunc<Input>({ func: ... })`\n2. Zod schemas: `pikkuMCPPromptFunc({ input: z.object(...), func: ... })`"
+            },
+            {
+              "name": "pikkuMCPResourceFunc",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "Creates a function for handling MCP resource requests. These functions provide data that AI models can access.",
+              "docs": "Creates a function for handling MCP resource requests.\nThese functions provide data that AI models can access.\n\nSupports two patterns:\n1. Generic types: `pikkuMCPResourceFunc<Input>({ func: ... })`\n2. Zod schemas: `pikkuMCPResourceFunc({ input: z.object(...), func: ... })`"
+            },
+            {
+              "name": "pikkuMCPToolFunc",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "Creates a function for handling MCP tool invocations. These functions perform actions that AI models can request.",
+              "docs": "Creates a function for handling MCP tool invocations.\nThese functions perform actions that AI models can request.\n\nSupports two patterns:\n1. Generic types: `pikkuMCPToolFunc<Input>({ func: ... })`\n2. Zod schemas: `pikkuMCPToolFunc({ input: z.object(...), func: ... })`"
+            },
+            {
+              "name": "wireMCPPrompt",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "Registers an MCP prompt with the Pikku framework. Prompts provide templates that AI models can use.",
+              "docs": "Registers an MCP prompt with the Pikku framework.\nPrompts provide templates that AI models can use."
+            },
+            {
+              "name": "wireMCPResource",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "Registers an MCP resource with the Pikku framework. Resources provide data that AI models can access.",
+              "docs": "Registers an MCP resource with the Pikku framework.\nResources provide data that AI models can access."
+            }
+          ]
+        },
+        {
+          "specifier": "#pikku/queue",
+          "name": "queue",
+          "step": "wire it up",
+          "summary": "Wires a function as a queue worker, so a job on the queue runs the same handler an HTTP route would.",
+          "symbols": [
+            {
+              "name": "wireQueueWorker",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "Registers a queue worker with the Pikku framework. Workers process background jobs from queues.",
+              "docs": "Registers a queue worker with the Pikku framework.\nWorkers process background jobs from queues."
+            }
+          ]
+        },
+        {
+          "specifier": "#pikku/scheduler",
+          "name": "scheduler",
+          "step": "wire it up",
+          "summary": "Wires a function to a cron expression to run it on a schedule.",
+          "symbols": [
+            {
+              "name": "wireScheduler",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "Registers a scheduled task with the Pikku framework. Tasks run based on cron expressions and are sessionless.",
+              "docs": "Registers a scheduled task with the Pikku framework.\nTasks run based on cron expressions and are sessionless."
+            }
+          ]
+        },
+        {
+          "specifier": "#pikku/trigger",
+          "name": "trigger",
+          "step": "wire it up",
+          "summary": "Wires a function to an event a source emits, rather than to a caller that asks for it.",
+          "symbols": [
+            {
+              "name": "pikkuTriggerFunc",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "Creates a trigger function configuration. Use this to define trigger functions that set up subscriptions.",
+              "docs": "Creates a trigger function configuration.\nUse this to define trigger functions that set up subscriptions."
+            },
+            {
+              "name": "wireTrigger",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "Registers a trigger with the Pikku framework. Declares a trigger name and its target pikku function. Runs everywhere — inspector extracts at build time.",
+              "docs": "Registers a trigger with the Pikku framework.\nDeclares a trigger name and its target pikku function.\nRuns everywhere — inspector extracts at build time."
+            },
+            {
+              "name": "wireTriggerSource",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "Registers a trigger source with the Pikku framework. Provides the subscription function and input data. Only imported in the trigger worker process.",
+              "docs": "Registers a trigger source with the Pikku framework.\nProvides the subscription function and input data.\nOnly imported in the trigger worker process."
+            }
+          ]
+        },
+        {
+          "specifier": "#pikku/auth",
+          "name": "auth",
+          "step": "guard it",
+          "summary": "Who may call a function, and what the call is made with: permissions that see the request, auth gates that run before it, and the credentials a function borrows rather than holds.",
+          "symbols": [
+            {
+              "name": "addGlobalPermission",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "Wire-agnostic global permissions. Runs at the top of every wiring's permission resolution — before wire-, tag-, and function-level entries.",
+              "docs": "Wire-agnostic global permissions. Runs at the top of every wiring's\npermission resolution — before wire-, tag-, and function-level entries.\n\nResolution order: global -> wire -> tag -> function."
+            },
+            {
+              "name": "defineCredential",
+              "kind": "function",
+              "origin": {
+                "via": "core",
+                "subpath": "./credential"
+              },
+              "summary": "Declares a credential. The body is a no-op that tree-shakes away — the CLI reads the call by AST, so the declaration must be a top-level literal. `type: 'wire'` is per-user, `type: 'singleton'` is platform-wide.",
+              "docs": "Declares a credential. The body is a no-op that tree-shakes away — the CLI\nreads the call by AST, so the declaration must be a top-level literal.\n`type: 'wire'` is per-user, `type: 'singleton'` is platform-wide."
+            },
+            {
+              "name": "pikkuAuth",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "Factory function for creating auth-only permissions with tree-shaking support. Auth permissions only receive services and session (no request data), making them evaluable before request data is available.",
+              "docs": "Factory function for creating auth-only permissions with tree-shaking support.\nAuth permissions only receive services and session (no request data),\nmaking them evaluable before request data is available."
+            },
+            {
+              "name": "pikkuBetterAuth",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              }
+            },
+            {
+              "name": "pikkuPermission",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "Factory function for creating permissions with tree-shaking support. Supports both direct function and configuration object syntax.",
+              "docs": "Factory function for creating permissions with tree-shaking support.\nSupports both direct function and configuration object syntax."
+            },
+            {
+              "name": "PikkuPermission",
+              "kind": "type",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "Type-safe API permission definition that integrates with your application's session type. Use this to define authorization logic for your API endpoints.",
+              "docs": "Type-safe API permission definition that integrates with your application's session type.\nUse this to define authorization logic for your API endpoints."
+            },
+            {
+              "name": "pikkuPermissionFactory",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "Factory function for creating permission factories Use this when your permission needs configuration/input parameters",
+              "docs": "Factory function for creating permission factories\nUse this when your permission needs configuration/input parameters"
+            }
+          ]
+        },
+        {
+          "specifier": "#pikku/scopes",
+          "name": "scopes",
+          "step": "guard it",
+          "summary": "The scopes a caller can hold and the roles that grant them, gating a call outside the permission pool.",
+          "symbols": [
+            {
+              "name": "defineScope",
+              "kind": "function",
+              "origin": {
+                "via": "core",
+                "subpath": "./scope"
+              },
+              "summary": "Declares scopes. The body is a no-op that tree-shakes away — the CLI reads the call by AST and generates a `ScopeId` union, so a function referencing an undeclared scope fails the build.",
+              "docs": "Declares scopes. The body is a no-op that tree-shakes away — the CLI reads\nthe call by AST and generates a `ScopeId` union, so a function referencing an\nundeclared scope fails the build.\n\nScopes are keyed by segment at every level: a scope is named by its key, and\nits value describes it. Every node is grantable — the declaration below\nyields `admin`, `admin:invoices`, `admin:invoices:create`,\n`admin:invoices:void` and `billing`."
+            },
+            {
+              "name": "defineSystemRole",
+              "kind": "function",
+              "origin": {
+                "via": "core",
+                "subpath": "./role"
+              },
+              "summary": "No-op function for declaring system roles. This exists purely for TypeScript type checking and will be tree-shaken. The CLI extracts metadata via AST parsing and generates a `SystemRoleName` union, so a persona naming an undeclared role fails the build.",
+              "docs": "No-op function for declaring system roles.\nThis exists purely for TypeScript type checking and will be tree-shaken.\nThe CLI extracts metadata via AST parsing and generates a `SystemRoleName`\nunion, so a persona naming an undeclared role fails the build.\n\nA system role is a role that ships with the product: the console may grant\nit, but cannot rename, re-scope or delete it. Roles an admin composes in the\nconsole are unaffected and are not declared here.\n\nRemoval is deliberately not destructive. Deleting a declaration leaves the\nrow in the store, marked undeclared and inert, until `pikku roles prune` —\nthe same additive contract `defineScope` has, and for the same reason: a\nmid-deploy revocation is not something a code edit should be able to cause."
+            }
+          ]
+        },
+        {
+          "specifier": "#pikku/agent",
+          "name": "agent",
+          "step": "orchestrate it",
+          "summary": "Defines an AI agent, the tools it may call and the scorers that judge what it did.",
+          "symbols": [
+            {
+              "name": "agent",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              }
+            },
+            {
+              "name": "agentApprove",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              }
+            },
+            {
+              "name": "agentResume",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              }
+            },
+            {
+              "name": "agentStream",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              }
+            },
+            {
+              "name": "pikkuAgent",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              }
+            },
+            {
+              "name": "pikkuAgentJudge",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              }
+            },
+            {
+              "name": "pikkuAgentScorer",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              }
+            }
+          ]
+        },
+        {
+          "specifier": "#pikku/workflow",
+          "name": "workflow",
+          "step": "orchestrate it",
+          "summary": "Composes functions into a durable workflow whose steps survive a restart and retry on their own.",
+          "symbols": [
+            {
+              "name": "PikkuFunctionWorkflow",
+              "kind": "type",
+              "origin": {
+                "via": "generated"
+              }
+            },
+            {
+              "name": "pikkuWorkflowComplexFunc",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              }
+            },
+            {
+              "name": "pikkuWorkflowFunc",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              }
+            },
+            {
+              "name": "pikkuWorkflowGraph",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              }
+            },
+            {
+              "name": "TypedWorkflow",
+              "kind": "interface",
+              "origin": {
+                "via": "generated"
+              }
+            },
+            {
+              "name": "WorkflowCancelledException",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./workflow"
+              }
+            }
+          ]
+        },
+        {
+          "specifier": "#pikku/scenarios",
+          "name": "scenarios",
+          "step": "test it",
+          "summary": "Drives features and scenarios against a real running server, in the vocabulary a user would use.",
+          "symbols": [
+            {
+              "name": "createCookieJar",
+              "kind": "function",
+              "origin": {
+                "via": "core",
+                "subpath": "./workflow"
+              }
+            },
+            {
+              "name": "createScenarioRunner",
+              "kind": "function",
+              "origin": {
+                "via": "core",
+                "subpath": "./workflow"
+              },
+              "summary": "A workflow service with the scenario capability attached — the two lines `pikku scenario run` needs, in one call so no caller has to remember that the capability is installed rather than inherited.",
+              "docs": "A workflow service with the scenario capability attached — the two lines\n`pikku scenario run` needs, in one call so no caller has to remember that the\ncapability is installed rather than inherited.\n\nThe in-memory service is the right engine because a scenario run is a single\nexternal process driving a deployed app over its real transport: there is\nnothing to persist and no second worker to resume it."
+            },
+            {
+              "name": "pikkuAddonScenarioStep",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "A step in which a third-party system acts — \"Given Stripe's webhook arrives\", \"When Mailgun bounces it\".",
+              "docs": "A step in which a third-party system acts — \"Given Stripe's webhook arrives\",\n\"When Mailgun bounces it\".\n\n`addon` names the addon that wraps that service, the same name its\n`wireAddon` declares. These steps *are* the mock its consumers currently\nhand-write: shipped by the addon author, maintained with the addon, and the\nsame artifact that appears in the prose.\n\nNote that arranging and asserting are different — \"Stripe's webhook arrives\"\nstubs, \"Then Stripe was charged\" asserts, and only the first is a stub.\n\nLocal-test-only, and never in a virtual user's catalogue: one that could\ninvoke this would forge its own payment success."
+            },
+            {
+              "name": "PikkuBrowserWire",
+              "kind": "interface",
+              "origin": {
+                "via": "core",
+                "subpath": "./workflow"
+              },
+              "summary": "Structural browser handle, present only when the runner provisioned a browser for this step (a `browser` binding on the step config).",
+              "docs": "Structural browser handle, present only when the runner provisioned a\nbrowser for this step (a `browser` binding on the step config).\n\n`@pikku/core` deliberately never imports playwright — it must stay\ndependency-free for edge runtimes. `@pikku/playwright` augments this\ninterface via `declare module`, so `wire.browser.page` is a fully typed\nPlaywright `Page` in a project that installs it."
+            },
+            {
+              "name": "pikkuFeature",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "A feature: an ordered group of scenarios, mirroring gherkin's Feature ↔ Scenario structure. Scenarios are referenced by imported identifier, so a renamed or deleted scenario is a compile error rather than a silent skip.",
+              "docs": "A feature: an ordered group of scenarios, mirroring gherkin's Feature ↔\nScenario structure. Scenarios are referenced by imported identifier, so a\nrenamed or deleted scenario is a compile error rather than a silent skip.\n\nA scenario does not have to belong to a feature — a void-input scenario\nstill runs standalone.\n\n```ts\nexport const credentialFeature = pikkuFeature({\n  name: 'Credential API',\n  tags: ['credential'],\n  before: startsMockOAuthServer,\n  after: stopsMockOAuthServer,\n  scenarios: [\n    credentialLazyLoadScenario,\n    ...['stripe', 'google'].map((name) => ({\n      scenario: credentialRoundTripScenario,\n      data: { name },\n    })),\n  ],\n})\n```"
+            },
+            {
+              "name": "PikkuFeatureEntry",
+              "kind": "type",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "One entry in a feature's `scenarios` list, validated against itself: a bare scenario, or a scenario paired with the input to run it with. The paired form is gherkin's `Examples:` written as an ordinary loop.",
+              "docs": "One entry in a feature's `scenarios` list, validated against itself: a bare\nscenario, or a scenario paired with the input to run it with. The paired form\nis gherkin's `Examples:` written as an ordinary loop."
+            },
+            {
+              "name": "PikkuFunctionScenario",
+              "kind": "type",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "`Ctx` types `scenario.context`, defaulting to the body's own output. A hook returns void but shares the scenario's context, so it passes that scenario's output here instead.",
+              "docs": "`Ctx` types `scenario.context`, defaulting to the body's own output. A hook\nreturns void but shares the scenario's context, so it passes that scenario's\noutput here instead."
+            },
+            {
+              "name": "PikkuFunctionScenarioStep",
+              "kind": "type",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "One surface's implementation of a step.",
+              "docs": "One surface's implementation of a step.\n\nEach binding is typed independently, so a browser binding gets a non-optional\n`wire.browser` and a cli binding a non-optional `wire.cli` without either\nleaking into the other."
+            },
+            {
+              "name": "pikkuPlatformScenarioStep",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "A step in which the app acts on itself — \"Given the platform has expired the trial\".",
+              "docs": "A step in which the app acts on itself — \"Given the platform has expired the\ntrial\".\n\nThe grammatical subject of that sentence is not a user of your app; it **is**\nyour app, which is why it is its own declaration rather than a persona with an\nasterisk. A persona is a person.\n\nLocal-test-only, and never in a virtual user's catalogue: a virtual user that\ncould expire its own trial is manufacturing the outcome it exists to discover."
+            },
+            {
+              "name": "pikkuScenario",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "A scenario: a complex workflow that drives the app the way users do. Steps run as actors over the REAL transport — `scenario.do(step, rpc, data, { actor: actors.yasser })` — so flows double as e2e tests and staged/production health checks (no state reset; scope what you create).",
+              "docs": "A scenario: a complex workflow that drives the app the way users do.\nSteps run as actors over the REAL transport — `scenario.do(step, rpc,\ndata, { actor: actors.yasser })` — so flows double as e2e tests and\nstaged/production health checks (no state reset; scope what you create)."
+            },
+            {
+              "name": "pikkuScenarioHook",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "Declares a scenario hook. Returns the function verbatim — a hook is never registered, so this exists purely to give an inline hook a call site to be contextually typed from, the way every other pikku primitive is.",
+              "docs": "Declares a scenario hook. Returns the function verbatim — a hook is never\nregistered, so this exists purely to give an inline hook a call site to be\ncontextually typed from, the way every other pikku primitive is."
+            },
+            {
+              "name": "PikkuScenarioHook",
+              "kind": "type",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "A scenario lifecycle hook: the scenario's own `(services, data, wire)` signature with its result discarded. `OutputSchema` types `scenario.context` while the return type stays `void`.",
+              "docs": "A scenario lifecycle hook: the scenario's own `(services, data, wire)`\nsignature with its result discarded. `OutputSchema` types\n`scenario.context` while the return type stays `void`."
+            },
+            {
+              "name": "PikkuScenarioRef",
+              "kind": "type",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "A scenario as a feature references it. Any `pikkuScenario` export is assignable; `In` is recovered from it so the paired form's `data` is checked against that scenario's own input.",
+              "docs": "A scenario as a feature references it. Any `pikkuScenario` export is\nassignable; `In` is recovered from it so the paired form's `data` is\nchecked against that scenario's own input."
+            },
+            {
+              "name": "pikkuScenarioStep",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "A named, reusable scenario step, declaring one implementation per surface an actor can drive it through.",
+              "docs": "A named, reusable scenario step, declaring one implementation per surface an\nactor can drive it through.\n\nThe step's identity is what the actor is trying to do; which surface carries\nit out is a binding. That is what lets one ladder run through a real browser,\nover the websocket, or entirely server-side — and what makes \"how much of this\nflow can a human actually reach\" a number rather than a guess.\n\nSteps are deliberately NOT registered as RPCs: a browser-driving step must\nnever be network-callable."
+            },
+            {
+              "name": "pollUntil",
+              "kind": "function",
+              "origin": {
+                "via": "core",
+                "subpath": "./workflow"
+              }
+            },
+            {
+              "name": "postScenarioJson",
+              "kind": "function",
+              "origin": {
+                "via": "core",
+                "subpath": "./services"
+              },
+              "summary": "POST JSON somewhere and report what came back, without throwing on a 4xx/5xx.",
+              "docs": "POST JSON somewhere and report what came back, without throwing on a 4xx/5xx.\n\nEvery scenario that reaches past a persona was writing this by hand — the same\n`content-type`, the same `JSON.stringify`, the same drain — and the copies had\ndrifted: some returned `res.json()`, which loses the status and throws\noutright when the target answers an empty body or an HTML error page. A\nrefusal is the expected outcome of a permissions scenario, so it has to\nsurvive as data."
+            },
+            {
+              "name": "readScenarioHttpResponse",
+              "kind": "function",
+              "origin": {
+                "via": "core",
+                "subpath": "./services"
+              },
+              "summary": "Drain a response into the shape a step can carry: the parsed body (an empty one counting as no body at all) alongside the text it was parsed from.",
+              "docs": "Drain a response into the shape a step can carry: the parsed body (an empty\none counting as no body at all) alongside the text it was parsed from.\n\n`invokeRaw` returns this, and a step that has to reach past a persona — a\nroute with no RPC, an identity no persona can hold — reaches for this rather\nthan writing the same record by hand."
+            },
+            {
+              "name": "requireScenarioEnv",
+              "kind": "function",
+              "origin": {
+                "via": "core",
+                "subpath": "./workflow"
+              }
+            },
+            {
+              "name": "ScenarioHttpResponse",
+              "kind": "interface",
+              "origin": {
+                "via": "core",
+                "subpath": "./services"
+              },
+              "summary": "What the transport answered, for a step that treats the status as data.",
+              "docs": "What the transport answered, for a step that treats the status as data.\n\nAn HTTP response with its body already drained: the stream can only be read\nonce, and a step's return value crosses into the run record, so the response\nobject itself cannot travel. This is the shape every caller ends up with."
+            },
+            {
+              "name": "ScenarioSurface",
+              "kind": "type",
+              "origin": {
+                "via": "core",
+                "subpath": "./workflow"
+              },
+              "summary": "How an actor drives the system for one step.",
+              "docs": "How an actor drives the system for one step.\n\nA step declares one implementation per surface it supports, and the runner\npicks between them — so the same ladder can run through a real browser, over\nthe websocket, or entirely server-side.\n\n`default` is the floor: it is what every other surface falls back to, so it\ncan never itself fall back."
+            },
+            {
+              "name": "TestIdSelector",
+              "kind": "interface",
+              "origin": {
+                "via": "core",
+                "subpath": "./workflow"
+              },
+              "summary": "How a browser step names an element.",
+              "docs": "How a browser step names an element.\n\nA `data-testid` on its own is rarely enough to name exactly one: `where`\nmatches the element's own data attributes (so a step asserts a status\nwithout reading translated copy back to the app), `prefix` matches a family\nof ids, `containing` picks the match holding a piece of text, and `within`\nscopes the lookup to one row or section.\n\nDeclared here so a step's input type is structural; the driver\n(`@pikku/playwright`) is what resolves it against a real page."
+            },
+            {
+              "name": "TypedPersonas",
+              "kind": "type",
+              "origin": {
+                "via": "generated"
+              }
+            },
+            {
+              "name": "TypedScenario",
+              "kind": "type",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "`Out` types `scenario.context`.",
+              "docs": "`Out` types `scenario.context`."
+            },
+            {
+              "name": "TypedScenarioSteps",
+              "kind": "interface",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "The typed half of a scenario wire: `given`/`when`/`then`, narrowed to the names declared by `pikkuScenarioStep` in this project. `given` and `when` differ only in the prose the reporter renders; `then` additionally makes the step's bindings witnesses rather than alternatives.",
+              "docs": "The typed half of a scenario wire: `given`/`when`/`then`, narrowed to the\nnames declared by `pikkuScenarioStep` in this project. `given` and `when`\ndiffer only in the prose the reporter renders; `then` additionally makes the\nstep's bindings witnesses rather than alternatives."
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "id": "addon",
+      "job": "build an addon",
+      "summary": "An addon declares functions and contracts; the host application decides how the world reaches them. The same barrels are generated under #pikku/addon/*, minus every wiring — an addon that called wireHTTP would be registering a route in a registry it does not own.",
+      "specifierBase": "#pikku",
+      "leaves": [
+        {
+          "specifier": "#pikku/addon/function",
+          "name": "function",
+          "step": "create a function",
+          "summary": "The function definers every wiring eventually points at, and the types they are written against.",
+          "symbols": [
+            {
+              "name": "InferSchemaOutput",
+              "kind": "type",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "Helper type to infer the output type from a Standard Schema",
+              "docs": "Helper type to infer the output type from a Standard Schema"
+            },
+            {
+              "name": "NodeConfig",
+              "kind": "type",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "Inline node configuration for function definitions.",
+              "docs": "Inline node configuration for function definitions."
+            },
+            {
+              "name": "pikkuApprovalDescription",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "Factory function for creating approval description functions with tree-shaking support.",
+              "docs": "Factory function for creating approval description functions with tree-shaking support."
+            },
+            {
+              "name": "PikkuApprovalDescription",
+              "kind": "type",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "A function that generates a human-readable description of a pending approval action. Used by AI agents to show meaningful approval prompts instead of raw tool arguments.",
+              "docs": "A function that generates a human-readable description of a pending approval action.\nUsed by AI agents to show meaningful approval prompts instead of raw tool arguments."
+            },
+            {
+              "name": "pikkuFunc",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "Creates a Pikku function that can be either session-aware or sessionless. This is the main function wrapper for creating API endpoints.",
+              "docs": "Creates a Pikku function that can be either session-aware or sessionless.\nThis is the main function wrapper for creating API endpoints.\n\nDefine the input and output with Zod schemas — the function's types are\ninferred from them, and the schemas double as runtime validation."
+            },
+            {
+              "name": "PikkuFunction",
+              "kind": "type",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "A session-aware API function that requires user authentication. Use this for protected endpoints that need access to user session data.",
+              "docs": "A session-aware API function that requires user authentication.\nUse this for protected endpoints that need access to user session data."
+            },
+            {
+              "name": "PikkuFunctionConfig",
+              "kind": "type",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "Configuration object for Pikku functions with optional middleware, permissions, tags, and documentation. This type wraps CorePikkuFunctionConfig with the user's custom types.",
+              "docs": "Configuration object for Pikku functions with optional middleware, permissions, tags, and documentation.\nThis type wraps CorePikkuFunctionConfig with the user's custom types."
+            },
+            {
+              "name": "PikkuFunctionSessionless",
+              "kind": "type",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "A sessionless API function that doesn't require user authentication. Use this for public endpoints, health checks, or operations that don't need user context.",
+              "docs": "A sessionless API function that doesn't require user authentication.\nUse this for public endpoints, health checks, or operations that don't need user context."
+            },
+            {
+              "name": "pikkuListFunc",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              }
+            },
+            {
+              "name": "pikkuRemoteChannelFunc",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "Declares a capability the connected client answers, reachable from any `wireChannel` function as `channel.remote(name, input)`.",
+              "docs": "Declares a capability the connected client answers, reachable from any\n`wireChannel` function as `channel.remote(name, input)`.\n\nThere is no `func`: this side owns the contract, the client owns the body.\nThe `description` is what a person is shown when asked to approve the call,\nso write it for them rather than for the caller."
+            },
+            {
+              "name": "pikkuSessionlessFunc",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "Creates a sessionless Pikku function that doesn't require user authentication. Use this for public endpoints, webhooks, or background tasks.",
+              "docs": "Creates a sessionless Pikku function that doesn't require user authentication.\nUse this for public endpoints, webhooks, or background tasks.\n\nDefine the input and output with Zod schemas — the function's types are\ninferred from them, and the schemas double as runtime validation."
+            },
+            {
+              "name": "pikkuVoidFunc",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "Creates a function that takes no input and returns no output. Useful for health checks, triggers, or cleanup operations.",
+              "docs": "Creates a function that takes no input and returns no output.\nUseful for health checks, triggers, or cleanup operations."
+            },
+            {
+              "name": "ref",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "References a registered function by name for use in any wiring. Works for both local and addon functions — resolves via RPC at runtime.",
+              "docs": "References a registered function by name for use in any wiring.\nWorks for both local and addon functions — resolves via RPC at runtime."
+            },
+            {
+              "name": "refChannel",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              }
+            },
+            {
+              "name": "refCLI",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              }
+            },
+            {
+              "name": "refHTTP",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              }
+            },
+            {
+              "name": "Services",
+              "kind": "interface",
+              "origin": {
+                "via": "package",
+                "packageName": "@pikku/templates-function-addon"
+              }
+            },
+            {
+              "name": "Session",
+              "kind": "type",
+              "origin": {
+                "via": "generated"
+              }
+            },
+            {
+              "name": "SingletonServices",
+              "kind": "interface",
+              "origin": {
+                "via": "package",
+                "packageName": "@pikku/templates-function-addon"
+              }
+            },
+            {
+              "name": "WiredServices",
+              "kind": "type",
+              "origin": {
+                "via": "generated"
+              }
+            },
+            {
+              "name": "WiredSingletonServices",
+              "kind": "type",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "The services a wired function actually receives. The inspector records which services each wired `func`, `permissions` and `middleware` destructures and emits them as `RequiredSingletonServices`; intersecting that here makes those services **non-optional** at every call site. A service is optional only when nothing destructures it — in which case it is never created either. This is why an `if (!service)` guard inside a function body is always dead code.",
+              "docs": "The services a wired function actually receives. The inspector records which\nservices each wired `func`, `permissions` and `middleware` destructures and\nemits them as `RequiredSingletonServices`; intersecting that here makes those\nservices **non-optional** at every call site. A service is optional only when\nnothing destructures it — in which case it is never created either. This is\nwhy an `if (!service)` guard inside a function body is always dead code."
+            }
+          ]
+        },
+        {
+          "specifier": "#pikku/addon/function",
+          "name": "function",
+          "step": "create a function",
+          "summary": "The function definers every wiring eventually points at, and the types they are written against.",
+          "symbols": [
+            {
+              "name": "InferSchemaOutput",
+              "kind": "type",
+              "origin": {
+                "via": "package",
+                "packageName": "@pikku/templates-function-addon"
+              },
+              "summary": "Helper type to infer the output type from a Standard Schema",
+              "docs": "Helper type to infer the output type from a Standard Schema"
+            },
+            {
+              "name": "NodeConfig",
+              "kind": "type",
+              "origin": {
+                "via": "package",
+                "packageName": "@pikku/templates-function-addon"
+              },
+              "summary": "Inline node configuration for function definitions.",
+              "docs": "Inline node configuration for function definitions."
+            },
+            {
+              "name": "pikkuApprovalDescription",
+              "kind": "function",
+              "origin": {
+                "via": "package",
+                "packageName": "@pikku/templates-function-addon"
+              },
+              "summary": "Factory function for creating approval description functions with tree-shaking support.",
+              "docs": "Factory function for creating approval description functions with tree-shaking support."
+            },
+            {
+              "name": "PikkuApprovalDescription",
+              "kind": "type",
+              "origin": {
+                "via": "package",
+                "packageName": "@pikku/templates-function-addon"
+              },
+              "summary": "A function that generates a human-readable description of a pending approval action. Used by AI agents to show meaningful approval prompts instead of raw tool arguments.",
+              "docs": "A function that generates a human-readable description of a pending approval action.\nUsed by AI agents to show meaningful approval prompts instead of raw tool arguments."
+            },
+            {
+              "name": "pikkuFunc",
+              "kind": "function",
+              "origin": {
+                "via": "package",
+                "packageName": "@pikku/templates-function-addon"
+              },
+              "summary": "Creates a Pikku function that can be either session-aware or sessionless. This is the main function wrapper for creating API endpoints.",
+              "docs": "Creates a Pikku function that can be either session-aware or sessionless.\nThis is the main function wrapper for creating API endpoints.\n\nDefine the input and output with Zod schemas — the function's types are\ninferred from them, and the schemas double as runtime validation."
+            },
+            {
+              "name": "PikkuFunction",
+              "kind": "type",
+              "origin": {
+                "via": "package",
+                "packageName": "@pikku/templates-function-addon"
+              },
+              "summary": "A session-aware API function that requires user authentication. Use this for protected endpoints that need access to user session data.",
+              "docs": "A session-aware API function that requires user authentication.\nUse this for protected endpoints that need access to user session data."
+            },
+            {
+              "name": "PikkuFunctionConfig",
+              "kind": "type",
+              "origin": {
+                "via": "package",
+                "packageName": "@pikku/templates-function-addon"
+              },
+              "summary": "Configuration object for Pikku functions with optional middleware, permissions, tags, and documentation. This type wraps CorePikkuFunctionConfig with the user's custom types.",
+              "docs": "Configuration object for Pikku functions with optional middleware, permissions, tags, and documentation.\nThis type wraps CorePikkuFunctionConfig with the user's custom types."
+            },
+            {
+              "name": "PikkuFunctionSessionless",
+              "kind": "type",
+              "origin": {
+                "via": "package",
+                "packageName": "@pikku/templates-function-addon"
+              },
+              "summary": "A sessionless API function that doesn't require user authentication. Use this for public endpoints, health checks, or operations that don't need user context.",
+              "docs": "A sessionless API function that doesn't require user authentication.\nUse this for public endpoints, health checks, or operations that don't need user context."
+            },
+            {
+              "name": "pikkuListFunc",
+              "kind": "function",
+              "origin": {
+                "via": "package",
+                "packageName": "@pikku/templates-function-addon"
+              }
+            },
+            {
+              "name": "pikkuRemoteChannelFunc",
+              "kind": "function",
+              "origin": {
+                "via": "package",
+                "packageName": "@pikku/templates-function-addon"
+              },
+              "summary": "Declares a capability the connected client answers, reachable from any `wireChannel` function as `channel.remote(name, input)`.",
+              "docs": "Declares a capability the connected client answers, reachable from any\n`wireChannel` function as `channel.remote(name, input)`.\n\nThere is no `func`: this side owns the contract, the client owns the body.\nThe `description` is what a person is shown when asked to approve the call,\nso write it for them rather than for the caller."
+            },
+            {
+              "name": "pikkuSessionlessFunc",
+              "kind": "function",
+              "origin": {
+                "via": "package",
+                "packageName": "@pikku/templates-function-addon"
+              },
+              "summary": "Creates a sessionless Pikku function that doesn't require user authentication. Use this for public endpoints, webhooks, or background tasks.",
+              "docs": "Creates a sessionless Pikku function that doesn't require user authentication.\nUse this for public endpoints, webhooks, or background tasks.\n\nDefine the input and output with Zod schemas — the function's types are\ninferred from them, and the schemas double as runtime validation."
+            },
+            {
+              "name": "pikkuVoidFunc",
+              "kind": "function",
+              "origin": {
+                "via": "package",
+                "packageName": "@pikku/templates-function-addon"
+              },
+              "summary": "Creates a function that takes no input and returns no output. Useful for health checks, triggers, or cleanup operations.",
+              "docs": "Creates a function that takes no input and returns no output.\nUseful for health checks, triggers, or cleanup operations."
+            },
+            {
+              "name": "ref",
+              "kind": "function",
+              "origin": {
+                "via": "package",
+                "packageName": "@pikku/templates-function-addon"
+              },
+              "summary": "References a registered function by name for use in any wiring. Works for both local and addon functions — resolves via RPC at runtime.",
+              "docs": "References a registered function by name for use in any wiring.\nWorks for both local and addon functions — resolves via RPC at runtime."
+            },
+            {
+              "name": "refChannel",
+              "kind": "function",
+              "origin": {
+                "via": "package",
+                "packageName": "@pikku/templates-function-addon"
+              }
+            },
+            {
+              "name": "refCLI",
+              "kind": "function",
+              "origin": {
+                "via": "package",
+                "packageName": "@pikku/templates-function-addon"
+              }
+            },
+            {
+              "name": "refHTTP",
+              "kind": "function",
+              "origin": {
+                "via": "package",
+                "packageName": "@pikku/templates-function-addon"
+              }
+            },
+            {
+              "name": "Services",
+              "kind": "interface",
+              "origin": {
+                "via": "package",
+                "packageName": "@pikku/templates-function-addon"
+              }
+            },
+            {
+              "name": "Session",
+              "kind": "type",
+              "origin": {
+                "via": "package",
+                "packageName": "@pikku/templates-function-addon"
+              }
+            },
+            {
+              "name": "SingletonServices",
+              "kind": "interface",
+              "origin": {
+                "via": "package",
+                "packageName": "@pikku/templates-function-addon"
+              }
+            },
+            {
+              "name": "WiredServices",
+              "kind": "type",
+              "origin": {
+                "via": "package",
+                "packageName": "@pikku/templates-function-addon"
+              }
+            },
+            {
+              "name": "WiredSingletonServices",
+              "kind": "type",
+              "origin": {
+                "via": "package",
+                "packageName": "@pikku/templates-function-addon"
+              },
+              "summary": "The services a wired function actually receives. The inspector records which services each wired `func`, `permissions` and `middleware` destructures and emits them as `RequiredSingletonServices`; intersecting that here makes those services **non-optional** at every call site. A service is optional only when nothing destructures it — in which case it is never created either. This is why an `if (!service)` guard inside a function body is always dead code.",
+              "docs": "The services a wired function actually receives. The inspector records which\nservices each wired `func`, `permissions` and `middleware` destructures and\nemits them as `RequiredSingletonServices`; intersecting that here makes those\nservices **non-optional** at every call site. A service is optional only when\nnothing destructures it — in which case it is never created either. This is\nwhy an `if (!service)` guard inside a function body is always dead code."
+            }
+          ]
+        },
+        {
+          "specifier": "#pikku/addon/setup",
+          "name": "setup",
+          "step": "create a function",
+          "summary": "The three factories a project declares exactly once — its config, its singleton services and its per-wire services. An addon declares the same three in its own flavour, handed the logger, variables and secrets the host application already built. Everything else on this page is imported by features; these are imported by bootstrap and then left alone.",
+          "symbols": [
+            {
+              "name": "AddonBaseServices",
+              "kind": "type",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "Base services provided to addon package service factories. These are always available from the parent application.",
+              "docs": "Base services provided to addon package service factories.\nThese are always available from the parent application."
+            },
+            {
+              "name": "Config",
+              "kind": "interface",
+              "origin": {
+                "via": "package",
+                "packageName": "@pikku/templates-function-addon"
+              }
+            },
+            {
+              "name": "pikkuAddonConfig",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "Creates a Pikku config factory for addon packages. Unlike pikkuConfig, this receives AddonBaseServices (logger, variables, secrets) from the parent application, so addon packages can read variables/secrets during config creation.",
+              "docs": "Creates a Pikku config factory for addon packages.\nUnlike pikkuConfig, this receives AddonBaseServices (logger, variables, secrets)\nfrom the parent application, so addon packages can read variables/secrets during config creation."
+            },
+            {
+              "name": "pikkuAddonServices",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "Creates a Pikku singleton services factory for addon packages. Unlike pikkuServices, this expects the parent application to provide logger, variables, and secrets - no fallbacks needed.",
+              "docs": "Creates a Pikku singleton services factory for addon packages.\nUnlike pikkuServices, this expects the parent application to provide\nlogger, variables, and secrets - no fallbacks needed."
+            },
+            {
+              "name": "pikkuAddonWireServices",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "Creates a Pikku wire services factory for addon packages. Wire services are created per-request and have access to the HTTP request context.",
+              "docs": "Creates a Pikku wire services factory for addon packages.\nWire services are created per-request and have access to the HTTP request context."
+            },
+            {
+              "name": "pikkuConfig",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "Creates a Pikku config factory. Use this to define your application's configuration factory.",
+              "docs": "Creates a Pikku config factory.\nUse this to define your application's configuration factory."
+            },
+            {
+              "name": "pikkuServices",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "Creates a Pikku singleton services factory. Use this to define services that are created once and shared across all requests.",
+              "docs": "Creates a Pikku singleton services factory.\nUse this to define services that are created once and shared across all requests."
+            },
+            {
+              "name": "pikkuWireServices",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "Creates a Pikku wire services factory. Use this to define services that are created per-request/session.",
+              "docs": "Creates a Pikku wire services factory.\nUse this to define services that are created per-request/session."
+            }
+          ]
+        },
+        {
+          "specifier": "#pikku/addon/setup",
+          "name": "setup",
+          "step": "create a function",
+          "summary": "The three factories a project declares exactly once — its config, its singleton services and its per-wire services. An addon declares the same three in its own flavour, handed the logger, variables and secrets the host application already built. Everything else on this page is imported by features; these are imported by bootstrap and then left alone.",
+          "symbols": [
+            {
+              "name": "AddonBaseServices",
+              "kind": "type",
+              "origin": {
+                "via": "package",
+                "packageName": "@pikku/templates-function-addon"
+              },
+              "summary": "Base services provided to addon package service factories. These are always available from the parent application.",
+              "docs": "Base services provided to addon package service factories.\nThese are always available from the parent application."
+            },
+            {
+              "name": "Config",
+              "kind": "interface",
+              "origin": {
+                "via": "package",
+                "packageName": "@pikku/templates-function-addon"
+              }
+            },
+            {
+              "name": "pikkuAddonConfig",
+              "kind": "function",
+              "origin": {
+                "via": "package",
+                "packageName": "@pikku/templates-function-addon"
+              },
+              "summary": "Creates a Pikku config factory for addon packages. Unlike pikkuConfig, this receives AddonBaseServices (logger, variables, secrets) from the parent application, so addon packages can read variables/secrets during config creation.",
+              "docs": "Creates a Pikku config factory for addon packages.\nUnlike pikkuConfig, this receives AddonBaseServices (logger, variables, secrets)\nfrom the parent application, so addon packages can read variables/secrets during config creation."
+            },
+            {
+              "name": "pikkuAddonServices",
+              "kind": "function",
+              "origin": {
+                "via": "package",
+                "packageName": "@pikku/templates-function-addon"
+              },
+              "summary": "Creates a Pikku singleton services factory for addon packages. Unlike pikkuServices, this expects the parent application to provide logger, variables, and secrets - no fallbacks needed.",
+              "docs": "Creates a Pikku singleton services factory for addon packages.\nUnlike pikkuServices, this expects the parent application to provide\nlogger, variables, and secrets - no fallbacks needed."
+            },
+            {
+              "name": "pikkuAddonWireServices",
+              "kind": "function",
+              "origin": {
+                "via": "package",
+                "packageName": "@pikku/templates-function-addon"
+              },
+              "summary": "Creates a Pikku wire services factory for addon packages. Wire services are created per-request and have access to the HTTP request context.",
+              "docs": "Creates a Pikku wire services factory for addon packages.\nWire services are created per-request and have access to the HTTP request context."
+            },
+            {
+              "name": "pikkuConfig",
+              "kind": "function",
+              "origin": {
+                "via": "package",
+                "packageName": "@pikku/templates-function-addon"
+              },
+              "summary": "Creates a Pikku config factory. Use this to define your application's configuration factory.",
+              "docs": "Creates a Pikku config factory.\nUse this to define your application's configuration factory."
+            },
+            {
+              "name": "pikkuServices",
+              "kind": "function",
+              "origin": {
+                "via": "package",
+                "packageName": "@pikku/templates-function-addon"
+              },
+              "summary": "Creates a Pikku singleton services factory. Use this to define services that are created once and shared across all requests.",
+              "docs": "Creates a Pikku singleton services factory.\nUse this to define services that are created once and shared across all requests."
+            },
+            {
+              "name": "pikkuWireServices",
+              "kind": "function",
+              "origin": {
+                "via": "package",
+                "packageName": "@pikku/templates-function-addon"
+              },
+              "summary": "Creates a Pikku wire services factory. Use this to define services that are created per-request/session.",
+              "docs": "Creates a Pikku wire services factory.\nUse this to define services that are created per-request/session."
+            }
+          ]
+        },
+        {
+          "specifier": "#pikku/addon/error",
+          "name": "error",
+          "step": "enhance it",
+          "summary": "The errors your functions throw and the HTTP status each one maps to, so a thrown error is part of the contract rather than a stack trace.",
+          "symbols": [
+            {
+              "name": "addError",
+              "kind": "function",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "AIProviderAuthError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "AIProviderNotConfiguredError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "BadGatewayError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "BadRequestError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "ConflictError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "ErrorDetails",
+              "kind": "interface",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "ExpectationFailedError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "ForbiddenError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "GatewayTimeoutError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "GoneError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "HTTPVersionNotSupportedError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "InternalServerError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "InvalidMiddlewareWireError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "InvalidOriginError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "InvalidSessionError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "isExpectedError",
+              "kind": "function",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              },
+              "summary": "A `PikkuError`, or any error carrying `expected: true` — the marker that survives serialization across a workflow step boundary and rehydration as a plain `Error`. Callers log the message alone for these, the full stack for everything else.",
+              "docs": "A `PikkuError`, or any error carrying `expected: true` — the marker that\nsurvives serialization across a workflow step boundary and rehydration as a\nplain `Error`. Callers log the message alone for these, the full stack for\neverything else."
+            },
+            {
+              "name": "LengthRequiredError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "LocalEnvironmentOnlyError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "LockedError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "MaxComputeTimeReachedError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "MethodNotAllowedError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "MissingCredentialError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "MissingSchemaError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "MissingScopeError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "MissingServiceError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "MissingSessionError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "NotAcceptableError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "NotFoundError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "NotImplementedError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "PayloadTooLargeError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "PaymentRequiredError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "PikkuError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "PikkuMissingMetaError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "PreconditionFailedError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "ProxyAuthenticationRequiredError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "RangeNotSatisfiableError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "ReadonlySessionError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "RequestTimeoutError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "SerializedError",
+              "kind": "interface",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "ServiceUnavailableError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "SystemRoleImmutableError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              },
+              "summary": "An administrative operation targeted a role that is declared in code.",
+              "docs": "An administrative operation targeted a role that is declared in code.\n\nSystem roles ship with the product: the console may show and grant them, but\nrenaming, re-scoping or deleting one would let a UI action silently change\nwhat a declared persona means, and what every scenario written against that\nrole is actually testing."
+            },
+            {
+              "name": "SystemRoleShadowedError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              },
+              "summary": "A role was created with the name of a role declared in code.",
+              "docs": "A role was created with the name of a role declared in code.\n\nShadowing is refused rather than merged: two rows answering to one name make\n\"does Susan hold `buyer`?\" depend on which one the store happened to return."
+            },
+            {
+              "name": "TooManyRequestsError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "UnauthorizedError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "UnprocessableContentError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "UnsupportedMediaTypeError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "URITooLongError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "WeakKeyMaterialError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            }
+          ]
+        },
+        {
+          "specifier": "#pikku/addon/error",
+          "name": "error",
+          "step": "enhance it",
+          "summary": "The errors your functions throw and the HTTP status each one maps to, so a thrown error is part of the contract rather than a stack trace.",
+          "symbols": [
+            {
+              "name": "addError",
+              "kind": "function",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "AIProviderAuthError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "AIProviderNotConfiguredError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "BadGatewayError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "BadRequestError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "ConflictError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "ErrorDetails",
+              "kind": "interface",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "ExpectationFailedError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "ForbiddenError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "GatewayTimeoutError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "GoneError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "HTTPVersionNotSupportedError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "InternalServerError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "InvalidMiddlewareWireError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "InvalidOriginError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "InvalidSessionError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "isExpectedError",
+              "kind": "function",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              },
+              "summary": "A `PikkuError`, or any error carrying `expected: true` — the marker that survives serialization across a workflow step boundary and rehydration as a plain `Error`. Callers log the message alone for these, the full stack for everything else.",
+              "docs": "A `PikkuError`, or any error carrying `expected: true` — the marker that\nsurvives serialization across a workflow step boundary and rehydration as a\nplain `Error`. Callers log the message alone for these, the full stack for\neverything else."
+            },
+            {
+              "name": "LengthRequiredError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "LocalEnvironmentOnlyError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "LockedError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "MaxComputeTimeReachedError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "MethodNotAllowedError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "MissingCredentialError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "MissingSchemaError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "MissingScopeError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "MissingServiceError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "MissingSessionError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "NotAcceptableError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "NotFoundError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "NotImplementedError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "PayloadTooLargeError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "PaymentRequiredError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "PikkuError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "PikkuMissingMetaError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "PreconditionFailedError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "ProxyAuthenticationRequiredError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "RangeNotSatisfiableError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "ReadonlySessionError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "RequestTimeoutError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "SerializedError",
+              "kind": "interface",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "ServiceUnavailableError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "SystemRoleImmutableError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              },
+              "summary": "An administrative operation targeted a role that is declared in code.",
+              "docs": "An administrative operation targeted a role that is declared in code.\n\nSystem roles ship with the product: the console may show and grant them, but\nrenaming, re-scoping or deleting one would let a UI action silently change\nwhat a declared persona means, and what every scenario written against that\nrole is actually testing."
+            },
+            {
+              "name": "SystemRoleShadowedError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              },
+              "summary": "A role was created with the name of a role declared in code.",
+              "docs": "A role was created with the name of a role declared in code.\n\nShadowing is refused rather than merged: two rows answering to one name make\n\"does Susan hold `buyer`?\" depend on which one the store happened to return."
+            },
+            {
+              "name": "TooManyRequestsError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "UnauthorizedError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "UnprocessableContentError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "UnsupportedMediaTypeError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "URITooLongError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            },
+            {
+              "name": "WeakKeyMaterialError",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./errors"
+              }
+            }
+          ]
+        },
+        {
+          "specifier": "#pikku/addon/middleware",
+          "name": "middleware",
+          "step": "enhance it",
+          "summary": "Middleware is one concept regardless of what it ends up attached to, so it is one import: define it here, then register it globally, against a tag, or against an HTTP route or channel.",
+          "symbols": [
+            {
+              "name": "addChannelMiddleware",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              }
+            },
+            {
+              "name": "addGlobalMiddleware",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "Wire-agnostic global middleware. Runs at the top of every wiring's middleware chain — before wire-, tag-, and function-level entries.",
+              "docs": "Wire-agnostic global middleware. Runs at the top of every wiring's\nmiddleware chain — before wire-, tag-, and function-level entries.\n\nResolution order: global -> wire -> tag -> function."
+            },
+            {
+              "name": "addHTTPMiddleware",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "Registers HTTP middleware either globally or for a specific route pattern.",
+              "docs": "Registers HTTP middleware either globally or for a specific route pattern.\n\nWhen a string route pattern is provided along with middleware, the middleware\nis applied only to that route. Otherwise, if an array is provided, it is treated\nas global middleware (applied to all routes)."
+            },
+            {
+              "name": "addTagMiddleware",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "Tag-scoped middleware. Applies to any wiring that carries the matching tag.",
+              "docs": "Tag-scoped middleware. Applies to any wiring that carries the matching tag."
+            },
+            {
+              "name": "cors",
+              "kind": "function",
+              "origin": {
+                "via": "core",
+                "subpath": "./middleware"
+              },
+              "summary": "Sets CORS headers on every response and short-circuits OPTIONS preflight with a 204. `origin: true` reflects the request origin; an array reflects a matching origin and otherwise sends no `Access-Control-Allow-Origin` at all, so the browser reports \"origin not allowed\" rather than an origin mismatch against whichever entry happened to be first.",
+              "docs": "Sets CORS headers on every response and short-circuits OPTIONS preflight\nwith a 204. `origin: true` reflects the request origin; an array reflects a\nmatching origin and otherwise sends no `Access-Control-Allow-Origin` at all,\nso the browser reports \"origin not allowed\" rather than an origin mismatch\nagainst whichever entry happened to be first."
+            },
+            {
+              "name": "MiddlewarePriority",
+              "kind": "type",
+              "origin": {
+                "via": "core",
+                "subpath": "./middleware"
+              },
+              "summary": "Execution order: `highest` runs first (outermost in the onion), `lowest` runs last, closest to the function.",
+              "docs": "Execution order: `highest` runs first (outermost in the onion), `lowest`\nruns last, closest to the function."
+            },
+            {
+              "name": "pikkuAgentMiddleware",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              }
+            },
+            {
+              "name": "pikkuChannelMiddleware",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              }
+            },
+            {
+              "name": "PikkuChannelMiddleware",
+              "kind": "type",
+              "origin": {
+                "via": "generated"
+              }
+            },
+            {
+              "name": "pikkuChannelMiddlewareFactory",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              }
+            },
+            {
+              "name": "pikkuMiddleware",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "Factory function for creating middleware with tree-shaking support. Supports both direct function and configuration object syntax.",
+              "docs": "Factory function for creating middleware with tree-shaking support.\nSupports both direct function and configuration object syntax."
+            },
+            {
+              "name": "PikkuMiddleware",
+              "kind": "type",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "Type-safe middleware definition that can access your application's services and session. Use this to define reusable middleware that can be applied to multiple wirings.",
+              "docs": "Type-safe middleware definition that can access your application's services and session.\nUse this to define reusable middleware that can be applied to multiple wirings."
+            },
+            {
+              "name": "pikkuMiddlewareFactory",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "Factory function for creating middleware factories Use this when your middleware needs configuration/input parameters",
+              "docs": "Factory function for creating middleware factories\nUse this when your middleware needs configuration/input parameters"
+            }
+          ]
+        },
+        {
+          "specifier": "#pikku/addon/middleware",
+          "name": "middleware",
+          "step": "enhance it",
+          "summary": "Middleware is one concept regardless of what it ends up attached to, so it is one import: define it here, then register it globally, against a tag, or against an HTTP route or channel.",
+          "symbols": [
+            {
+              "name": "addChannelMiddleware",
+              "kind": "function",
+              "origin": {
+                "via": "package",
+                "packageName": "@pikku/templates-function-addon"
+              }
+            },
+            {
+              "name": "addGlobalMiddleware",
+              "kind": "function",
+              "origin": {
+                "via": "package",
+                "packageName": "@pikku/templates-function-addon"
+              },
+              "summary": "Wire-agnostic global middleware. Runs at the top of every wiring's middleware chain — before wire-, tag-, and function-level entries.",
+              "docs": "Wire-agnostic global middleware. Runs at the top of every wiring's\nmiddleware chain — before wire-, tag-, and function-level entries.\n\nResolution order: global -> wire -> tag -> function."
+            },
+            {
+              "name": "addHTTPMiddleware",
+              "kind": "function",
+              "origin": {
+                "via": "package",
+                "packageName": "@pikku/templates-function-addon"
+              },
+              "summary": "Registers HTTP middleware either globally or for a specific route pattern.",
+              "docs": "Registers HTTP middleware either globally or for a specific route pattern.\n\nWhen a string route pattern is provided along with middleware, the middleware\nis applied only to that route. Otherwise, if an array is provided, it is treated\nas global middleware (applied to all routes)."
+            },
+            {
+              "name": "addTagMiddleware",
+              "kind": "function",
+              "origin": {
+                "via": "package",
+                "packageName": "@pikku/templates-function-addon"
+              },
+              "summary": "Tag-scoped middleware. Applies to any wiring that carries the matching tag.",
+              "docs": "Tag-scoped middleware. Applies to any wiring that carries the matching tag."
+            },
+            {
+              "name": "cors",
+              "kind": "function",
+              "origin": {
+                "via": "core",
+                "subpath": "./middleware"
+              },
+              "summary": "Sets CORS headers on every response and short-circuits OPTIONS preflight with a 204. `origin: true` reflects the request origin; an array reflects a matching origin and otherwise sends no `Access-Control-Allow-Origin` at all, so the browser reports \"origin not allowed\" rather than an origin mismatch against whichever entry happened to be first.",
+              "docs": "Sets CORS headers on every response and short-circuits OPTIONS preflight\nwith a 204. `origin: true` reflects the request origin; an array reflects a\nmatching origin and otherwise sends no `Access-Control-Allow-Origin` at all,\nso the browser reports \"origin not allowed\" rather than an origin mismatch\nagainst whichever entry happened to be first."
+            },
+            {
+              "name": "MiddlewarePriority",
+              "kind": "type",
+              "origin": {
+                "via": "core",
+                "subpath": "./middleware"
+              },
+              "summary": "Execution order: `highest` runs first (outermost in the onion), `lowest` runs last, closest to the function.",
+              "docs": "Execution order: `highest` runs first (outermost in the onion), `lowest`\nruns last, closest to the function."
+            },
+            {
+              "name": "pikkuAgentMiddleware",
+              "kind": "function",
+              "origin": {
+                "via": "package",
+                "packageName": "@pikku/templates-function-addon"
+              }
+            },
+            {
+              "name": "pikkuChannelMiddleware",
+              "kind": "function",
+              "origin": {
+                "via": "package",
+                "packageName": "@pikku/templates-function-addon"
+              }
+            },
+            {
+              "name": "PikkuChannelMiddleware",
+              "kind": "type",
+              "origin": {
+                "via": "package",
+                "packageName": "@pikku/templates-function-addon"
+              }
+            },
+            {
+              "name": "pikkuChannelMiddlewareFactory",
+              "kind": "function",
+              "origin": {
+                "via": "package",
+                "packageName": "@pikku/templates-function-addon"
+              }
+            },
+            {
+              "name": "pikkuMiddleware",
+              "kind": "function",
+              "origin": {
+                "via": "package",
+                "packageName": "@pikku/templates-function-addon"
+              },
+              "summary": "Factory function for creating middleware with tree-shaking support. Supports both direct function and configuration object syntax.",
+              "docs": "Factory function for creating middleware with tree-shaking support.\nSupports both direct function and configuration object syntax."
+            },
+            {
+              "name": "PikkuMiddleware",
+              "kind": "type",
+              "origin": {
+                "via": "package",
+                "packageName": "@pikku/templates-function-addon"
+              },
+              "summary": "Type-safe middleware definition that can access your application's services and session. Use this to define reusable middleware that can be applied to multiple wirings.",
+              "docs": "Type-safe middleware definition that can access your application's services and session.\nUse this to define reusable middleware that can be applied to multiple wirings."
+            },
+            {
+              "name": "pikkuMiddlewareFactory",
+              "kind": "function",
+              "origin": {
+                "via": "package",
+                "packageName": "@pikku/templates-function-addon"
+              },
+              "summary": "Factory function for creating middleware factories Use this when your middleware needs configuration/input parameters",
+              "docs": "Factory function for creating middleware factories\nUse this when your middleware needs configuration/input parameters"
+            }
+          ]
+        },
+        {
+          "specifier": "#pikku/addon/secrets",
+          "name": "secrets",
+          "step": "enhance it",
+          "summary": "Secrets a function can use without ever holding, declared here and resolved by the secrets service at runtime.",
+          "symbols": [
+            {
+              "name": "CredentialsMap",
+              "kind": "type",
+              "origin": {
+                "via": "generated"
+              }
+            },
+            {
+              "name": "defineSecret",
+              "kind": "function",
+              "origin": {
+                "via": "core",
+                "subpath": "./secret"
+              }
+            },
+            {
+              "name": "TypedSecretService",
+              "kind": "class",
+              "origin": {
+                "via": "generated"
+              }
+            }
+          ]
+        },
+        {
+          "specifier": "#pikku/addon/secrets",
+          "name": "secrets",
+          "step": "enhance it",
+          "summary": "Secrets a function can use without ever holding, declared here and resolved by the secrets service at runtime.",
+          "symbols": [
+            {
+              "name": "CredentialsMap",
+              "kind": "type",
+              "origin": {
+                "via": "package",
+                "packageName": "@pikku/templates-function-addon"
+              }
+            },
+            {
+              "name": "defineSecret",
+              "kind": "function",
+              "origin": {
+                "via": "core",
+                "subpath": "./secret"
+              }
+            },
+            {
+              "name": "TypedSecretService",
+              "kind": "class",
+              "origin": {
+                "via": "package",
+                "packageName": "@pikku/templates-function-addon"
+              }
+            }
+          ]
+        },
+        {
+          "specifier": "#pikku/addon/variables",
+          "name": "variables",
+          "step": "enhance it",
+          "summary": "Configuration a function reads through the variables service, declared once so a deployment can be checked for what it is missing.",
+          "symbols": [
+            {
+              "name": "defineVariable",
+              "kind": "function",
+              "origin": {
+                "via": "core",
+                "subpath": "./variable"
+              }
+            },
+            {
+              "name": "TypedVariablesService",
+              "kind": "class",
+              "origin": {
+                "via": "generated"
+              }
+            },
+            {
+              "name": "VariablesMap",
+              "kind": "interface",
+              "origin": {
+                "via": "generated"
+              }
+            }
+          ]
+        },
+        {
+          "specifier": "#pikku/addon/variables",
+          "name": "variables",
+          "step": "enhance it",
+          "summary": "Configuration a function reads through the variables service, declared once so a deployment can be checked for what it is missing.",
+          "symbols": [
+            {
+              "name": "defineVariable",
+              "kind": "function",
+              "origin": {
+                "via": "core",
+                "subpath": "./variable"
+              }
+            },
+            {
+              "name": "TypedVariablesService",
+              "kind": "class",
+              "origin": {
+                "via": "package",
+                "packageName": "@pikku/templates-function-addon"
+              }
+            },
+            {
+              "name": "VariablesMap",
+              "kind": "interface",
+              "origin": {
+                "via": "package",
+                "packageName": "@pikku/templates-function-addon"
+              }
+            }
+          ]
+        },
+        {
+          "specifier": "#pikku/addon/channel",
+          "name": "channel",
+          "step": "wire it up",
+          "summary": "Wires a function to a websocket channel, its message routes and its pub/sub topics.",
+          "symbols": [
+            {
+              "name": "defineChannelRoutes",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "Type-safe helper for defining channel message routes that can be composed. Returns the routes record as-is for use with wireChannel's onMessageWiring.",
+              "docs": "Type-safe helper for defining channel message routes that can be composed.\nReturns the routes record as-is for use with wireChannel's onMessageWiring."
+            },
+            {
+              "name": "pikkuChannelConnectionFunc",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "Creates a function that handles WebSocket channel connections. Called when a client connects to a channel.",
+              "docs": "Creates a function that handles WebSocket channel connections.\nCalled when a client connects to a channel."
+            },
+            {
+              "name": "pikkuChannelDisconnectionFunc",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "Creates a function that handles WebSocket channel disconnections. Called when a client disconnects from a channel.",
+              "docs": "Creates a function that handles WebSocket channel disconnections.\nCalled when a client disconnects from a channel."
+            },
+            {
+              "name": "pikkuChannelFunc",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "Creates a function that handles WebSocket channel messages. Called when a message is received on a channel.",
+              "docs": "Creates a function that handles WebSocket channel messages.\nCalled when a message is received on a channel.\n\nSupports two patterns:\n1. Generic types: `pikkuChannelFunc<Input, Output>({ func: ... })`\n2. Zod schemas: `pikkuChannelFunc({ input: z.object(...), func: ... })`"
+            }
+          ]
+        },
+        {
+          "specifier": "#pikku/addon/channel",
+          "name": "channel",
+          "step": "wire it up",
+          "summary": "Wires a function to a websocket channel, its message routes and its pub/sub topics.",
+          "symbols": [
+            {
+              "name": "defineChannelRoutes",
+              "kind": "function",
+              "origin": {
+                "via": "package",
+                "packageName": "@pikku/templates-function-addon"
+              },
+              "summary": "Type-safe helper for defining channel message routes that can be composed. Returns the routes record as-is for use with wireChannel's onMessageWiring.",
+              "docs": "Type-safe helper for defining channel message routes that can be composed.\nReturns the routes record as-is for use with wireChannel's onMessageWiring."
+            },
+            {
+              "name": "pikkuChannelConnectionFunc",
+              "kind": "function",
+              "origin": {
+                "via": "package",
+                "packageName": "@pikku/templates-function-addon"
+              },
+              "summary": "Creates a function that handles WebSocket channel connections. Called when a client connects to a channel.",
+              "docs": "Creates a function that handles WebSocket channel connections.\nCalled when a client connects to a channel."
+            },
+            {
+              "name": "pikkuChannelDisconnectionFunc",
+              "kind": "function",
+              "origin": {
+                "via": "package",
+                "packageName": "@pikku/templates-function-addon"
+              },
+              "summary": "Creates a function that handles WebSocket channel disconnections. Called when a client disconnects from a channel.",
+              "docs": "Creates a function that handles WebSocket channel disconnections.\nCalled when a client disconnects from a channel."
+            },
+            {
+              "name": "pikkuChannelFunc",
+              "kind": "function",
+              "origin": {
+                "via": "package",
+                "packageName": "@pikku/templates-function-addon"
+              },
+              "summary": "Creates a function that handles WebSocket channel messages. Called when a message is received on a channel.",
+              "docs": "Creates a function that handles WebSocket channel messages.\nCalled when a message is received on a channel.\n\nSupports two patterns:\n1. Generic types: `pikkuChannelFunc<Input, Output>({ func: ... })`\n2. Zod schemas: `pikkuChannelFunc({ input: z.object(...), func: ... })`"
+            }
+          ]
+        },
+        {
+          "specifier": "#pikku/addon/http",
+          "name": "http",
+          "step": "wire it up",
+          "summary": "Wires a function to an HTTP route, with the path parameters checked against the function input.",
+          "symbols": [
+            {
+              "name": "defineHTTPRoutes",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "Type-safe helper for defining route contracts that can be composed.",
+              "docs": "Type-safe helper for defining route contracts that can be composed."
+            }
+          ]
+        },
+        {
+          "specifier": "#pikku/addon/http",
+          "name": "http",
+          "step": "wire it up",
+          "summary": "Wires a function to an HTTP route, with the path parameters checked against the function input.",
+          "symbols": [
+            {
+              "name": "defineHTTPRoutes",
+              "kind": "function",
+              "origin": {
+                "via": "package",
+                "packageName": "@pikku/templates-function-addon"
+              },
+              "summary": "Type-safe helper for defining route contracts that can be composed.",
+              "docs": "Type-safe helper for defining route contracts that can be composed."
+            }
+          ]
+        },
+        {
+          "specifier": "#pikku/addon/mcp",
+          "name": "mcp",
+          "step": "wire it up",
+          "summary": "Wires a function as an MCP tool, resource or prompt for a model to call.",
+          "symbols": [
+            {
+              "name": "pikkuMCPPromptFunc",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "Creates a function for handling MCP prompt requests. These functions generate prompt templates for AI models.",
+              "docs": "Creates a function for handling MCP prompt requests.\nThese functions generate prompt templates for AI models.\n\nSupports two patterns:\n1. Generic types: `pikkuMCPPromptFunc<Input>({ func: ... })`\n2. Zod schemas: `pikkuMCPPromptFunc({ input: z.object(...), func: ... })`"
+            },
+            {
+              "name": "pikkuMCPResourceFunc",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "Creates a function for handling MCP resource requests. These functions provide data that AI models can access.",
+              "docs": "Creates a function for handling MCP resource requests.\nThese functions provide data that AI models can access.\n\nSupports two patterns:\n1. Generic types: `pikkuMCPResourceFunc<Input>({ func: ... })`\n2. Zod schemas: `pikkuMCPResourceFunc({ input: z.object(...), func: ... })`"
+            },
+            {
+              "name": "pikkuMCPToolFunc",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "Creates a function for handling MCP tool invocations. These functions perform actions that AI models can request.",
+              "docs": "Creates a function for handling MCP tool invocations.\nThese functions perform actions that AI models can request.\n\nSupports two patterns:\n1. Generic types: `pikkuMCPToolFunc<Input>({ func: ... })`\n2. Zod schemas: `pikkuMCPToolFunc({ input: z.object(...), func: ... })`"
+            }
+          ]
+        },
+        {
+          "specifier": "#pikku/addon/mcp",
+          "name": "mcp",
+          "step": "wire it up",
+          "summary": "Wires a function as an MCP tool, resource or prompt for a model to call.",
+          "symbols": [
+            {
+              "name": "pikkuMCPPromptFunc",
+              "kind": "function",
+              "origin": {
+                "via": "package",
+                "packageName": "@pikku/templates-function-addon"
+              },
+              "summary": "Creates a function for handling MCP prompt requests. These functions generate prompt templates for AI models.",
+              "docs": "Creates a function for handling MCP prompt requests.\nThese functions generate prompt templates for AI models.\n\nSupports two patterns:\n1. Generic types: `pikkuMCPPromptFunc<Input>({ func: ... })`\n2. Zod schemas: `pikkuMCPPromptFunc({ input: z.object(...), func: ... })`"
+            },
+            {
+              "name": "pikkuMCPResourceFunc",
+              "kind": "function",
+              "origin": {
+                "via": "package",
+                "packageName": "@pikku/templates-function-addon"
+              },
+              "summary": "Creates a function for handling MCP resource requests. These functions provide data that AI models can access.",
+              "docs": "Creates a function for handling MCP resource requests.\nThese functions provide data that AI models can access.\n\nSupports two patterns:\n1. Generic types: `pikkuMCPResourceFunc<Input>({ func: ... })`\n2. Zod schemas: `pikkuMCPResourceFunc({ input: z.object(...), func: ... })`"
+            },
+            {
+              "name": "pikkuMCPToolFunc",
+              "kind": "function",
+              "origin": {
+                "via": "package",
+                "packageName": "@pikku/templates-function-addon"
+              },
+              "summary": "Creates a function for handling MCP tool invocations. These functions perform actions that AI models can request.",
+              "docs": "Creates a function for handling MCP tool invocations.\nThese functions perform actions that AI models can request.\n\nSupports two patterns:\n1. Generic types: `pikkuMCPToolFunc<Input>({ func: ... })`\n2. Zod schemas: `pikkuMCPToolFunc({ input: z.object(...), func: ... })`"
+            }
+          ]
+        },
+        {
+          "specifier": "#pikku/addon/trigger",
+          "name": "trigger",
+          "step": "wire it up",
+          "summary": "Wires a function to an event a source emits, rather than to a caller that asks for it.",
+          "symbols": [
+            {
+              "name": "pikkuTriggerFunc",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "Creates a trigger function configuration. Use this to define trigger functions that set up subscriptions.",
+              "docs": "Creates a trigger function configuration.\nUse this to define trigger functions that set up subscriptions."
+            }
+          ]
+        },
+        {
+          "specifier": "#pikku/addon/trigger",
+          "name": "trigger",
+          "step": "wire it up",
+          "summary": "Wires a function to an event a source emits, rather than to a caller that asks for it.",
+          "symbols": [
+            {
+              "name": "pikkuTriggerFunc",
+              "kind": "function",
+              "origin": {
+                "via": "package",
+                "packageName": "@pikku/templates-function-addon"
+              },
+              "summary": "Creates a trigger function configuration. Use this to define trigger functions that set up subscriptions.",
+              "docs": "Creates a trigger function configuration.\nUse this to define trigger functions that set up subscriptions."
+            }
+          ]
+        },
+        {
+          "specifier": "#pikku/addon/auth",
+          "name": "auth",
+          "step": "guard it",
+          "summary": "Who may call a function, and what the call is made with: permissions that see the request, auth gates that run before it, and the credentials a function borrows rather than holds.",
+          "symbols": [
+            {
+              "name": "addGlobalPermission",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "Wire-agnostic global permissions. Runs at the top of every wiring's permission resolution — before wire-, tag-, and function-level entries.",
+              "docs": "Wire-agnostic global permissions. Runs at the top of every wiring's\npermission resolution — before wire-, tag-, and function-level entries.\n\nResolution order: global -> wire -> tag -> function."
+            },
+            {
+              "name": "defineCredential",
+              "kind": "function",
+              "origin": {
+                "via": "core",
+                "subpath": "./credential"
+              },
+              "summary": "Declares a credential. The body is a no-op that tree-shakes away — the CLI reads the call by AST, so the declaration must be a top-level literal. `type: 'wire'` is per-user, `type: 'singleton'` is platform-wide.",
+              "docs": "Declares a credential. The body is a no-op that tree-shakes away — the CLI\nreads the call by AST, so the declaration must be a top-level literal.\n`type: 'wire'` is per-user, `type: 'singleton'` is platform-wide."
+            },
+            {
+              "name": "pikkuAuth",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "Factory function for creating auth-only permissions with tree-shaking support. Auth permissions only receive services and session (no request data), making them evaluable before request data is available.",
+              "docs": "Factory function for creating auth-only permissions with tree-shaking support.\nAuth permissions only receive services and session (no request data),\nmaking them evaluable before request data is available."
+            },
+            {
+              "name": "pikkuPermission",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "Factory function for creating permissions with tree-shaking support. Supports both direct function and configuration object syntax.",
+              "docs": "Factory function for creating permissions with tree-shaking support.\nSupports both direct function and configuration object syntax."
+            },
+            {
+              "name": "PikkuPermission",
+              "kind": "type",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "Type-safe API permission definition that integrates with your application's session type. Use this to define authorization logic for your API endpoints.",
+              "docs": "Type-safe API permission definition that integrates with your application's session type.\nUse this to define authorization logic for your API endpoints."
+            },
+            {
+              "name": "pikkuPermissionFactory",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "Factory function for creating permission factories Use this when your permission needs configuration/input parameters",
+              "docs": "Factory function for creating permission factories\nUse this when your permission needs configuration/input parameters"
+            }
+          ]
+        },
+        {
+          "specifier": "#pikku/addon/auth",
+          "name": "auth",
+          "step": "guard it",
+          "summary": "Who may call a function, and what the call is made with: permissions that see the request, auth gates that run before it, and the credentials a function borrows rather than holds.",
+          "symbols": [
+            {
+              "name": "addGlobalPermission",
+              "kind": "function",
+              "origin": {
+                "via": "package",
+                "packageName": "@pikku/templates-function-addon"
+              },
+              "summary": "Wire-agnostic global permissions. Runs at the top of every wiring's permission resolution — before wire-, tag-, and function-level entries.",
+              "docs": "Wire-agnostic global permissions. Runs at the top of every wiring's\npermission resolution — before wire-, tag-, and function-level entries.\n\nResolution order: global -> wire -> tag -> function."
+            },
+            {
+              "name": "defineCredential",
+              "kind": "function",
+              "origin": {
+                "via": "core",
+                "subpath": "./credential"
+              },
+              "summary": "Declares a credential. The body is a no-op that tree-shakes away — the CLI reads the call by AST, so the declaration must be a top-level literal. `type: 'wire'` is per-user, `type: 'singleton'` is platform-wide.",
+              "docs": "Declares a credential. The body is a no-op that tree-shakes away — the CLI\nreads the call by AST, so the declaration must be a top-level literal.\n`type: 'wire'` is per-user, `type: 'singleton'` is platform-wide."
+            },
+            {
+              "name": "pikkuAuth",
+              "kind": "function",
+              "origin": {
+                "via": "package",
+                "packageName": "@pikku/templates-function-addon"
+              },
+              "summary": "Factory function for creating auth-only permissions with tree-shaking support. Auth permissions only receive services and session (no request data), making them evaluable before request data is available.",
+              "docs": "Factory function for creating auth-only permissions with tree-shaking support.\nAuth permissions only receive services and session (no request data),\nmaking them evaluable before request data is available."
+            },
+            {
+              "name": "pikkuPermission",
+              "kind": "function",
+              "origin": {
+                "via": "package",
+                "packageName": "@pikku/templates-function-addon"
+              },
+              "summary": "Factory function for creating permissions with tree-shaking support. Supports both direct function and configuration object syntax.",
+              "docs": "Factory function for creating permissions with tree-shaking support.\nSupports both direct function and configuration object syntax."
+            },
+            {
+              "name": "PikkuPermission",
+              "kind": "type",
+              "origin": {
+                "via": "package",
+                "packageName": "@pikku/templates-function-addon"
+              },
+              "summary": "Type-safe API permission definition that integrates with your application's session type. Use this to define authorization logic for your API endpoints.",
+              "docs": "Type-safe API permission definition that integrates with your application's session type.\nUse this to define authorization logic for your API endpoints."
+            },
+            {
+              "name": "pikkuPermissionFactory",
+              "kind": "function",
+              "origin": {
+                "via": "package",
+                "packageName": "@pikku/templates-function-addon"
+              },
+              "summary": "Factory function for creating permission factories Use this when your permission needs configuration/input parameters",
+              "docs": "Factory function for creating permission factories\nUse this when your permission needs configuration/input parameters"
+            }
+          ]
+        },
+        {
+          "specifier": "#pikku/addon/scopes",
+          "name": "scopes",
+          "step": "guard it",
+          "summary": "The scopes a caller can hold and the roles that grant them, gating a call outside the permission pool.",
+          "symbols": [
+            {
+              "name": "defineScope",
+              "kind": "function",
+              "origin": {
+                "via": "core",
+                "subpath": "./scope"
+              },
+              "summary": "Declares scopes. The body is a no-op that tree-shakes away — the CLI reads the call by AST and generates a `ScopeId` union, so a function referencing an undeclared scope fails the build.",
+              "docs": "Declares scopes. The body is a no-op that tree-shakes away — the CLI reads\nthe call by AST and generates a `ScopeId` union, so a function referencing an\nundeclared scope fails the build.\n\nScopes are keyed by segment at every level: a scope is named by its key, and\nits value describes it. Every node is grantable — the declaration below\nyields `admin`, `admin:invoices`, `admin:invoices:create`,\n`admin:invoices:void` and `billing`."
+            },
+            {
+              "name": "defineSystemRole",
+              "kind": "function",
+              "origin": {
+                "via": "core",
+                "subpath": "./role"
+              },
+              "summary": "No-op function for declaring system roles. This exists purely for TypeScript type checking and will be tree-shaken. The CLI extracts metadata via AST parsing and generates a `SystemRoleName` union, so a persona naming an undeclared role fails the build.",
+              "docs": "No-op function for declaring system roles.\nThis exists purely for TypeScript type checking and will be tree-shaken.\nThe CLI extracts metadata via AST parsing and generates a `SystemRoleName`\nunion, so a persona naming an undeclared role fails the build.\n\nA system role is a role that ships with the product: the console may grant\nit, but cannot rename, re-scope or delete it. Roles an admin composes in the\nconsole are unaffected and are not declared here.\n\nRemoval is deliberately not destructive. Deleting a declaration leaves the\nrow in the store, marked undeclared and inert, until `pikku roles prune` —\nthe same additive contract `defineScope` has, and for the same reason: a\nmid-deploy revocation is not something a code edit should be able to cause."
+            }
+          ]
+        },
+        {
+          "specifier": "#pikku/addon/scopes",
+          "name": "scopes",
+          "step": "guard it",
+          "summary": "The scopes a caller can hold and the roles that grant them, gating a call outside the permission pool.",
+          "symbols": [
+            {
+              "name": "defineScope",
+              "kind": "function",
+              "origin": {
+                "via": "core",
+                "subpath": "./scope"
+              },
+              "summary": "Declares scopes. The body is a no-op that tree-shakes away — the CLI reads the call by AST and generates a `ScopeId` union, so a function referencing an undeclared scope fails the build.",
+              "docs": "Declares scopes. The body is a no-op that tree-shakes away — the CLI reads\nthe call by AST and generates a `ScopeId` union, so a function referencing an\nundeclared scope fails the build.\n\nScopes are keyed by segment at every level: a scope is named by its key, and\nits value describes it. Every node is grantable — the declaration below\nyields `admin`, `admin:invoices`, `admin:invoices:create`,\n`admin:invoices:void` and `billing`."
+            },
+            {
+              "name": "defineSystemRole",
+              "kind": "function",
+              "origin": {
+                "via": "core",
+                "subpath": "./role"
+              },
+              "summary": "No-op function for declaring system roles. This exists purely for TypeScript type checking and will be tree-shaken. The CLI extracts metadata via AST parsing and generates a `SystemRoleName` union, so a persona naming an undeclared role fails the build.",
+              "docs": "No-op function for declaring system roles.\nThis exists purely for TypeScript type checking and will be tree-shaken.\nThe CLI extracts metadata via AST parsing and generates a `SystemRoleName`\nunion, so a persona naming an undeclared role fails the build.\n\nA system role is a role that ships with the product: the console may grant\nit, but cannot rename, re-scope or delete it. Roles an admin composes in the\nconsole are unaffected and are not declared here.\n\nRemoval is deliberately not destructive. Deleting a declaration leaves the\nrow in the store, marked undeclared and inert, until `pikku roles prune` —\nthe same additive contract `defineScope` has, and for the same reason: a\nmid-deploy revocation is not something a code edit should be able to cause."
+            }
+          ]
+        },
+        {
+          "specifier": "#pikku/addon/agent",
+          "name": "agent",
+          "step": "orchestrate it",
+          "summary": "Defines an AI agent, the tools it may call and the scorers that judge what it did.",
+          "symbols": [
+            {
+              "name": "agent",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              }
+            },
+            {
+              "name": "agentApprove",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              }
+            },
+            {
+              "name": "agentResume",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              }
+            },
+            {
+              "name": "agentStream",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              }
+            },
+            {
+              "name": "pikkuAgent",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              }
+            },
+            {
+              "name": "pikkuAgentJudge",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              }
+            },
+            {
+              "name": "pikkuAgentScorer",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              }
+            }
+          ]
+        },
+        {
+          "specifier": "#pikku/addon/agent",
+          "name": "agent",
+          "step": "orchestrate it",
+          "summary": "Defines an AI agent, the tools it may call and the scorers that judge what it did.",
+          "symbols": [
+            {
+              "name": "agent",
+              "kind": "function",
+              "origin": {
+                "via": "package",
+                "packageName": "@pikku/templates-function-addon"
+              }
+            },
+            {
+              "name": "agentApprove",
+              "kind": "function",
+              "origin": {
+                "via": "package",
+                "packageName": "@pikku/templates-function-addon"
+              }
+            },
+            {
+              "name": "agentResume",
+              "kind": "function",
+              "origin": {
+                "via": "package",
+                "packageName": "@pikku/templates-function-addon"
+              }
+            },
+            {
+              "name": "agentStream",
+              "kind": "function",
+              "origin": {
+                "via": "package",
+                "packageName": "@pikku/templates-function-addon"
+              }
+            },
+            {
+              "name": "pikkuAgent",
+              "kind": "function",
+              "origin": {
+                "via": "package",
+                "packageName": "@pikku/templates-function-addon"
+              }
+            },
+            {
+              "name": "pikkuAgentJudge",
+              "kind": "function",
+              "origin": {
+                "via": "package",
+                "packageName": "@pikku/templates-function-addon"
+              }
+            },
+            {
+              "name": "pikkuAgentScorer",
+              "kind": "function",
+              "origin": {
+                "via": "package",
+                "packageName": "@pikku/templates-function-addon"
+              }
+            }
+          ]
+        },
+        {
+          "specifier": "#pikku/addon/workflow",
+          "name": "workflow",
+          "step": "orchestrate it",
+          "summary": "Composes functions into a durable workflow whose steps survive a restart and retry on their own.",
+          "symbols": [
+            {
+              "name": "PikkuFunctionWorkflow",
+              "kind": "type",
+              "origin": {
+                "via": "generated"
+              }
+            },
+            {
+              "name": "pikkuWorkflowComplexFunc",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              }
+            },
+            {
+              "name": "pikkuWorkflowFunc",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              }
+            },
+            {
+              "name": "pikkuWorkflowGraph",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              }
+            },
+            {
+              "name": "TypedWorkflow",
+              "kind": "interface",
+              "origin": {
+                "via": "generated"
+              }
+            },
+            {
+              "name": "WorkflowCancelledException",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./workflow"
+              }
+            }
+          ]
+        },
+        {
+          "specifier": "#pikku/addon/workflow",
+          "name": "workflow",
+          "step": "orchestrate it",
+          "summary": "Composes functions into a durable workflow whose steps survive a restart and retry on their own.",
+          "symbols": [
+            {
+              "name": "PikkuFunctionWorkflow",
+              "kind": "type",
+              "origin": {
+                "via": "package",
+                "packageName": "@pikku/templates-function-addon"
+              }
+            },
+            {
+              "name": "pikkuWorkflowComplexFunc",
+              "kind": "function",
+              "origin": {
+                "via": "package",
+                "packageName": "@pikku/templates-function-addon"
+              }
+            },
+            {
+              "name": "pikkuWorkflowFunc",
+              "kind": "function",
+              "origin": {
+                "via": "package",
+                "packageName": "@pikku/templates-function-addon"
+              }
+            },
+            {
+              "name": "pikkuWorkflowGraph",
+              "kind": "function",
+              "origin": {
+                "via": "package",
+                "packageName": "@pikku/templates-function-addon"
+              }
+            },
+            {
+              "name": "TypedWorkflow",
+              "kind": "interface",
+              "origin": {
+                "via": "package",
+                "packageName": "@pikku/templates-function-addon"
+              }
+            },
+            {
+              "name": "WorkflowCancelledException",
+              "kind": "class",
+              "origin": {
+                "via": "core",
+                "subpath": "./workflow"
+              }
+            }
+          ]
+        },
+        {
+          "specifier": "#pikku/addon/scenarios",
+          "name": "scenarios",
+          "step": "test it",
+          "summary": "Drives features and scenarios against a real running server, in the vocabulary a user would use.",
+          "symbols": [
+            {
+              "name": "createCookieJar",
+              "kind": "function",
+              "origin": {
+                "via": "core",
+                "subpath": "./workflow"
+              }
+            },
+            {
+              "name": "createScenarioRunner",
+              "kind": "function",
+              "origin": {
+                "via": "core",
+                "subpath": "./workflow"
+              },
+              "summary": "A workflow service with the scenario capability attached — the two lines `pikku scenario run` needs, in one call so no caller has to remember that the capability is installed rather than inherited.",
+              "docs": "A workflow service with the scenario capability attached — the two lines\n`pikku scenario run` needs, in one call so no caller has to remember that the\ncapability is installed rather than inherited.\n\nThe in-memory service is the right engine because a scenario run is a single\nexternal process driving a deployed app over its real transport: there is\nnothing to persist and no second worker to resume it."
+            },
+            {
+              "name": "pikkuAddonScenarioStep",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "A step in which a third-party system acts — \"Given Stripe's webhook arrives\", \"When Mailgun bounces it\".",
+              "docs": "A step in which a third-party system acts — \"Given Stripe's webhook arrives\",\n\"When Mailgun bounces it\".\n\n`addon` names the addon that wraps that service, the same name its\n`wireAddon` declares. These steps *are* the mock its consumers currently\nhand-write: shipped by the addon author, maintained with the addon, and the\nsame artifact that appears in the prose.\n\nNote that arranging and asserting are different — \"Stripe's webhook arrives\"\nstubs, \"Then Stripe was charged\" asserts, and only the first is a stub.\n\nLocal-test-only, and never in a virtual user's catalogue: one that could\ninvoke this would forge its own payment success."
+            },
+            {
+              "name": "PikkuBrowserWire",
+              "kind": "interface",
+              "origin": {
+                "via": "core",
+                "subpath": "./workflow"
+              },
+              "summary": "Structural browser handle, present only when the runner provisioned a browser for this step (a `browser` binding on the step config).",
+              "docs": "Structural browser handle, present only when the runner provisioned a\nbrowser for this step (a `browser` binding on the step config).\n\n`@pikku/core` deliberately never imports playwright — it must stay\ndependency-free for edge runtimes. `@pikku/playwright` augments this\ninterface via `declare module`, so `wire.browser.page` is a fully typed\nPlaywright `Page` in a project that installs it."
+            },
+            {
+              "name": "pikkuFeature",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "A feature: an ordered group of scenarios, mirroring gherkin's Feature ↔ Scenario structure. Scenarios are referenced by imported identifier, so a renamed or deleted scenario is a compile error rather than a silent skip.",
+              "docs": "A feature: an ordered group of scenarios, mirroring gherkin's Feature ↔\nScenario structure. Scenarios are referenced by imported identifier, so a\nrenamed or deleted scenario is a compile error rather than a silent skip.\n\nA scenario does not have to belong to a feature — a void-input scenario\nstill runs standalone.\n\n```ts\nexport const credentialFeature = pikkuFeature({\n  name: 'Credential API',\n  tags: ['credential'],\n  before: startsMockOAuthServer,\n  after: stopsMockOAuthServer,\n  scenarios: [\n    credentialLazyLoadScenario,\n    ...['stripe', 'google'].map((name) => ({\n      scenario: credentialRoundTripScenario,\n      data: { name },\n    })),\n  ],\n})\n```"
+            },
+            {
+              "name": "PikkuFeatureEntry",
+              "kind": "type",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "One entry in a feature's `scenarios` list, validated against itself: a bare scenario, or a scenario paired with the input to run it with. The paired form is gherkin's `Examples:` written as an ordinary loop.",
+              "docs": "One entry in a feature's `scenarios` list, validated against itself: a bare\nscenario, or a scenario paired with the input to run it with. The paired form\nis gherkin's `Examples:` written as an ordinary loop."
+            },
+            {
+              "name": "PikkuFunctionScenario",
+              "kind": "type",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "`Ctx` types `scenario.context`, defaulting to the body's own output. A hook returns void but shares the scenario's context, so it passes that scenario's output here instead.",
+              "docs": "`Ctx` types `scenario.context`, defaulting to the body's own output. A hook\nreturns void but shares the scenario's context, so it passes that scenario's\noutput here instead."
+            },
+            {
+              "name": "PikkuFunctionScenarioStep",
+              "kind": "type",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "One surface's implementation of a step.",
+              "docs": "One surface's implementation of a step.\n\nEach binding is typed independently, so a browser binding gets a non-optional\n`wire.browser` and a cli binding a non-optional `wire.cli` without either\nleaking into the other."
+            },
+            {
+              "name": "pikkuPlatformScenarioStep",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "A step in which the app acts on itself — \"Given the platform has expired the trial\".",
+              "docs": "A step in which the app acts on itself — \"Given the platform has expired the\ntrial\".\n\nThe grammatical subject of that sentence is not a user of your app; it **is**\nyour app, which is why it is its own declaration rather than a persona with an\nasterisk. A persona is a person.\n\nLocal-test-only, and never in a virtual user's catalogue: a virtual user that\ncould expire its own trial is manufacturing the outcome it exists to discover."
+            },
+            {
+              "name": "pikkuScenario",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "A scenario: a complex workflow that drives the app the way users do. Steps run as actors over the REAL transport — `scenario.do(step, rpc, data, { actor: actors.yasser })` — so flows double as e2e tests and staged/production health checks (no state reset; scope what you create).",
+              "docs": "A scenario: a complex workflow that drives the app the way users do.\nSteps run as actors over the REAL transport — `scenario.do(step, rpc,\ndata, { actor: actors.yasser })` — so flows double as e2e tests and\nstaged/production health checks (no state reset; scope what you create)."
+            },
+            {
+              "name": "pikkuScenarioHook",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "Declares a scenario hook. Returns the function verbatim — a hook is never registered, so this exists purely to give an inline hook a call site to be contextually typed from, the way every other pikku primitive is.",
+              "docs": "Declares a scenario hook. Returns the function verbatim — a hook is never\nregistered, so this exists purely to give an inline hook a call site to be\ncontextually typed from, the way every other pikku primitive is."
+            },
+            {
+              "name": "PikkuScenarioHook",
+              "kind": "type",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "A scenario lifecycle hook: the scenario's own `(services, data, wire)` signature with its result discarded. `OutputSchema` types `scenario.context` while the return type stays `void`.",
+              "docs": "A scenario lifecycle hook: the scenario's own `(services, data, wire)`\nsignature with its result discarded. `OutputSchema` types\n`scenario.context` while the return type stays `void`."
+            },
+            {
+              "name": "PikkuScenarioRef",
+              "kind": "type",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "A scenario as a feature references it. Any `pikkuScenario` export is assignable; `In` is recovered from it so the paired form's `data` is checked against that scenario's own input.",
+              "docs": "A scenario as a feature references it. Any `pikkuScenario` export is\nassignable; `In` is recovered from it so the paired form's `data` is\nchecked against that scenario's own input."
+            },
+            {
+              "name": "pikkuScenarioStep",
+              "kind": "function",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "A named, reusable scenario step, declaring one implementation per surface an actor can drive it through.",
+              "docs": "A named, reusable scenario step, declaring one implementation per surface an\nactor can drive it through.\n\nThe step's identity is what the actor is trying to do; which surface carries\nit out is a binding. That is what lets one ladder run through a real browser,\nover the websocket, or entirely server-side — and what makes \"how much of this\nflow can a human actually reach\" a number rather than a guess.\n\nSteps are deliberately NOT registered as RPCs: a browser-driving step must\nnever be network-callable."
+            },
+            {
+              "name": "pollUntil",
+              "kind": "function",
+              "origin": {
+                "via": "core",
+                "subpath": "./workflow"
+              }
+            },
+            {
+              "name": "postScenarioJson",
+              "kind": "function",
+              "origin": {
+                "via": "core",
+                "subpath": "./services"
+              },
+              "summary": "POST JSON somewhere and report what came back, without throwing on a 4xx/5xx.",
+              "docs": "POST JSON somewhere and report what came back, without throwing on a 4xx/5xx.\n\nEvery scenario that reaches past a persona was writing this by hand — the same\n`content-type`, the same `JSON.stringify`, the same drain — and the copies had\ndrifted: some returned `res.json()`, which loses the status and throws\noutright when the target answers an empty body or an HTML error page. A\nrefusal is the expected outcome of a permissions scenario, so it has to\nsurvive as data."
+            },
+            {
+              "name": "readScenarioHttpResponse",
+              "kind": "function",
+              "origin": {
+                "via": "core",
+                "subpath": "./services"
+              },
+              "summary": "Drain a response into the shape a step can carry: the parsed body (an empty one counting as no body at all) alongside the text it was parsed from.",
+              "docs": "Drain a response into the shape a step can carry: the parsed body (an empty\none counting as no body at all) alongside the text it was parsed from.\n\n`invokeRaw` returns this, and a step that has to reach past a persona — a\nroute with no RPC, an identity no persona can hold — reaches for this rather\nthan writing the same record by hand."
+            },
+            {
+              "name": "requireScenarioEnv",
+              "kind": "function",
+              "origin": {
+                "via": "core",
+                "subpath": "./workflow"
+              }
+            },
+            {
+              "name": "ScenarioHttpResponse",
+              "kind": "interface",
+              "origin": {
+                "via": "core",
+                "subpath": "./services"
+              },
+              "summary": "What the transport answered, for a step that treats the status as data.",
+              "docs": "What the transport answered, for a step that treats the status as data.\n\nAn HTTP response with its body already drained: the stream can only be read\nonce, and a step's return value crosses into the run record, so the response\nobject itself cannot travel. This is the shape every caller ends up with."
+            },
+            {
+              "name": "ScenarioSurface",
+              "kind": "type",
+              "origin": {
+                "via": "core",
+                "subpath": "./workflow"
+              },
+              "summary": "How an actor drives the system for one step.",
+              "docs": "How an actor drives the system for one step.\n\nA step declares one implementation per surface it supports, and the runner\npicks between them — so the same ladder can run through a real browser, over\nthe websocket, or entirely server-side.\n\n`default` is the floor: it is what every other surface falls back to, so it\ncan never itself fall back."
+            },
+            {
+              "name": "TestIdSelector",
+              "kind": "interface",
+              "origin": {
+                "via": "core",
+                "subpath": "./workflow"
+              },
+              "summary": "How a browser step names an element.",
+              "docs": "How a browser step names an element.\n\nA `data-testid` on its own is rarely enough to name exactly one: `where`\nmatches the element's own data attributes (so a step asserts a status\nwithout reading translated copy back to the app), `prefix` matches a family\nof ids, `containing` picks the match holding a piece of text, and `within`\nscopes the lookup to one row or section.\n\nDeclared here so a step's input type is structural; the driver\n(`@pikku/playwright`) is what resolves it against a real page."
+            },
+            {
+              "name": "TypedPersonas",
+              "kind": "type",
+              "origin": {
+                "via": "generated"
+              }
+            },
+            {
+              "name": "TypedScenario",
+              "kind": "type",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "`Out` types `scenario.context`.",
+              "docs": "`Out` types `scenario.context`."
+            },
+            {
+              "name": "TypedScenarioSteps",
+              "kind": "interface",
+              "origin": {
+                "via": "generated"
+              },
+              "summary": "The typed half of a scenario wire: `given`/`when`/`then`, narrowed to the names declared by `pikkuScenarioStep` in this project. `given` and `when` differ only in the prose the reporter renders; `then` additionally makes the step's bindings witnesses rather than alternatives.",
+              "docs": "The typed half of a scenario wire: `given`/`when`/`then`, narrowed to the\nnames declared by `pikkuScenarioStep` in this project. `given` and `when`\ndiffer only in the prose the reporter renders; `then` additionally makes the\nstep's bindings witnesses rather than alternatives."
+            }
+          ]
+        },
+        {
+          "specifier": "#pikku/addon/scenarios",
+          "name": "scenarios",
+          "step": "test it",
+          "summary": "Drives features and scenarios against a real running server, in the vocabulary a user would use.",
+          "symbols": [
+            {
+              "name": "createCookieJar",
+              "kind": "function",
+              "origin": {
+                "via": "core",
+                "subpath": "./workflow"
+              }
+            },
+            {
+              "name": "createScenarioRunner",
+              "kind": "function",
+              "origin": {
+                "via": "core",
+                "subpath": "./workflow"
+              },
+              "summary": "A workflow service with the scenario capability attached — the two lines `pikku scenario run` needs, in one call so no caller has to remember that the capability is installed rather than inherited.",
+              "docs": "A workflow service with the scenario capability attached — the two lines\n`pikku scenario run` needs, in one call so no caller has to remember that the\ncapability is installed rather than inherited.\n\nThe in-memory service is the right engine because a scenario run is a single\nexternal process driving a deployed app over its real transport: there is\nnothing to persist and no second worker to resume it."
+            },
+            {
+              "name": "pikkuAddonScenarioStep",
+              "kind": "function",
+              "origin": {
+                "via": "package",
+                "packageName": "@pikku/templates-function-addon"
+              },
+              "summary": "A step in which a third-party system acts — \"Given Stripe's webhook arrives\", \"When Mailgun bounces it\".",
+              "docs": "A step in which a third-party system acts — \"Given Stripe's webhook arrives\",\n\"When Mailgun bounces it\".\n\n`addon` names the addon that wraps that service, the same name its\n`wireAddon` declares. These steps *are* the mock its consumers currently\nhand-write: shipped by the addon author, maintained with the addon, and the\nsame artifact that appears in the prose.\n\nNote that arranging and asserting are different — \"Stripe's webhook arrives\"\nstubs, \"Then Stripe was charged\" asserts, and only the first is a stub.\n\nLocal-test-only, and never in a virtual user's catalogue: one that could\ninvoke this would forge its own payment success."
+            },
+            {
+              "name": "PikkuBrowserWire",
+              "kind": "interface",
+              "origin": {
+                "via": "core",
+                "subpath": "./workflow"
+              },
+              "summary": "Structural browser handle, present only when the runner provisioned a browser for this step (a `browser` binding on the step config).",
+              "docs": "Structural browser handle, present only when the runner provisioned a\nbrowser for this step (a `browser` binding on the step config).\n\n`@pikku/core` deliberately never imports playwright — it must stay\ndependency-free for edge runtimes. `@pikku/playwright` augments this\ninterface via `declare module`, so `wire.browser.page` is a fully typed\nPlaywright `Page` in a project that installs it."
+            },
+            {
+              "name": "pikkuFeature",
+              "kind": "function",
+              "origin": {
+                "via": "package",
+                "packageName": "@pikku/templates-function-addon"
+              },
+              "summary": "A feature: an ordered group of scenarios, mirroring gherkin's Feature ↔ Scenario structure. Scenarios are referenced by imported identifier, so a renamed or deleted scenario is a compile error rather than a silent skip.",
+              "docs": "A feature: an ordered group of scenarios, mirroring gherkin's Feature ↔\nScenario structure. Scenarios are referenced by imported identifier, so a\nrenamed or deleted scenario is a compile error rather than a silent skip.\n\nA scenario does not have to belong to a feature — a void-input scenario\nstill runs standalone.\n\n```ts\nexport const credentialFeature = pikkuFeature({\n  name: 'Credential API',\n  tags: ['credential'],\n  before: startsMockOAuthServer,\n  after: stopsMockOAuthServer,\n  scenarios: [\n    credentialLazyLoadScenario,\n    ...['stripe', 'google'].map((name) => ({\n      scenario: credentialRoundTripScenario,\n      data: { name },\n    })),\n  ],\n})\n```"
+            },
+            {
+              "name": "PikkuFeatureEntry",
+              "kind": "type",
+              "origin": {
+                "via": "package",
+                "packageName": "@pikku/templates-function-addon"
+              },
+              "summary": "One entry in a feature's `scenarios` list, validated against itself: a bare scenario, or a scenario paired with the input to run it with. The paired form is gherkin's `Examples:` written as an ordinary loop.",
+              "docs": "One entry in a feature's `scenarios` list, validated against itself: a bare\nscenario, or a scenario paired with the input to run it with. The paired form\nis gherkin's `Examples:` written as an ordinary loop."
+            },
+            {
+              "name": "PikkuFunctionScenario",
+              "kind": "type",
+              "origin": {
+                "via": "package",
+                "packageName": "@pikku/templates-function-addon"
+              },
+              "summary": "`Ctx` types `scenario.context`, defaulting to the body's own output. A hook returns void but shares the scenario's context, so it passes that scenario's output here instead.",
+              "docs": "`Ctx` types `scenario.context`, defaulting to the body's own output. A hook\nreturns void but shares the scenario's context, so it passes that scenario's\noutput here instead."
+            },
+            {
+              "name": "PikkuFunctionScenarioStep",
+              "kind": "type",
+              "origin": {
+                "via": "package",
+                "packageName": "@pikku/templates-function-addon"
+              },
+              "summary": "One surface's implementation of a step.",
+              "docs": "One surface's implementation of a step.\n\nEach binding is typed independently, so a browser binding gets a non-optional\n`wire.browser` and a cli binding a non-optional `wire.cli` without either\nleaking into the other."
+            },
+            {
+              "name": "pikkuPlatformScenarioStep",
+              "kind": "function",
+              "origin": {
+                "via": "package",
+                "packageName": "@pikku/templates-function-addon"
+              },
+              "summary": "A step in which the app acts on itself — \"Given the platform has expired the trial\".",
+              "docs": "A step in which the app acts on itself — \"Given the platform has expired the\ntrial\".\n\nThe grammatical subject of that sentence is not a user of your app; it **is**\nyour app, which is why it is its own declaration rather than a persona with an\nasterisk. A persona is a person.\n\nLocal-test-only, and never in a virtual user's catalogue: a virtual user that\ncould expire its own trial is manufacturing the outcome it exists to discover."
+            },
+            {
+              "name": "pikkuScenario",
+              "kind": "function",
+              "origin": {
+                "via": "package",
+                "packageName": "@pikku/templates-function-addon"
+              },
+              "summary": "A scenario: a complex workflow that drives the app the way users do. Steps run as actors over the REAL transport — `scenario.do(step, rpc, data, { actor: actors.yasser })` — so flows double as e2e tests and staged/production health checks (no state reset; scope what you create).",
+              "docs": "A scenario: a complex workflow that drives the app the way users do.\nSteps run as actors over the REAL transport — `scenario.do(step, rpc,\ndata, { actor: actors.yasser })` — so flows double as e2e tests and\nstaged/production health checks (no state reset; scope what you create)."
+            },
+            {
+              "name": "pikkuScenarioHook",
+              "kind": "function",
+              "origin": {
+                "via": "package",
+                "packageName": "@pikku/templates-function-addon"
+              },
+              "summary": "Declares a scenario hook. Returns the function verbatim — a hook is never registered, so this exists purely to give an inline hook a call site to be contextually typed from, the way every other pikku primitive is.",
+              "docs": "Declares a scenario hook. Returns the function verbatim — a hook is never\nregistered, so this exists purely to give an inline hook a call site to be\ncontextually typed from, the way every other pikku primitive is."
+            },
+            {
+              "name": "PikkuScenarioHook",
+              "kind": "type",
+              "origin": {
+                "via": "package",
+                "packageName": "@pikku/templates-function-addon"
+              },
+              "summary": "A scenario lifecycle hook: the scenario's own `(services, data, wire)` signature with its result discarded. `OutputSchema` types `scenario.context` while the return type stays `void`.",
+              "docs": "A scenario lifecycle hook: the scenario's own `(services, data, wire)`\nsignature with its result discarded. `OutputSchema` types\n`scenario.context` while the return type stays `void`."
+            },
+            {
+              "name": "PikkuScenarioRef",
+              "kind": "type",
+              "origin": {
+                "via": "package",
+                "packageName": "@pikku/templates-function-addon"
+              },
+              "summary": "A scenario as a feature references it. Any `pikkuScenario` export is assignable; `In` is recovered from it so the paired form's `data` is checked against that scenario's own input.",
+              "docs": "A scenario as a feature references it. Any `pikkuScenario` export is\nassignable; `In` is recovered from it so the paired form's `data` is\nchecked against that scenario's own input."
+            },
+            {
+              "name": "pikkuScenarioStep",
+              "kind": "function",
+              "origin": {
+                "via": "package",
+                "packageName": "@pikku/templates-function-addon"
+              },
+              "summary": "A named, reusable scenario step, declaring one implementation per surface an actor can drive it through.",
+              "docs": "A named, reusable scenario step, declaring one implementation per surface an\nactor can drive it through.\n\nThe step's identity is what the actor is trying to do; which surface carries\nit out is a binding. That is what lets one ladder run through a real browser,\nover the websocket, or entirely server-side — and what makes \"how much of this\nflow can a human actually reach\" a number rather than a guess.\n\nSteps are deliberately NOT registered as RPCs: a browser-driving step must\nnever be network-callable."
+            },
+            {
+              "name": "pollUntil",
+              "kind": "function",
+              "origin": {
+                "via": "core",
+                "subpath": "./workflow"
+              }
+            },
+            {
+              "name": "postScenarioJson",
+              "kind": "function",
+              "origin": {
+                "via": "core",
+                "subpath": "./services"
+              },
+              "summary": "POST JSON somewhere and report what came back, without throwing on a 4xx/5xx.",
+              "docs": "POST JSON somewhere and report what came back, without throwing on a 4xx/5xx.\n\nEvery scenario that reaches past a persona was writing this by hand — the same\n`content-type`, the same `JSON.stringify`, the same drain — and the copies had\ndrifted: some returned `res.json()`, which loses the status and throws\noutright when the target answers an empty body or an HTML error page. A\nrefusal is the expected outcome of a permissions scenario, so it has to\nsurvive as data."
+            },
+            {
+              "name": "readScenarioHttpResponse",
+              "kind": "function",
+              "origin": {
+                "via": "core",
+                "subpath": "./services"
+              },
+              "summary": "Drain a response into the shape a step can carry: the parsed body (an empty one counting as no body at all) alongside the text it was parsed from.",
+              "docs": "Drain a response into the shape a step can carry: the parsed body (an empty\none counting as no body at all) alongside the text it was parsed from.\n\n`invokeRaw` returns this, and a step that has to reach past a persona — a\nroute with no RPC, an identity no persona can hold — reaches for this rather\nthan writing the same record by hand."
+            },
+            {
+              "name": "requireScenarioEnv",
+              "kind": "function",
+              "origin": {
+                "via": "core",
+                "subpath": "./workflow"
+              }
+            },
+            {
+              "name": "ScenarioHttpResponse",
+              "kind": "interface",
+              "origin": {
+                "via": "core",
+                "subpath": "./services"
+              },
+              "summary": "What the transport answered, for a step that treats the status as data.",
+              "docs": "What the transport answered, for a step that treats the status as data.\n\nAn HTTP response with its body already drained: the stream can only be read\nonce, and a step's return value crosses into the run record, so the response\nobject itself cannot travel. This is the shape every caller ends up with."
+            },
+            {
+              "name": "ScenarioSurface",
+              "kind": "type",
+              "origin": {
+                "via": "core",
+                "subpath": "./workflow"
+              },
+              "summary": "How an actor drives the system for one step.",
+              "docs": "How an actor drives the system for one step.\n\nA step declares one implementation per surface it supports, and the runner\npicks between them — so the same ladder can run through a real browser, over\nthe websocket, or entirely server-side.\n\n`default` is the floor: it is what every other surface falls back to, so it\ncan never itself fall back."
+            },
+            {
+              "name": "TestIdSelector",
+              "kind": "interface",
+              "origin": {
+                "via": "core",
+                "subpath": "./workflow"
+              },
+              "summary": "How a browser step names an element.",
+              "docs": "How a browser step names an element.\n\nA `data-testid` on its own is rarely enough to name exactly one: `where`\nmatches the element's own data attributes (so a step asserts a status\nwithout reading translated copy back to the app), `prefix` matches a family\nof ids, `containing` picks the match holding a piece of text, and `within`\nscopes the lookup to one row or section.\n\nDeclared here so a step's input type is structural; the driver\n(`@pikku/playwright`) is what resolves it against a real page."
+            },
+            {
+              "name": "TypedPersonas",
+              "kind": "type",
+              "origin": {
+                "via": "package",
+                "packageName": "@pikku/templates-function-addon"
+              }
+            },
+            {
+              "name": "TypedScenario",
+              "kind": "type",
+              "origin": {
+                "via": "package",
+                "packageName": "@pikku/templates-function-addon"
+              },
+              "summary": "`Out` types `scenario.context`.",
+              "docs": "`Out` types `scenario.context`."
+            },
+            {
+              "name": "TypedScenarioSteps",
+              "kind": "interface",
+              "origin": {
+                "via": "package",
+                "packageName": "@pikku/templates-function-addon"
+              },
+              "summary": "The typed half of a scenario wire: `given`/`when`/`then`, narrowed to the names declared by `pikkuScenarioStep` in this project. `given` and `when` differ only in the prose the reporter renders; `then` additionally makes the step's bindings witnesses rather than alternatives.",
+              "docs": "The typed half of a scenario wire: `given`/`when`/`then`, narrowed to the\nnames declared by `pikkuScenarioStep` in this project. `given` and `when`\ndiffer only in the prose the reporter renders; `then` additionally makes the\nstep's bindings witnesses rather than alternatives."
+            }
+          ]
+        }
+      ]
+    }
+  ]
+}