stitchkit 0.110.6 → 0.111.0

package/llms-full.txt

@@ -77,12 +77,12 @@ own, recorded as an ADR.
 | `stitchkit/geo` | server (Bun or Node) | evolving | managed GeoIP reader generations, last-known-good reload and the optional MaxMind adapter |
 | `stitchkit/oauth` | browser **and** server | evolving | provider-neutral Authorization Code + PKCE request and one-shot callback transaction mechanics |
 | `stitchkit/google` | server (Bun or Node) | evolving | optional Google code exchange and verified OIDC identity adapter |
-| `stitchkit/observability` | server | stable<br>_redefined in 2 of the 55 minors since 0.56.2, most recently 0.92.0_ | request/tool event projections — `createObservability`, trace context, sanitisation |
+| `stitchkit/observability` | server | stable<br>_redefined in 2 of the 56 minors since 0.56.2, most recently 0.92.0_ | request/tool event projections — `createObservability`, trace context, sanitisation |
 | `stitchkit/testing` | tests on Bun or Node | stable | in-process generated clients over a real Fetch handler, the managed-resource conformance kit and manual time for schedules and retries |
 | `stitchkit/declaration` | browser + build and deployment tooling (Bun or Node) | evolving | `ProjectDeclarationSchema` — the one machine-readable statement a repository makes about itself |
 | `stitchkit/react` | browser + server rendering | stable | `createCursorQuery`, `createCacheBridge`, QueryClient and `ApiError` retry policy |
 | `stitchkit/react/keyboard` | browser | evolving | which part of a screen gets a key — ordered layers, one Escape per level, list zones with real focus; see [keyboard guide](keyboard.md) |
-| `stitchkit/agent-runtime` | server | evolving<br>_redefined in 23 of the 55 minors since 0.56.2, most recently 0.105.0_ | optional durable conversation/run loop, history, models, prompts, fencing and events |
+| `stitchkit/agent-runtime` | server | evolving<br>_redefined in 23 of the 56 minors since 0.56.2, most recently 0.105.0_ | optional durable conversation/run loop, history, models, prompts, fencing and events |
 | `stitchkit/agent-runtime/sandbox` | server | evolving | optional Linux Bubblewrap sessions, durable workspaces and a host HTTP credential gateway; see [sandbox guide](sandbox.md) |
 | `stitchkit/agent-runtime/testing` | tests on Bun or Node | evolving | credential-free replay, scripted provider faults, deterministic race controls and the agent-store conformance kit |
 | `stitchkit/agent-runtime/harness` | server | evolving | resource-aware process-local facade over the canonical Agent runtime; supervision stays outside |
@@ -94,7 +94,7 @@ own, recorded as an ADR.
 | `stitchkit/agent-runtime/sqlite/bun` | server (Bun) | evolving | durable built-in SQLite store for the agent runtime |
 | `stitchkit/agent-runtime/sqlite/node` | server (Node ≥ 22.5) | evolving | durable built-in SQLite store for the agent runtime |
 | `stitchkit-tui` | terminal (Bun) | evolving | optional official OpenTUI host over a caller-composed headless runtime |
-| `stitchkit/application` | browser + server | evolving<br>_redefined in 14 of the 55 minors since 0.56.2, most recently 0.110.0_ | managed resource graph, readiness, admission, schedules, subtree restart and bounded shutdown |
+| `stitchkit/application` | browser + server | evolving<br>_redefined in 14 of the 56 minors since 0.56.2, most recently 0.110.0_ | managed resource graph, readiness, admission, schedules, subtree restart and bounded shutdown |
 | `stitchkit/application/grammy` | server | evolving | a grammY bot as application resources — configuration, then polling with updates admitted by batch — and the webhook adapter |
 | `stitchkit/application/opentelemetry` | server | evolving | maps application snapshots onto an injected OpenTelemetry `Meter` |
 | `stitchkit/application/schemas` | browser + server | evolving | the application's snapshot, health and shutdown schemas alone, without the kernel |
@@ -1162,6 +1162,48 @@ Every handler receives one `ctx` argument:
 The same handler runs for HTTP, MCP and agent calls — `ctx.source` tells you
 which. Anything an auth hook attaches (e.g. the resolved user) is also on `ctx`.
 
+### Request attributes from the ingress
+
+When your own code builds the `Request` — a local socket ingress, a relay, a test harness —
+and calls the fetch handler of the core, it often knows something an endpoint needs and the
+request cannot be allowed to say for itself: which authenticated peer sent it. A header can be
+forged by any client. `defineRequestIngress` is the channel the request cannot carry:
+
+```ts
+import { createHandler, defineRequestIngress, implement } from 'stitchkit/server'
+
+interface Peer {
+  node: string
+}
+export const peer = defineRequestIngress<Peer>('peer')
+
+// The ingress, after it has authenticated the peer and built the request:
+peer.attach(request, { node: 'node-7' })
+const response = await handler(request)
+
+// An endpoint, `authorize`, `beforeHandle` or `onError` — `ctx` is the source:
+implement(contract, {
+  place: (ctx) => ({ node: peer.from(ctx)?.node ?? null }),
+})
+```
+
+- The value belongs to the key. A header, a body, `request.clone()` and `new Request(request)`
+  carry nothing; a request from another ingress has no value, and `from` answers `undefined`.
+  Two keys never meet, even under one name, and a second `attach` of the same key to the same
+  request is an error.
+- `ctx.req` is the `Request` the fetch handler of the core received, on every HTTP context: an
+  endpoint, `authorize`, `beforeHandle`, and the `onError` context of a validation failure, an
+  unknown path, a refused method or an `onRequest` that threw. That is the guarantee the lookup
+  stands on, and the ingress tests hold it.
+- A raw route, `streamingRoute` and `onRequest` receive the request without a context: read with
+  `peer.from({ req })`. The MCP, agent and CLI lanes carry no `Request`, so there is nothing to
+  read.
+- With `proxyOrigin` configured, the request is replaced before `wrapFetch`: attach in
+  `wrapFetch` or later, to the request you are handed.
+- A Socket.IO handshake is routed before `wrapFetch` on Bun and rebuilt as a new `Request` on
+  Node: it never carries an attached value.
+- `stitchkit/node` exports the same names.
+
 ### `createImplement` — a fixed context type
 
 To type `ctx` with your app's extras (the user an auth hook injects), fix the
@@ -2087,6 +2129,10 @@ handler: async (req) => {
 }
 ```
 
+`parseBody` reads the body up to `{ maxBytes }` — 1 MiB when you pass none, as the third
+argument — and returns `null` for a larger one without reading further, so a raw route
+never holds an unbounded body in memory.
+
 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
@@ -3509,6 +3555,33 @@ that ends inside a line throws `StreamTruncatedLineError` (`lineBytes`) instead
 fragment as a value — the right policy for a socket or a child process, where a missing newline
 means the writer died. Both errors extend the `RangeError` / `SyntaxError` they replace.
 
+## Reading a body up to a byte limit
+
+`readBoundedBody` (from `stitchkit` or `stitchkit/http`) reads a request or response body, a
+`ReadableStream<Uint8Array>` or any `AsyncIterable<Uint8Array>`, and never reads past
+`maxBytes` plus one chunk. Whoever owns the boundary picks the two errors, so a body that is too
+large and a read that was cancelled stay different outcomes:
+
+```ts
+import { readBoundedBody } from 'stitchkit'
+
+const bytes = await readBoundedBody(request.body, {
+  maxBytes: 64 * 1024,
+  signal: request.signal,
+  limitError: (observedBytes) => new PayloadTooLarge(observedBytes),
+  abortError: (reason) => new ClientGone({ cause: reason }),
+})
+```
+
+- The source is cancelled when the limit is crossed and when `signal` aborts. A read that never
+  settles does not hold the call after an abort, and an abort is honoured before the first read
+  (even for a `null` body).
+- A body of exactly `maxBytes` is read; one more byte calls `limitError` with the bytes seen so far
+  (the chunk that crossed the limit included).
+- A `null` body, such as a request without one, is an empty result.
+- Without `abortError` the signal's own reason is thrown.
+- `maxBytes` is a positive safe integer.
+
 ## Resumable streams
 
 A stream that survives a dropped connection needs four things beyond opening it:
@@ -4511,6 +4584,10 @@ default; DCR is off unless `clientRegistration.dcr` supplies both `register` and
 exactly equals its URL, explicit redirect URIs and
 `token_endpoint_auth_method: 'none'`.
 
+The token endpoint and `/register` read at most 64 KiB of a request body, or
+`maxRequestBodyBytes` when you set it; a larger one is answered `413` with
+`invalid_request` and the rest is not read.
+
 The production fetcher rejects credentials, fragments, non-HTTPS URLs and
 private/reserved targets. Every redirect is DNS-resolved and IP-pinned again;
 timeouts, redirect count and body size are bounded. Its bounded cache respects
@@ -13427,7 +13504,7 @@ queryable across all three:
 | `ok` / `statusCode` | legacy success bit plus real HTTP status, or `200`/`400` for a tool; an opted-in cancellation is `false` / `499`. `statusCode` is **absent** on a job — it had no transport to have a status on, and inventing one would be the same defect as the `method: 'AGENT'` this replaced. A job's outcome is `ok`, plus `errorCode` when it failed |
 | `durationMs` / `startedAt` | timing |
 | `errorCode` / `errorMessage` / `errorDetail` | failures only — `errorDetail` carries the structure the message flattens (e.g. Zod issues) |
-| `payload` | sanitised tool arguments; HTTP is `null` unless request `includePayload` is enabled |
+| `payload` | sanitised tool arguments; HTTP is `null` unless request `includePayload` is enabled, or when the body was larger than `payloadMaxBytes` (then `payloadTruncated: true`) |
 | `resultSize` / `responseBytes` | result item count + serialised size |
 | `userId` / `ipAddress` / `userAgent` | identity |
 
@@ -13799,6 +13876,23 @@ createObservability({
 `redact`, `truncatePreview` and `measureSize` are exported on their own if you
 need to sanitise something outside the audit path.
 
+### How much of a body the audit row reads
+
+With `includePayload: true` the row reads a clone of the request body, and it reads at most
+`payloadMaxBytes` of it. Unset, the limit is the handler's `maxJsonBodyBytes`, or 1 MiB when the
+handler has none, so one number bounds both. The clone is taken when the request opens, before
+a route is matched, so an endpoint's own `maxJsonBodyBytes` is not known to it: set
+`payloadMaxBytes` when endpoints accept more than the handler default. A body that is larger
+is cancelled at the limit, its `payload` is `null`, and the row carries `payloadTruncated: true` — a `null` payload with that flag
+means "too large to record", not "no body". Set `payloadMaxBytes` (a positive integer) to record
+more or less than the handler accepts:
+
+```ts
+createObservability({
+  request: { write, includePayload: true, payloadMaxBytes: 256 * 1024 },
+})
+```
+
 ## The raw hooks
 
 Tool observability is built on hooks you can also use directly — for a one-off
@@ -16053,6 +16147,32 @@ analytics policy belong to the application.
 
 # Upgrading stitchkit
 
+## Released migration: 0.111.0
+
+**Who must act:** applications whose raw routes call `parseBody` on JSON larger than 1 MiB, and applications whose OAuth clients send `/register` or `/token` bodies larger than 64 KiB.
+
+### Bounded raw and OAuth bodies
+
+`parseBody` reads at most 1 MiB and returns `null` for a larger body, where it used to read any size. A route that takes larger JSON states its limit:
+
+```ts
+// before
+const body = await parseBody(req, Schema)
+// after
+const body = await parseBody(req, Schema, { maxBytes: 8 * 1024 * 1024 })
+```
+
+`mountOAuthProvider` reads at most 64 KiB of a `/token` or `/register` body and answers `413` with `invalid_request` for a larger one. A deployment whose clients register larger metadata raises the limit:
+
+```ts
+// before
+mountOAuthProvider({ issuer, signingSecret, resource, codes, authorizeUser })
+// after
+mountOAuthProvider({ issuer, signingSecret, resource, codes, authorizeUser, maxRequestBodyBytes: 256 * 1024 })
+```
+
+Both limits must be a positive safe integer; anything else is refused when the route is built or called.
+
 ## Released migration: 0.110.0
 
 ### Interrupted process drains
@@ -17430,7 +17550,7 @@ Run it inside the project that depends on stitchkit. It reads your installed
 version out of `node_modules`, reads the changelog **shipped inside the
 package**, and prints every breaking section your range crosses, oldest first,
 each with its **Who must act** line — the list this guide's migrations expand
-on. Nothing to clone, nothing to be told: `--from` / `--to` override either end
+on — and then the fixes of that range that name what they touch. Nothing to clone, nothing to be told: `--from` / `--to` override either end
 of the range if you want a different one.
 
 So upgrading is: read the `### ⚠️ Breaking changes` of every version *above* your
@@ -17461,6 +17581,12 @@ beside a `package.json`, which is build output) and gives each item one verdict:
 - **not declared — check by hand** — an item from before the line existed, with the files that
   import the entrypoints it leads with.
 
+A fix that names what it touches gets the same verdicts. Since 0.110.7 every `### Fixed` item that
+leads with an entrypoint carries the `**Affects:**` line, and `upgrade` prints them in a second
+section, **Fixes that touch this project** (`fixes` in `--json`): a fix to `runNativeCommand` is
+listed with the `path:line` that imports it, or as *not used here*. Fixes of earlier releases that
+carry no line are not judged; one line counts them (`fixesWithoutAffects` in `--json`).
+
 `--json` prints the same verdicts per item for a CI step. The scan reads static `import` and
 `export … from` declarations, bare imports and `import()` / `require()` of a literal specifier; a
 specifier built at run time is invisible to it, and so is a file of another kind (`.astro`,
@@ -20958,6 +21084,7 @@ The browser-and-server entrypoint. Re-exports everything from
 | `parseSSE` | function | parse SSE from a `Response`, a web stream or an async byte iterable into an async generator — [guide](../guide/client.md#sse) |
 | `parseNDJSON` | function | parse bounded fatal-UTF-8 NDJSON from a `Response`, a `ReadableStream<Uint8Array>` or an `AsyncIterable<Uint8Array>` (a child's stdout); blank keep-alives are skipped, `finalLine: 'require-newline'` makes the delimiter mandatory and `signal` cancels the source — [guide](../guide/client.md#any-byte-source) |
 | `createNDJSONDecoder` / `NDJSONDecoder` | function / _type_ | the same bounded NDJSON reading driven by `push(chunk)` / `end()`, for a socket `data` callback |
+| `readBoundedBody` / `BoundedBodyOptions` | function / _type_ | the whole body of a `ReadableStream<Uint8Array>` or async byte iterable as bytes, never reading past `maxBytes` plus one chunk; `limitError(observedBytes)` and `abortError(reason)` choose the two errors, the source is cancelled on both, a `null` body is empty — [guide](../guide/client.md#reading-a-body-up-to-a-byte-limit) |
 | `StreamByteSource` | _type_ | `Response \| ReadableStream<Uint8Array> \| AsyncIterable<Uint8Array>`, what the NDJSON and SSE readers accept |
 | `StreamLineLimitError` / `StreamTruncatedLineError` | class | a line past `maxLineBytes` (`limitBytes`, `lineBytes`; a `RangeError`) and a source ended inside a line under `require-newline` (`lineBytes`; a `SyntaxError`) |
 | `resumableIterator` | function | re-open a long-lived stream from the last delivered cursor, with jittered backoff, a caller-owned terminal item and prompt abort — [guide](../guide/client.md#resumable-streams) |
@@ -21297,9 +21424,10 @@ Also re-exports the error helpers from `stitchkit/contract`.
 | `formatZodError` | function | a `ZodError` → a readable, field-summarised string |
 | `zodIssues` | function | a `ZodError` → structured `{ path, code, message }[]` — the machine-readable sibling of `formatZodError` |
 | `ZodIssueSummary` | _type_ | one structured validation issue (`{ path, code, message }`) |
-| `parseBody` | function | parse + Zod-validate a JSON body → `data` or `null` (no throw) |
+| `parseBody` | function | parse + Zod-validate a JSON body → `data` or `null` (no throw); reads at most `options.maxBytes` (1 MiB by default) and is `null` for a larger body |
 | `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) |
+| `defineRequestIngress` / `RequestIngress` / `RequestIngressSource` | function / _type_ | a typed key the code that builds a `Request` attaches a value to (`attach(request, value)`) and an endpoint, `authorize`, `beforeHandle` or `onError` reads from its `ctx` (`from(ctx)`); a header, `clone()` and `new Request(request)` carry nothing, a second `attach` is refused, and `ctx.req` is the very request the handler received — [guide](../guide/server.md#request-attributes-from-the-ingress) |
 | `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`) |
@@ -22389,7 +22517,7 @@ audit event. See the [Observability guide](../guide/observability.md).
 | `ObservabilityDrainReport` | _type_ | final closed/drained snapshot, `durationMs` (the shared drain's age, not this call's wait), and `drained` — read from the counters, `false` only when `total.pending + total.preparing` is nonzero |
 | `ObservabilitySinkStatusSchema` / `ObservabilityStatusSchema` / `ObservabilityDrainReportSchema` | schema | runtime schemas for status/report integration boundaries |
 | `RequestEventSinkConfig` | _type_ | `write`, filter/sanitisation, `maxPending`, `onSinkError` and `onDrop` |
-| `RequestObservabilityConfig` | _type_ | request sink plus opt-in payload capture and default-off `includeCancelled` rows |
+| `RequestObservabilityConfig` | _type_ | request sink plus opt-in payload capture (`payloadMaxBytes` bounds the body read, `payloadTruncated` marks a cut one) and default-off `includeCancelled` rows |
 | `SinkDropReason` | _type_ | `'capacity' \| 'closed'` |
 | `SinkError` | _type_ | isolated sink/projection failure and optional event |
 | `SinkDrop` | _type_ | rejected event, reason and current pending count |
@@ -22634,7 +22762,7 @@ A native remote-connector auth surface for MCP — [guide](../guide/mcp-and-agen
 | `protectedResourceMetadataUrl` | function | build the metadata URL for a resource |
 | `wwwAuthenticateHeader` | function | build the `WWW-Authenticate` challenge header |
 | `PROTECTED_RESOURCE_PATH` | const | the well-known metadata path |
-| `OAuthProviderConfig` | _type_ | config for `mountOAuthProvider` |
+| `OAuthProviderConfig` | _type_ | config for `mountOAuthProvider`; `maxRequestBodyBytes` bounds the `/token` and `/register` bodies (64 KiB by default) |
 | `ProtectedResourceConfig` | _type_ | config for `oauthProtectedResourceRoute` |
 | `ApplicationType` | _type_ | DCR `application_type` — `'native'` (loopback allowed) \| `'web'` (https only) |
 | `AuthCodeData` | _type_ | a stored authorization-code record |

package/llms.txt

@@ -9,11 +9,11 @@ Build with stitchkit: define a contract once, then `implement` it and serve it (
 Load the slice for each entrypoint your code imports — `import … from 'stitchkit/server'` → `llms/server.txt`; the root `stitchkit` import → `llms/stitchkit.txt`. A slice holds that entrypoint's API reference section and the guide pages whose home it is; every guide lives in exactly one slice, and a slice that needs another's guide names it under "Also read". Each file is at most 50.0 KB; a longer one continues in numbered parts, each naming the next at its top. Moving across versions: load `llms/upgrading.txt` and the range slices it lists between your version and the target. `llms-full.txt` inlines everything; it is far larger than a context window, so do not read it whole.
 
 ## Entrypoint slices
-- **stitchkit**: [llms/stitchkit.txt](llms/stitchkit.txt) 47.5 KB → [llms/stitchkit.2.txt](llms/stitchkit.2.txt) 36.5 KB
+- **stitchkit**: [llms/stitchkit.txt](llms/stitchkit.txt) 47.5 KB → [llms/stitchkit.2.txt](llms/stitchkit.2.txt) 38.1 KB
 - **stitchkit/live**: [llms/live.txt](llms/live.txt) 21.2 KB
 - **stitchkit/react**: [llms/react.txt](llms/react.txt) 8.6 KB
 - **stitchkit/react/keyboard**: [llms/react-keyboard.txt](llms/react-keyboard.txt) 9.2 KB
-- **stitchkit/tools**: [llms/tools.txt](llms/tools.txt) 46.2 KB → [llms/tools.2.txt](llms/tools.2.txt) 30.4 KB → [llms/tools.3.txt](llms/tools.3.txt) 26.2 KB
+- **stitchkit/tools**: [llms/tools.txt](llms/tools.txt) 46.4 KB → [llms/tools.2.txt](llms/tools.2.txt) 30.4 KB → [llms/tools.3.txt](llms/tools.3.txt) 26.3 KB
 - **stitchkit/tools/mcp**: [llms/tools-mcp.txt](llms/tools-mcp.txt) 1.8 KB
 - **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
@@ -23,8 +23,8 @@ Load the slice for each entrypoint your code imports — `import … from 'stitc
 - **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) 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/server**: [llms/server.txt](llms/server.txt) 44.2 KB → [llms/server.2.txt](llms/server.2.txt) 20.5 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.9 KB
+- **stitchkit/observability**: [llms/observability.txt](llms/observability.txt) 46.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
 - **stitchkit/agent-runtime/harness**: [llms/agent-runtime-harness.txt](llms/agent-runtime-harness.txt) 11.0 KB
@@ -63,8 +63,8 @@ Load the slice for each entrypoint your code imports — `import … from 'stitc
 - **stitchkit/realtime**: [llms/realtime.txt](llms/realtime.txt) 1.4 KB
 
 ## Upgrading slices
-- **Upgrading — how to move across versions**: [llms/upgrading.txt](llms/upgrading.txt) 12.2 KB
-- **Upgrading 0.101.0 → 0.110.0**: [llms/upgrading-0.101.0-0.110.0.txt](llms/upgrading-0.101.0-0.110.0.txt) 45.8 KB
+- **Upgrading — how to move across versions**: [llms/upgrading.txt](llms/upgrading.txt) 12.7 KB
+- **Upgrading 0.101.0 → 0.111.0**: [llms/upgrading-0.101.0-0.111.0.txt](llms/upgrading-0.101.0-0.111.0.txt) 46.9 KB
 - **Upgrading 0.74.0 → 0.100.0**: [llms/upgrading-0.74.0-0.100.0.txt](llms/upgrading-0.74.0-0.100.0.txt) 45.1 KB
 - **Upgrading 0.61.0 → 0.73.0**: [llms/upgrading-0.61.0-0.73.0.txt](llms/upgrading-0.61.0-0.73.0.txt) 41.2 KB
 - **Upgrading 0.44.0 → 0.60.0**: [llms/upgrading-0.44.0-0.60.0.txt](llms/upgrading-0.44.0-0.60.0.txt) 43.9 KB

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stitchkit",
-  "version": "0.110.6",
+  "version": "0.111.0",
   "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",