stitchkit 0.110.4 → 0.110.6

package/llms/server.2.txt

@@ -18,6 +18,137 @@ Also read:
 # Guide: HTTP server  (docs/guide/server.md)  (continued)
 ==============================================================================
 
+## Raw routes
+
+Some routes cannot be a clean JSON contract — an OAuth redirect, a webhook with
+signature verification, static files, the Socket.IO endpoint. `rawRoutes` are
+plain `Request → Response` handlers, matched by the same router (shared CORS and
+`onRequest`) but with no schema parsing and no `beforeHandle` gate — a raw route
+authorises itself.
+
+```ts
+createServer({
+  services,
+  rawRoutes: [
+    {
+      method: 'GET',
+      path: '/health',
+      handler: () => Response.json({ status: 'ok' }),
+    },
+    {
+      method: 'POST',
+      path: '/webhooks/:provider',
+      serviceName: 'webhooks',
+      action: 'receive',
+      handler: (req, ctx) => handleWebhook(ctx.params.provider, req),
+    },
+  ],
+})
+```
+
+`serviceName` and `action` are optional observability identity. Declare
+`serviceName` when audit, logging, sampling or another cross-cutting policy
+groups this raw route with a service; add `action` when the policy needs an
+operation within that service. Stitchkit never derives either from `path`.
+`action` without `serviceName`, and empty identity strings, fail at startup.
+
+A path may be exact, carry `:param` segments, or end in `/*filePath` for a prefix
+wildcard — and the two combine: `/app/:slug/*filePath` matches `/app/x/a/b` with
+`ctx.params.slug === 'x'` and the remainder in `ctx.params.filePath` (a SPA
+deep-link fallback). List more specific routes before the wildcard — the first
+match wins. `staticRoute()` builds a raw route that serves a directory.
+
+At startup Stitchkit rejects exact duplicates, equivalent parameter shapes
+(`/users/:id` vs `/users/:userId`) and any later raw route completely hidden by
+an earlier raw route. Partial overlap stays legal, including the recommended
+specific-before-wildcard order. `GET` and `HEAD` remain independent because that
+is how the actual raw matcher dispatches them. Raw-vs-contract overlap remains a
+startup diagnostic naming the bypassed contract identity and scope.
+
+### Raw-route helpers
+
+A raw route gives up the contract pipeline, so three things get re-implemented in
+every one. `stitchkit/server` ships them — conveniences, not a second pipeline
+(no auth, no schema gate beyond `parseBody`):
+
+```ts
+import { respondJson, errorResponse, parseBody, badRequest } from 'stitchkit/server'
+
+handler: async (req) => {
+  try {
+    const body = await parseBody(req, MySchema)      // typed value, or null (no throw)
+    if (!body) throw badRequest('invalid body')      // helpers THROW an AppError
+    return respondJson(await myService(body))         // JSON; 204 when null/undefined
+  } catch (err) {
+    return errorResponse(err)                         // same envelope as a contract route
+  }
+}
+```
+
+The error helpers (`badRequest`, `notFound`, …) **throw** an `AppError`, so raise
+them inside the `try` and let `errorResponse(err)` render it — that runs any
+thrown value through the framework's `normalizeError`, so a raw route returns the
+**identical** `{ error: { code, message, … } }` shape (and `x-request-id`) a
+contract route does.
+
+### Serving files & Range requests
+
+`staticRoute` is basic on purpose — it reads the whole file into memory and has
+no `Range` or conditional support; put a CDN in front, or use it for small web
+assets. To serve **media** (video / audio / large downloads) that a browser must
+seek and cache, use **`serveFile`** (Bun) — it streams the requested byte range
+and speaks the conditional-request half of RFC 7233 / 9110:
+
+```ts
+import { defineContract } from 'stitchkit/contract'
+import { implement, serveFile } from 'stitchkit/server'
+import { z } from 'zod'
+
+const MediaParams = z.object({ id: z.string() })
+const media = defineContract({ prefix: 'media' }, {
+  download: {
+    method: 'GET', path: '/:id', desc: 'Download media',
+    params: MediaParams, rawResponse: true, contentType: 'video/mp4',
+  },
+  inspect: {
+    method: 'HEAD', path: '/:id', desc: 'Inspect media',
+    params: MediaParams, rawResponse: true, contentType: 'video/mp4',
+  },
+})
+
+const mediaService = implement(media, {
+  download: ({ req, params }) =>
+    serveFile(req, { path: pathForId(params.id), filename: 'clip.mp4' }),
+  inspect: ({ req, params }) =>
+    serveFile(req, { path: pathForId(params.id), filename: 'clip.mp4' }),
+})
+```
+
+GET and HEAD are separate operations deliberately: declaring GET never creates
+a hidden HEAD alias. Both travel through the normal contract router, params,
+lifecycle/RBAC and request logging. A HEAD handler may inspect the raw query via
+`ctx.req.url`, but cannot declare a request input schema or body.
+
+`serveFile` returns `206` (range, with `Content-Range` + `Content-Length`), `200`
+(full), `416` (unsatisfiable, `Content-Range: bytes */size`), `304`
+(`If-None-Match` / `If-Modified-Since`), `404` (missing) or `405` (non GET/HEAD).
+It always sets `Accept-Ranges: bytes`, a weak `ETag` and `Last-Modified` (so
+`If-Range` keeps a changing file from being stitched from stale + fresh bytes),
+and `nosniff`. `Content-Type` is auto-detected from the path — override it, or
+pass `disposition` / `cacheControl` / `etag: false`, via the options.
+
+Cross-origin, the browser lets JavaScript read only the CORS-safelisted response
+headers. stitchkit therefore exposes the download-relevant ones by default
+(`Content-Disposition`, `Content-Range`, `ETag`, …) — without that a `fetch`-based
+download cannot recover the file's name. Override with `cors.exposeHeaders`
+(extend `DEFAULT_CORS_EXPOSE_HEADERS` rather than replacing it), or pass `[]` to
+emit none.
+
+`serveFile` takes an explicit `path` and trusts it — **the caller owns
+containment**. For a URL-derived path use `staticRoute` (which enforces it) or
+`isWithinDir` first. The byte-range parser is exported on its own as
+`parseByteRange(header, size)` for direct use and testing. → ADR 0023.
+
 ## Server primitives
 
 `stitchkit/server` also exports the primitives most APIs need. Each is a small,

package/llms/server.5.txt

@@ -65,6 +65,7 @@ Also re-exports the error helpers from `stitchkit/contract`.
 | `parseBody` | function | parse + Zod-validate a JSON body → `data` or `null` (no throw) |
 | `HandlerConfig` | _type_ | config for `createHandler`, including optional `maxJsonBodyBytes`; bound to `BunServer` on this entrypoint |
 | `BunServerConfig` | _type_ | config for `createServer` (Bun); `unix` listens on a unix domain socket (mutually exclusive with `port`/`hostname`) — [details](../guide/server.md#local-daemon-over-a-unix-socket) |
+| `ProxyOriginConfig` | _type_ | explicit real-peer trust for Bun `createServer({ proxyOrigin })`; strict external-scheme normalization before composition — [details](../guide/server.md#external-origin-behind-a-trusted-proxy) |
 | `UnixListenConfig` | _type_ | unix listener — a socket path, or `{ path, mode }` to tighten the file mode after listen |
 | `BunServerHandle` | _type_ | managed Bun handle (`url`, `port`, `runtime`, `status`, `shutdown`) |
 | `ManagedServerHandle` | _type_ | shared lifecycle shape generic over the runtime escape hatch |

package/llms/server.txt

@@ -268,6 +268,7 @@ server. See [Testing & deployment](./testing-and-deployment.md).
 | `logging` | `true` for built-in request logs, or a `LoggingConfig` (see below) |
 | `traceId` | override per-request trace-id resolution — may return `undefined` to fall back |
 | `wrapFetch` | compose wrappers around the finished handler (request context, audit) |
+| `proxyOrigin` | Bun TCP ingress policy: `{ trustedPeer(socketIp) }` restores the external scheme before all composition; independent of client-IP `trustProxy` |
 | `socket` | full Stitchkit Socket.IO handle; route, default WebSocket handler and shutdown are mounted once |
 | `websocket` | custom Bun WebSocket handler; with `socket`, this is the explicit composed handler |
 | `development` / `bun` | passthrough to `Bun.serve` |
@@ -276,6 +277,60 @@ Native Bun `routes` are intentionally not accepted: Bun matches them before
 `fetch`, so they could bypass shutdown admission. Use `rawRoutes`; they retain
 the Fetch `Request → Response` model and participate in lifecycle tracking.
 
+### External origin behind a trusted proxy
+
+An HTTPS ingress often forwards plain HTTP to Bun. `trustProxy` trusts client-IP
+headers only; it does not change `Request.url`. Opt into the separate URL policy:
+
+```ts
+import { createServer, isLoopbackAddress } from 'stitchkit/server'
+
+const server = createServer({
+  hostname: '127.0.0.1',
+  port: 3000,
+  proxyOrigin: { trustedPeer: isLoopbackAddress },
+  services,
+})
+```
+
+The predicate receives the **real TCP peer**, never `X-Forwarded-For` or
+`X-Real-IP`. Match only the ingress you control. Loopback is appropriate only
+when other local processes are trusted. Unmatched peers, missing peer metadata
+and the default configuration ignore URL forwarding headers. Unix listeners have
+no TCP peer and do not use this policy. This option belongs to Bun `createServer`,
+not the Fetch-clean `createHandler` or Node `serveNode`.
+
+The trusted ingress must overwrite `Host` with the external authority and
+`X-Forwarded-Proto` with exactly `http` or `https`. It must remove `Forwarded`,
+`X-Forwarded-Host` and `X-Forwarded-Port`; their presence, a missing/invalid
+proto, a list of values or a malformed Host returns HTTP 400 before application
+code. Header names are case-insensitive; proto values are lowercase. Multiple
+ingress chains require a single sanitizing ingress at this boundary.
+
+For an nginx HTTPS terminator, the relevant forwarding settings are:
+
+```nginx
+proxy_set_header Host $http_host;
+proxy_set_header X-Forwarded-Proto $scheme;
+proxy_set_header Forwarded "";
+proxy_set_header X-Forwarded-Host "";
+proxy_set_header X-Forwarded-Port "";
+```
+
+The normalized `Request.url` reaches `wrapFetch`, hooks, contracts, raw routes,
+and the managed Socket.IO route. It preserves the path/query, wire authority
+(including explicit ports), method, body, headers and linked cancellation signal.
+Request cloning uses the normalized URL. The same runtime handle resolves
+`requestIP`, `timeout` and `upgrade` against the original native request, retaining
+WebSocket and shutdown behavior.
+
+This is a scheme normalization policy, **not host authorization**. Applications
+must retain their hostname/tenant allowlist and exact same-origin checks for
+Origin and Referer. The TLS terminator must reject SNI/Host mismatches before
+forwarding; a plain-HTTP Bun listener cannot observe the TLS SNI. The normalizer
+does not accept `X-Forwarded-Host`, authorize a foreign Host, or treat HTTP and
+HTTPS as aliases.
+
 ### Local daemon over a unix socket
 
 A local daemon whose door is a socket file needs no TCP port at all:
@@ -863,134 +918,3 @@ file: (ctx) => {
 `Response` is forwarded verbatim. Request headers are not relayed, so a `Range`
 sent to the proxy does not reach the origin and the full body comes back.
 → ADR 0038.
-
-## Raw routes
-
-Some routes cannot be a clean JSON contract — an OAuth redirect, a webhook with
-signature verification, static files, the Socket.IO endpoint. `rawRoutes` are
-plain `Request → Response` handlers, matched by the same router (shared CORS and
-`onRequest`) but with no schema parsing and no `beforeHandle` gate — a raw route
-authorises itself.
-
-```ts
-createServer({
-  services,
-  rawRoutes: [
-    {
-      method: 'GET',
-      path: '/health',
-      handler: () => Response.json({ status: 'ok' }),
-    },
-    {
-      method: 'POST',
-      path: '/webhooks/:provider',
-      serviceName: 'webhooks',
-      action: 'receive',
-      handler: (req, ctx) => handleWebhook(ctx.params.provider, req),
-    },
-  ],
-})
-```
-
-`serviceName` and `action` are optional observability identity. Declare
-`serviceName` when audit, logging, sampling or another cross-cutting policy
-groups this raw route with a service; add `action` when the policy needs an
-operation within that service. Stitchkit never derives either from `path`.
-`action` without `serviceName`, and empty identity strings, fail at startup.
-
-A path may be exact, carry `:param` segments, or end in `/*filePath` for a prefix
-wildcard — and the two combine: `/app/:slug/*filePath` matches `/app/x/a/b` with
-`ctx.params.slug === 'x'` and the remainder in `ctx.params.filePath` (a SPA
-deep-link fallback). List more specific routes before the wildcard — the first
-match wins. `staticRoute()` builds a raw route that serves a directory.
-
-At startup Stitchkit rejects exact duplicates, equivalent parameter shapes
-(`/users/:id` vs `/users/:userId`) and any later raw route completely hidden by
-an earlier raw route. Partial overlap stays legal, including the recommended
-specific-before-wildcard order. `GET` and `HEAD` remain independent because that
-is how the actual raw matcher dispatches them. Raw-vs-contract overlap remains a
-startup diagnostic naming the bypassed contract identity and scope.
-
-### Raw-route helpers
-
-A raw route gives up the contract pipeline, so three things get re-implemented in
-every one. `stitchkit/server` ships them — conveniences, not a second pipeline
-(no auth, no schema gate beyond `parseBody`):
-
-```ts
-import { respondJson, errorResponse, parseBody, badRequest } from 'stitchkit/server'
-
-handler: async (req) => {
-  try {
-    const body = await parseBody(req, MySchema)      // typed value, or null (no throw)
-    if (!body) throw badRequest('invalid body')      // helpers THROW an AppError
-    return respondJson(await myService(body))         // JSON; 204 when null/undefined
-  } catch (err) {
-    return errorResponse(err)                         // same envelope as a contract route
-  }
-}
-```
-
-The error helpers (`badRequest`, `notFound`, …) **throw** an `AppError`, so raise
-them inside the `try` and let `errorResponse(err)` render it — that runs any
-thrown value through the framework's `normalizeError`, so a raw route returns the
-**identical** `{ error: { code, message, … } }` shape (and `x-request-id`) a
-contract route does.
-
-### Serving files & Range requests
-
-`staticRoute` is basic on purpose — it reads the whole file into memory and has
-no `Range` or conditional support; put a CDN in front, or use it for small web
-assets. To serve **media** (video / audio / large downloads) that a browser must
-seek and cache, use **`serveFile`** (Bun) — it streams the requested byte range
-and speaks the conditional-request half of RFC 7233 / 9110:
-
-```ts
-import { defineContract } from 'stitchkit/contract'
-import { implement, serveFile } from 'stitchkit/server'
-import { z } from 'zod'
-
-const MediaParams = z.object({ id: z.string() })
-const media = defineContract({ prefix: 'media' }, {
-  download: {
-    method: 'GET', path: '/:id', desc: 'Download media',
-    params: MediaParams, rawResponse: true, contentType: 'video/mp4',
-  },
-  inspect: {
-    method: 'HEAD', path: '/:id', desc: 'Inspect media',
-    params: MediaParams, rawResponse: true, contentType: 'video/mp4',
-  },
-})
-
-const mediaService = implement(media, {
-  download: ({ req, params }) =>
-    serveFile(req, { path: pathForId(params.id), filename: 'clip.mp4' }),
-  inspect: ({ req, params }) =>
-    serveFile(req, { path: pathForId(params.id), filename: 'clip.mp4' }),
-})
-```
-
-GET and HEAD are separate operations deliberately: declaring GET never creates
-a hidden HEAD alias. Both travel through the normal contract router, params,
-lifecycle/RBAC and request logging. A HEAD handler may inspect the raw query via
-`ctx.req.url`, but cannot declare a request input schema or body.
-
-`serveFile` returns `206` (range, with `Content-Range` + `Content-Length`), `200`
-(full), `416` (unsatisfiable, `Content-Range: bytes */size`), `304`
-(`If-None-Match` / `If-Modified-Since`), `404` (missing) or `405` (non GET/HEAD).
-It always sets `Accept-Ranges: bytes`, a weak `ETag` and `Last-Modified` (so
-`If-Range` keeps a changing file from being stitched from stale + fresh bytes),
-and `nosniff`. `Content-Type` is auto-detected from the path — override it, or
-pass `disposition` / `cacheControl` / `etag: false`, via the options.
-
-Cross-origin, the browser lets JavaScript read only the CORS-safelisted response
-headers. stitchkit therefore exposes the download-relevant ones by default
-(`Content-Disposition`, `Content-Range`, `ETag`, …) — without that a `fetch`-based
-download cannot recover the file's name. Override with `cors.exposeHeaders`
-(extend `DEFAULT_CORS_EXPOSE_HEADERS` rather than replacing it), or pass `[]` to
-emit none.
-
-`serveFile` takes an explicit `path` and trusts it — **the caller owns
-containment**. For a URL-derived path use `staticRoute` (which enforces it) or
-`isWithinDir` first. The byte-range parser is exported on its own as
-`parseByteRange(header, size)` for direct use and testing. → ADR 0023.

package/llms-full.txt

@@ -1369,6 +1369,7 @@ server. See [Testing & deployment](./testing-and-deployment.md).
 | `logging` | `true` for built-in request logs, or a `LoggingConfig` (see below) |
 | `traceId` | override per-request trace-id resolution — may return `undefined` to fall back |
 | `wrapFetch` | compose wrappers around the finished handler (request context, audit) |
+| `proxyOrigin` | Bun TCP ingress policy: `{ trustedPeer(socketIp) }` restores the external scheme before all composition; independent of client-IP `trustProxy` |
 | `socket` | full Stitchkit Socket.IO handle; route, default WebSocket handler and shutdown are mounted once |
 | `websocket` | custom Bun WebSocket handler; with `socket`, this is the explicit composed handler |
 | `development` / `bun` | passthrough to `Bun.serve` |
@@ -1377,6 +1378,60 @@ Native Bun `routes` are intentionally not accepted: Bun matches them before
 `fetch`, so they could bypass shutdown admission. Use `rawRoutes`; they retain
 the Fetch `Request → Response` model and participate in lifecycle tracking.
 
+### External origin behind a trusted proxy
+
+An HTTPS ingress often forwards plain HTTP to Bun. `trustProxy` trusts client-IP
+headers only; it does not change `Request.url`. Opt into the separate URL policy:
+
+```ts
+import { createServer, isLoopbackAddress } from 'stitchkit/server'
+
+const server = createServer({
+  hostname: '127.0.0.1',
+  port: 3000,
+  proxyOrigin: { trustedPeer: isLoopbackAddress },
+  services,
+})
+```
+
+The predicate receives the **real TCP peer**, never `X-Forwarded-For` or
+`X-Real-IP`. Match only the ingress you control. Loopback is appropriate only
+when other local processes are trusted. Unmatched peers, missing peer metadata
+and the default configuration ignore URL forwarding headers. Unix listeners have
+no TCP peer and do not use this policy. This option belongs to Bun `createServer`,
+not the Fetch-clean `createHandler` or Node `serveNode`.
+
+The trusted ingress must overwrite `Host` with the external authority and
+`X-Forwarded-Proto` with exactly `http` or `https`. It must remove `Forwarded`,
+`X-Forwarded-Host` and `X-Forwarded-Port`; their presence, a missing/invalid
+proto, a list of values or a malformed Host returns HTTP 400 before application
+code. Header names are case-insensitive; proto values are lowercase. Multiple
+ingress chains require a single sanitizing ingress at this boundary.
+
+For an nginx HTTPS terminator, the relevant forwarding settings are:
+
+```nginx
+proxy_set_header Host $http_host;
+proxy_set_header X-Forwarded-Proto $scheme;
+proxy_set_header Forwarded "";
+proxy_set_header X-Forwarded-Host "";
+proxy_set_header X-Forwarded-Port "";
+```
+
+The normalized `Request.url` reaches `wrapFetch`, hooks, contracts, raw routes,
+and the managed Socket.IO route. It preserves the path/query, wire authority
+(including explicit ports), method, body, headers and linked cancellation signal.
+Request cloning uses the normalized URL. The same runtime handle resolves
+`requestIP`, `timeout` and `upgrade` against the original native request, retaining
+WebSocket and shutdown behavior.
+
+This is a scheme normalization policy, **not host authorization**. Applications
+must retain their hostname/tenant allowlist and exact same-origin checks for
+Origin and Referer. The TLS terminator must reject SNI/Host mismatches before
+forwarding; a plain-HTTP Bun listener cannot observe the TLS SNI. The normalizer
+does not accept `X-Forwarded-Host`, authorize a foreign Host, or treat HTTP and
+HTTPS as aliases.
+
 ### Local daemon over a unix socket
 
 A local daemon whose door is a socket file needs no TCP port at all:
@@ -9773,6 +9828,23 @@ string, the schema says what it should be:
 | `z.record(z.string(), z.unknown())` | `--data '{"code":"007"}'` or `--data.code=007` → `"007"` |
 | `.optional()` / `.default()` | not required                           |
 
+Use the inline `:=` form to assign a whole JSON value without scalar coercion:
+
+```bash
+myapp upsert --productId:=null --count:=null
+myapp upsert --productId null            # the literal string "null"
+myapp upsert --productId:='"null"'        # the same string, written as JSON
+```
+
+`null` is accepted only when the unchanged command schema permits it. Omitting an
+optional field leaves it absent; it does not imply `null`. The same syntax works
+for application global options and dotted leaves (`--settings.note:=null`). A
+JSON assignment supplies the whole field, so an array uses one assignment such as
+`--tags:='["a","b"]'`; mixing it with repeated element flags or another assignment
+is refused. Invalid JSON is a usage error before the handler runs. Framework
+options such as `--json` retain their existing grammar. An exact declared field
+name ending in `:` retains its existing inline spelling.
+
 Primitive literals use the same coercion through optional, nullable and default wrappers and as
 array elements. A literal set whose members have different primitive types stays lexical because
 argv has no type tag: for `z.literal([7, '007'])`, `--value 007` remains the string `"007"` rather
@@ -10635,11 +10707,16 @@ the code (so `exitCodes` can map it instead of every remote failure exiting `1`)
 the message the operator needs, and the error's own class — a plain `Error` is
 an *unexpected* error to the runner, which would print a code frame of the framework
 bundle before the JSON failure and scrub it to `INTERNAL_SERVER_ERROR`.
-A structured `{ error, details }` body is relayed as the contract error it
+A `tools/call` response with `isError: true` and a structured `{ error, details }` body is relayed as the contract error it
 is, on every transport; anything else fails as `UPSTREAM_TOOL_ERROR` carrying
 what the server did send. Not `INTERNAL_SERVER_ERROR`, because nothing of ours
 broke.
 
+The CLI writes this refusal to stderr, leaves stdout empty and exits with the
+mapped nonzero error code (`1` for an unmapped code). A successful response may
+contain an ordinary field named `error`; its payload alone does not establish a
+tool failure.
+
 **On the CLI a discovered command prints the answer, not the envelope.**
 `tools/call` returns `{ content: [...], structuredContent? }`, and an agent mount
 needs exactly that — the parts are what a model is shown. The CLI is different in
@@ -21223,6 +21300,7 @@ Also re-exports the error helpers from `stitchkit/contract`.
 | `parseBody` | function | parse + Zod-validate a JSON body → `data` or `null` (no throw) |
 | `HandlerConfig` | _type_ | config for `createHandler`, including optional `maxJsonBodyBytes`; bound to `BunServer` on this entrypoint |
 | `BunServerConfig` | _type_ | config for `createServer` (Bun); `unix` listens on a unix domain socket (mutually exclusive with `port`/`hostname`) — [details](../guide/server.md#local-daemon-over-a-unix-socket) |
+| `ProxyOriginConfig` | _type_ | explicit real-peer trust for Bun `createServer({ proxyOrigin })`; strict external-scheme normalization before composition — [details](../guide/server.md#external-origin-behind-a-trusted-proxy) |
 | `UnixListenConfig` | _type_ | unix listener — a socket path, or `{ path, mode }` to tighten the file mode after listen |
 | `BunServerHandle` | _type_ | managed Bun handle (`url`, `port`, `runtime`, `status`, `shutdown`) |
 | `ManagedServerHandle` | _type_ | shared lifecycle shape generic over the runtime escape hatch |
@@ -23158,7 +23236,7 @@ SDK nor the `ai` peer.
 |--------|------|---------|
 | `createCli` | function | build and run a CLI from contracts — [guide](../guide/cli.md) |
 | `defineCliCommand` | function | define one Zod-typed CLI-only executable command with optional validated-result presentation/exit policy |
-| `parseCliArgs` | function | argv → typed tool args against a schema (advanced) |
+| `parseCliArgs` | function | argv → typed tool args against a schema; inline `--field:=JSON` assigns a whole JSON value, including null, while ordinary string flags remain lexical (advanced) |
 | `routeCliArgv` | function | select the command out of argv without duplicating the global-option grammar (advanced) |
 | `extractCliGlobalOptions` | function | lift the application's own global options out of argv before routing (advanced) |
 | `coerceJsonArgs` | function | the second half of `parseCliArgs` — parse array/object values a consumer sends itself, including discovered MCP object guards restored from JSON Schema, without the `stitchkit/tools` barrel |

package/llms.txt

@@ -18,12 +18,12 @@ Load the slice for each entrypoint your code imports — `import … from 'stitc
 - **stitchkit/tools/contract**: [llms/tools-contract.txt](llms/tools-contract.txt) 0.2 KB
 - **stitchkit/tools/invoker**: [llms/tools-invoker.txt](llms/tools-invoker.txt) 0.2 KB
 - **stitchkit/tools/connections**: [llms/tools-connections.txt](llms/tools-connections.txt) 3.7 KB
-- **stitchkit/cli**: [llms/cli.txt](llms/cli.txt) 43.8 KB → [llms/cli.2.txt](llms/cli.2.txt) 20.2 KB
+- **stitchkit/cli**: [llms/cli.txt](llms/cli.txt) 44.6 KB → [llms/cli.2.txt](llms/cli.2.txt) 20.6 KB
 - **stitchkit/cli/publish**: [llms/cli-publish.txt](llms/cli-publish.txt) 1.5 KB
 - **stitchkit/remote**: [llms/remote.txt](llms/remote.txt) 1.0 KB
 - **stitchkit/contract**: [llms/contract.txt](llms/contract.txt) 31.9 KB
 - **stitchkit/primitives**: [llms/primitives.txt](llms/primitives.txt) 11.7 KB
-- **stitchkit/server**: [llms/server.txt](llms/server.txt) 45.3 KB → [llms/server.2.txt](llms/server.2.txt) 14.6 KB → [llms/server.3.txt](llms/server.3.txt) 45.6 KB → [llms/server.4.txt](llms/server.4.txt) 38.3 KB → [llms/server.5.txt](llms/server.5.txt) 22.1 KB
+- **stitchkit/server**: [llms/server.txt](llms/server.txt) 42.2 KB → [llms/server.2.txt](llms/server.2.txt) 20.3 KB → [llms/server.3.txt](llms/server.3.txt) 45.6 KB → [llms/server.4.txt](llms/server.4.txt) 38.3 KB → [llms/server.5.txt](llms/server.5.txt) 22.3 KB
 - **stitchkit/observability**: [llms/observability.txt](llms/observability.txt) 45.9 KB
 - **stitchkit/agent-runtime**: [llms/agent-runtime.txt](llms/agent-runtime.txt) 42.7 KB → [llms/agent-runtime.2.txt](llms/agent-runtime.2.txt) 46.7 KB → [llms/agent-runtime.3.txt](llms/agent-runtime.3.txt) 35.6 KB
 - **stitchkit/agent-runtime/testing**: [llms/agent-runtime-testing.txt](llms/agent-runtime-testing.txt) 2.6 KB

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stitchkit",
-  "version": "0.110.4",
+  "version": "0.110.6",
   "description": "Contract-first backend framework — one defineContract() into an HTTP API, MCP tools, AI-agent tools and a typed client. Bun and Node.",
   "keywords": [
     "bun",