ts-procedures 7.1.2 → 7.3.0

package/README.md

@@ -2,6 +2,14 @@
 
 A TypeScript RPC framework that creates type-safe, schema-validated procedure calls with a single function definition. Define your procedures once and get full type inference, runtime validation and procedure documentation/configuration.
 
+## Goals of this Project
+
+1. Full type safety
+2. Auto generated documentation and client api spec
+3. Fast and performant
+4. Excellent DX (and agent documentation)
+
+
 ## Installation
 
 ```bash

package/agent_config/claude-code/skills/ts-procedures/anti-patterns.md

@@ -695,6 +695,40 @@ Or use the `.safe()` sibling for exhaustive Result-based narrowing (see `pattern
 
 ---
 
+## 22. Using `noRuntimeValidation` on a public-facing factory
+
+**Problem:** Setting `Procedures({ config: { noRuntimeValidation: true } })` on a factory whose procedures are exposed via HTTP, mounted on a public surface, or invoked with caller-supplied JSON. Schema validation is the only thing standing between untyped wire data and your handlers — turning it off lets malformed payloads reach business logic.
+
+```typescript
+// BAD — these procedures are mounted on Hono and called by browsers
+const { Create } = Procedures({ config: { noRuntimeValidation: true } })
+
+const { CreateUser } = Create('CreateUser', {
+  path: '/users', method: 'post',
+  schema: { input: { body: Type.Object({ email: Type.String() }) } },
+}, async (ctx, { body }) => {
+  // body.email is typed `string`, but at runtime it can be anything —
+  // the request validator was disabled at the factory level.
+  await db.users.insert({ email: body.email })
+})
+```
+
+**Fix:** Leave validation on for any factory whose handlers can be reached from untrusted callers. Only opt out when the factory is purely internal (e.g., a back-of-house procedure registry called from another already-validated procedure or a fully type-checked compile step).
+
+```typescript
+// GOOD — public factory keeps runtime validation
+const { Create: CreatePublic } = Procedures()
+
+// GOOD — internal factory used only from already-validated callers
+const { Create: CreateInternal } = Procedures({
+  config: { noRuntimeValidation: true },
+})
+```
+
+**Why:** `noRuntimeValidation` skips both `schema.params` and `schema.input` AJV runs for every procedure on the factory — there is no per-procedure escape hatch. TypeScript types still flow, but TS types vanish at runtime. AJV is also what enforces `coerceTypes` and `removeAdditional`; once disabled, extra wire fields will leak through and string/number coercion stops happening. The flag is only `true` (no `false`) because the safe default — validation on — should never be expressed by a config value at all; an unset config is the safe path.
+
+---
+
 ## Summary Table
 
 | # | Anti-Pattern | Risk | Severity |
@@ -720,3 +754,4 @@ Or use the `.safe()` sibling for exhaustive Result-based narrowing (see `pattern
 | 19 | Mismatched path param names | Build-time error or confusing validation failures | CRITICAL |
 | 20 | Hand-writing onError instanceof ladders | Drifting response shapes, untyped client errors | WARNING |
 | 21 | Catching raw DOMException/TypeError from generated callables | Framework normalizes these; raw platform errors won't reach catch blocks after 7.0.0 | WARNING |
+| 22 | `noRuntimeValidation` on a public-facing factory | Untrusted wire data reaches handlers without AJV; coerceTypes/removeAdditional also disabled | CRITICAL |

package/agent_config/claude-code/skills/ts-procedures/api-reference.md

@@ -7,6 +7,9 @@ Factory function that creates a scoped procedure registration system.
 ```typescript
 function Procedures<TContext = unknown, TExtendedConfig = unknown>(
   builder?: {
+    config?: {
+      noRuntimeValidation?: true
+    }
     onCreate?: (procedure: {
       name: string
       isStream?: boolean
@@ -26,6 +29,7 @@ function Procedures<TContext = unknown, TExtendedConfig = unknown>(
 
 ### Parameters
 
+- `builder.config.noRuntimeValidation` — When `true`, every procedure registered through this factory skips AJV validation of `schema.params` and `schema.input` at call time (applies to both `Create` and `CreateStream`). JSON Schema is still computed at registration time, so `info.schema` and codegen are unaffected. Shape is `noRuntimeValidation?: true` — only `true` is accepted, making the opt-out explicit. Use only for trusted internal factories whose callers are already type-checked at build time; do **not** enable for procedures that accept input from public clients or untyped JSON bodies.
 - `builder.onCreate` — Called each time a procedure is registered. Use for framework integration, route registration, or logging.
 
 ### Return Value
@@ -1392,6 +1396,42 @@ type DefinitionInfo = {
 
 ---
 
+## Astro adapter — `ts-procedures/astro`
+
+For Astro apps, mount one or more pre-built Hono apps inside a single catch-all endpoint:
+
+```ts
+// src/pages/api/[...rest].ts
+import { createAstroHandler } from 'ts-procedures/astro'
+import { apiApp } from '../../server/api'
+
+export const { ALL } = createAstroHandler({
+  apps: apiApp,
+  pathPrefix: '/api',
+})
+```
+
+Inside factory-context closures, read Astro's APIContext via `getAstroContext`:
+
+```ts
+import { getAstroContext } from 'ts-procedures/astro'
+
+new HonoAPIAppBuilder()
+  .register(usersAPI, (c) => {
+    const astro = getAstroContext(c)
+    return { db, user: astro.locals.user ?? null }
+  })
+  .build()
+```
+
+Multi-app: pass an array; first non-404 response wins. All-404 falls back to the adapter's own 404. Streams pass through unchanged.
+
+Constraints:
+- Astro 5+ in SSR (or `prerender = false`).
+- Express builders are NOT supported by this adapter — Hono builders only.
+
+---
+
 ## Imports
 
 ```typescript

package/agent_config/claude-code/skills/ts-procedures/patterns.md

@@ -1195,3 +1195,17 @@ const axiosAdapter: ClientAdapter = {
   },
 }
 ```
+
+---
+
+### Astro integration
+
+When a downstream developer is building inside an Astro app, recommend the catch-all pattern:
+
+1. Build the Hono app ONCE in `src/server/api.ts` using `HonoAPIAppBuilder` / `HonoRPCAppBuilder` / `HonoStreamAppBuilder` exactly as you would for any other deployment.
+2. Inside the factory-context closure, call `getAstroContext(c)` to read `locals`, `cookies`, `params`, etc.
+3. Mount the built app(s) in a single catch-all file: `src/pages/api/[...rest].ts`. Use `pathPrefix: '/api'` so your Hono routes don't need to repeat the prefix.
+
+Anti-pattern: don't create one Astro file per procedure — that loses the centralized factory wiring and forces the developer to repeat the context closure.
+
+Anti-pattern: don't try to use `express-rpc` with the Astro adapter. The adapter only accepts Web-Fetch apps (Hono).

package/agent_config/claude-code/skills/ts-procedures-scaffold/SKILL.md

@@ -35,6 +35,7 @@ If either argument is missing, ask the user for `<type>` and `<Name>`.
 | `hono-stream` | `templates/hono-stream.md` | `{{Name}}.stream-rpc.ts`, `{{Name}}.stream-rpc.test.ts` |
 | `hono-api` | `templates/hono-api.md` | `{{Name}}.api.ts`, `{{Name}}.api.test.ts` |
 | `client` | `templates/client.md` | `{{Name}}.client.ts`, `{{Name}}.client.test.ts` |
+| `astro-catchall` | `templates/astro-catchall.md` | `src/pages/api/[...rest].ts` |
 
 ## Rules
 

package/agent_config/claude-code/skills/ts-procedures-scaffold/templates/astro-catchall.md

@@ -0,0 +1,23 @@
+# Astro Catch-All Template
+
+Catch-all Astro API route that serves every ts-procedures route from a single file.
+
+## Implementation — `src/pages/api/[...rest].ts`
+
+```typescript
+// src/pages/api/[...rest].ts
+//
+// Catch-all entry point that serves every ts-procedures route from a single Astro file.
+// Adjust `pathPrefix` to match the directory the file lives in (e.g., '/api' for
+// src/pages/api/[...rest].ts; '/v1' for src/pages/v1/[...rest].ts).
+//
+// Build your Hono app(s) ONCE in a sibling module, then drop them in here.
+
+import { createAstroHandler } from 'ts-procedures/astro'
+import { apiApp } from '../../server/api' // ← your built Hono app(s)
+
+export const { ALL } = createAstroHandler({
+  apps: apiApp,
+  pathPrefix: '/api',
+})
+```

package/agent_config/copilot/copilot-instructions.md

@@ -62,6 +62,8 @@ import type { DocEnvelope, HeaderDoc, ErrorDoc } from 'ts-procedures/http-docs'
 
 8. **getProcedures() for introspection.** Returns all registered procedures with metadata.
 
+9. **`Procedures({ config: { noRuntimeValidation: true } })` skips per-call AJV validation** for every procedure on the factory (both `Create` and `CreateStream`, both `schema.params` and `schema.input`). Shape is `noRuntimeValidation?: true` — only `true` is accepted. JSON Schema is still computed at registration time, so codegen and `info.schema` are unaffected; only the validator runs are bypassed. **Never enable this on a factory whose handlers are reachable from public/untrusted callers** — coerceTypes and removeAdditional also stop running. Reserve for trusted internal factories whose callers are already type-checked at build time. Independent of the per-call `ctx.isPrevalidated` escape hatch used by HTTP builders.
+
 ## Procedure Pattern
 
 ```typescript
@@ -192,6 +194,10 @@ const app = new HonoAPIAppBuilder({ pathPrefix: '/api' })
 // GET /api/users/:id → 200, POST /api/users → 201
 ```
 
+## Astro adapter
+
+Catch-all endpoint pattern. Build Hono apps once with HonoAPI/RPC/Stream builders, mount via `createAstroHandler` in `src/pages/api/[...rest].ts` with `pathPrefix: '/api'`. Read Astro context inside factory closures with `getAstroContext(c)`. Multi-app dispatch is first-non-404-wins. Express builders are not supported.
+
 ## Error Handling
 
 | Error Class | Trigger | HTTP Status |

package/agent_config/cursor/cursorrules

@@ -62,6 +62,8 @@ import type { DocEnvelope, HeaderDoc, ErrorDoc } from 'ts-procedures/http-docs'
 
 8. **getProcedures() for introspection.** Returns all registered procedures with metadata.
 
+9. **`Procedures({ config: { noRuntimeValidation: true } })` skips per-call AJV validation** for every procedure on the factory (both `Create` and `CreateStream`, both `schema.params` and `schema.input`). Shape is `noRuntimeValidation?: true` — only `true` is accepted. JSON Schema is still computed at registration time, so codegen and `info.schema` are unaffected; only the validator runs are bypassed. **Never enable this on a factory whose handlers are reachable from public/untrusted callers** — coerceTypes and removeAdditional also stop running. Reserve for trusted internal factories whose callers are already type-checked at build time. Independent of the per-call `ctx.isPrevalidated` escape hatch used by HTTP builders.
+
 ## Procedure Pattern
 
 ```typescript
@@ -192,6 +194,10 @@ const app = new HonoAPIAppBuilder({ pathPrefix: '/api' })
 // GET /api/users/:id → 200, POST /api/users → 201
 ```
 
+## Astro adapter
+
+Catch-all endpoint pattern. Build Hono apps once with HonoAPI/RPC/Stream builders, mount via `createAstroHandler` in `src/pages/api/[...rest].ts` with `pathPrefix: '/api'`. Read Astro context inside factory closures with `getAstroContext(c)`. Multi-app dispatch is first-non-404-wins. Express builders are not supported.
+
 ## Error Handling
 
 | Error Class | Trigger | HTTP Status |

package/build/implementations/http/astro/astro-context.d.ts

@@ -0,0 +1,19 @@
+import type { APIContext } from 'astro';
+import type { Context as HonoContext } from 'hono';
+/**
+ * Internal — stash the Astro APIContext for the Request that Hono will receive.
+ *
+ * The key MUST be the post-rewrite Request (the one passed to `app.fetch`),
+ * because that is what Hono exposes via `c.req.raw` and what `getAstroContext`
+ * reads back. When no `pathPrefix` rewrite happens, this is the same Request
+ * that Astro originally invoked the adapter with.
+ */
+export declare function setAstroContext(request: Request, apiContext: APIContext): void;
+/**
+ * Reads Astro's APIContext from inside a Hono factory-context closure.
+ *
+ * Throws when the request is not in scope — typically because the Hono app
+ * is being served outside the Astro adapter (e.g., bound to a Node listener
+ * or via a different adapter) and the closure was invoked there.
+ */
+export declare function getAstroContext(c: HonoContext): APIContext;

package/build/implementations/http/astro/astro-context.js

@@ -0,0 +1,28 @@
+const astroContextMap = new WeakMap();
+/**
+ * Internal — stash the Astro APIContext for the Request that Hono will receive.
+ *
+ * The key MUST be the post-rewrite Request (the one passed to `app.fetch`),
+ * because that is what Hono exposes via `c.req.raw` and what `getAstroContext`
+ * reads back. When no `pathPrefix` rewrite happens, this is the same Request
+ * that Astro originally invoked the adapter with.
+ */
+export function setAstroContext(request, apiContext) {
+    astroContextMap.set(request, apiContext);
+}
+/**
+ * Reads Astro's APIContext from inside a Hono factory-context closure.
+ *
+ * Throws when the request is not in scope — typically because the Hono app
+ * is being served outside the Astro adapter (e.g., bound to a Node listener
+ * or via a different adapter) and the closure was invoked there.
+ */
+export function getAstroContext(c) {
+    const ctx = astroContextMap.get(c.req.raw);
+    if (!ctx) {
+        throw new Error('getAstroContext was called outside an Astro request scope. ' +
+            'Ensure this Hono app is being served via createAstroHandler when this closure runs.');
+    }
+    return ctx;
+}
+//# sourceMappingURL=astro-context.js.map

package/build/implementations/http/astro/astro-context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"astro-context.js","sourceRoot":"","sources":["../../../../src/implementations/http/astro/astro-context.ts"],"names":[],"mappings":"AAGA,MAAM,eAAe,GAAG,IAAI,OAAO,EAAuB,CAAA;AAE1D;;;;;;;GAOG;AACH,MAAM,UAAU,eAAe,CAAC,OAAgB,EAAE,UAAsB;IACtE,eAAe,CAAC,GAAG,CAAC,OAAO,EAAE,UAAU,CAAC,CAAA;AAC1C,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,eAAe,CAAC,CAAc;IAC5C,MAAM,GAAG,GAAG,eAAe,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAA;IAC1C,IAAI,CAAC,GAAG,EAAE,CAAC;QACT,MAAM,IAAI,KAAK,CACb,6DAA6D;YAC3D,qFAAqF,CACxF,CAAA;IACH,CAAC;IACD,OAAO,GAAG,CAAA;AACZ,CAAC"}

package/build/implementations/http/astro/create-handler.d.ts

@@ -0,0 +1,26 @@
+import type { Hono } from 'hono';
+import type { APIRoute } from 'astro';
+export type AstroAdapterConfig = {
+    /** One or more built Hono apps. Order matters in first-match dispatch. */
+    apps: Hono | Hono[];
+    /**
+     * Path prefix matching the Astro catch-all mount point.
+     * For src/pages/api/[...rest].ts use '/api'. The adapter strips this
+     * before delegating, so Hono routes do NOT need to repeat the prefix.
+     *
+     * Normalization: leading and trailing slashes are optional; '/api',
+     * 'api', and '/api/' are equivalent. Undefined or '/' means no rewrite.
+     */
+    pathPrefix?: string;
+};
+export type AstroHandlers = {
+    ALL: APIRoute;
+    GET: APIRoute;
+    POST: APIRoute;
+    PUT: APIRoute;
+    PATCH: APIRoute;
+    DELETE: APIRoute;
+    HEAD: APIRoute;
+    OPTIONS: APIRoute;
+};
+export declare function createAstroHandler(config: AstroAdapterConfig): AstroHandlers;

package/build/implementations/http/astro/create-handler.js

@@ -0,0 +1,28 @@
+import { setAstroContext } from './astro-context.js';
+import { stripPrefix } from './rewrite-request.js';
+const HTTP_METHODS = ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'HEAD', 'OPTIONS'];
+export function createAstroHandler(config) {
+    const apps = Array.isArray(config.apps) ? config.apps : [config.apps];
+    if (apps.length === 0) {
+        throw new Error('createAstroHandler: `apps` must contain at least one Hono app.');
+    }
+    const ALL = async (apiContext) => {
+        const rewritten = stripPrefix(apiContext.request, config.pathPrefix);
+        if (rewritten === null) {
+            return new Response(null, { status: 404 });
+        }
+        setAstroContext(rewritten, apiContext);
+        for (const app of apps) {
+            const res = await app.fetch(rewritten);
+            if (res.status !== 404)
+                return res;
+        }
+        return new Response(null, { status: 404 });
+    };
+    const handlers = { ALL };
+    for (const method of HTTP_METHODS) {
+        handlers[method] = ALL;
+    }
+    return handlers;
+}
+//# sourceMappingURL=create-handler.js.map

package/build/implementations/http/astro/create-handler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-handler.js","sourceRoot":"","sources":["../../../../src/implementations/http/astro/create-handler.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAA;AACpD,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAA;AA2BlD,MAAM,YAAY,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,CAAU,CAAA;AAE1F,MAAM,UAAU,kBAAkB,CAAC,MAA0B;IAC3D,MAAM,IAAI,GAAG,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;IAErE,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACtB,MAAM,IAAI,KAAK,CAAC,gEAAgE,CAAC,CAAA;IACnF,CAAC;IAED,MAAM,GAAG,GAAa,KAAK,EAAE,UAAU,EAAE,EAAE;QACzC,MAAM,SAAS,GAAG,WAAW,CAAC,UAAU,CAAC,OAAO,EAAE,MAAM,CAAC,UAAU,CAAC,CAAA;QACpE,IAAI,SAAS,KAAK,IAAI,EAAE,CAAC;YACvB,OAAO,IAAI,QAAQ,CAAC,IAAI,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC,CAAA;QAC5C,CAAC;QACD,eAAe,CAAC,SAAS,EAAE,UAAU,CAAC,CAAA;QAEtC,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE,CAAC;YACvB,MAAM,GAAG,GAAG,MAAM,GAAG,CAAC,KAAK,CAAC,SAAS,CAAC,CAAA;YACtC,IAAI,GAAG,CAAC,MAAM,KAAK,GAAG;gBAAE,OAAO,GAAG,CAAA;QACpC,CAAC;QACD,OAAO,IAAI,QAAQ,CAAC,IAAI,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC,CAAA;IAC5C,CAAC,CAAA;IAED,MAAM,QAAQ,GAAG,EAAE,GAAG,EAAmB,CAAA;IACzC,KAAK,MAAM,MAAM,IAAI,YAAY,EAAE,CAAC;QAClC,QAAQ,CAAC,MAAM,CAAC,GAAG,GAAG,CAAA;IACxB,CAAC;IACD,OAAO,QAAQ,CAAA;AACjB,CAAC"}

package/build/implementations/http/astro/index.d.ts

@@ -0,0 +1,3 @@
+export { createAstroHandler } from './create-handler.js';
+export type { AstroAdapterConfig, AstroHandlers } from './create-handler.js';
+export { getAstroContext } from './astro-context.js';

package/build/implementations/http/astro/index.js

@@ -0,0 +1,6 @@
+// Public surface for ts-procedures/astro.
+// Note: setAstroContext is intentionally NOT re-exported — it's an
+// internal helper used only by createAstroHandler.
+export { createAstroHandler } from './create-handler.js';
+export { getAstroContext } from './astro-context.js';
+//# sourceMappingURL=index.js.map

package/build/implementations/http/astro/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/implementations/http/astro/index.ts"],"names":[],"mappings":"AAAA,0CAA0C;AAC1C,mEAAmE;AACnE,mDAAmD;AACnD,OAAO,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAA;AAExD,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAA"}

package/build/implementations/http/astro/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/implementations/http/astro/index.test.js

@@ -0,0 +1,295 @@
+import { describe, expect, test } from 'vitest';
+import { Hono } from 'hono';
+import { Type } from 'typebox';
+import { stripPrefix } from './rewrite-request.js';
+import { setAstroContext, getAstroContext } from './astro-context.js';
+import { createAstroHandler } from './create-handler.js';
+import { Procedures } from '../../../index.js';
+import { HonoAPIAppBuilder } from '../hono-api/index.js';
+import { HonoStreamAppBuilder } from '../hono-stream/index.js';
+// Minimal stand-in for Astro's APIContext for unit tests.
+function fakeApiContext(overrides = {}) {
+    return {
+        locals: { user: { id: 'u-1' } },
+        cookies: {},
+        params: {},
+        request: new Request('https://example.test/'),
+        url: new URL('https://example.test/'),
+        redirect: () => new Response(null, { status: 302 }),
+        ...overrides,
+    };
+}
+function buildSimpleUserApi() {
+    const API = Procedures();
+    API.Create('GetUser', {
+        path: '/users/:id',
+        method: 'get',
+        schema: {
+            input: { pathParams: Type.Object({ id: Type.String() }) },
+            returnType: Type.Object({ id: Type.String(), name: Type.String() }),
+        },
+    }, async (ctx, { pathParams }) => {
+        const u = ctx.db.get(pathParams.id);
+        if (!u)
+            throw new Error('not found');
+        return u;
+    });
+    const db = new Map([['1', { id: '1', name: 'Ada' }]]);
+    return new HonoAPIAppBuilder().register(API, () => ({ db })).build();
+}
+describe('stripPrefix', () => {
+    test('returns original request when prefix is undefined', () => {
+        const req = new Request('https://example.test/api/users/1');
+        expect(stripPrefix(req, undefined)).toBe(req);
+    });
+    test('returns original request when normalized prefix is "/"', () => {
+        const req = new Request('https://example.test/users/1');
+        expect(stripPrefix(req, '/')).toBe(req);
+        expect(stripPrefix(req, '')).toBe(req);
+    });
+    test('strips a leading-slash prefix', () => {
+        const req = new Request('https://example.test/api/users/1');
+        const out = stripPrefix(req, '/api');
+        expect(new URL(out.url).pathname).toBe('/users/1');
+    });
+    test('strips a no-slash prefix (normalized)', () => {
+        const req = new Request('https://example.test/api/users/1');
+        const out = stripPrefix(req, 'api');
+        expect(new URL(out.url).pathname).toBe('/users/1');
+    });
+    test('strips a trailing-slash prefix (normalized)', () => {
+        const req = new Request('https://example.test/api/users/1');
+        const out = stripPrefix(req, '/api/');
+        expect(new URL(out.url).pathname).toBe('/users/1');
+    });
+    test('exact-match prefix becomes "/"', () => {
+        const req = new Request('https://example.test/api');
+        const out = stripPrefix(req, '/api');
+        expect(new URL(out.url).pathname).toBe('/');
+    });
+    test('returns null when path does not start with prefix (404 short-circuit)', () => {
+        const req = new Request('https://example.test/other/users/1');
+        expect(stripPrefix(req, '/api')).toBeNull();
+    });
+    test('returns null when path shares prefix characters but not a segment boundary', () => {
+        // /apikey starts with /api but is not under /api — must NOT rewrite.
+        expect(stripPrefix(new Request('https://example.test/apikey/secret'), '/api')).toBeNull();
+        expect(stripPrefix(new Request('https://example.test/api-v2/x'), '/api')).toBeNull();
+        expect(stripPrefix(new Request('https://example.test/api_internal'), '/api')).toBeNull();
+    });
+    test('preserves the query string through the rewrite', () => {
+        const req = new Request('https://example.test/api/users?limit=10&tag=a&tag=b');
+        const out = stripPrefix(req, '/api');
+        const url = new URL(out.url);
+        expect(url.pathname).toBe('/users');
+        expect(url.search).toBe('?limit=10&tag=a&tag=b');
+    });
+    test('preserves the request method', () => {
+        const req = new Request('https://example.test/api/users', { method: 'POST' });
+        const out = stripPrefix(req, '/api');
+        expect(out.method).toBe('POST');
+    });
+    test('preserves headers', () => {
+        const req = new Request('https://example.test/api/users', {
+            method: 'POST',
+            headers: { 'X-Trace-Id': 'abc-123', 'Content-Type': 'application/json' },
+        });
+        const out = stripPrefix(req, '/api');
+        expect(out.headers.get('X-Trace-Id')).toBe('abc-123');
+        expect(out.headers.get('Content-Type')).toBe('application/json');
+    });
+});
+describe('astro-context', () => {
+    test('getAstroContext returns the APIContext stashed for the request seen by Hono', async () => {
+        const req = new Request('https://example.test/probe');
+        const apiContext = fakeApiContext();
+        setAstroContext(req, apiContext);
+        const app = new Hono();
+        let observed = null;
+        app.get('/probe', (c) => {
+            observed = getAstroContext(c);
+            return c.json({ ok: true });
+        });
+        const res = await app.fetch(req);
+        expect(res.status).toBe(200);
+        expect(observed).toBe(apiContext);
+    });
+    test('getAstroContext throws when called outside an Astro request scope', async () => {
+        const app = new Hono();
+        let captured = null;
+        app.get('/probe', (c) => {
+            try {
+                getAstroContext(c);
+            }
+            catch (err) {
+                captured = err;
+            }
+            return c.json({ ok: true });
+        });
+        await app.fetch(new Request('https://example.test/probe'));
+        expect(captured).toBeInstanceOf(Error);
+        expect(captured.message).toMatch(/outside an Astro request scope/i);
+    });
+});
+describe('createAstroHandler — single app, no prefix', () => {
+    test('exports ALL plus the seven HTTP method handlers', () => {
+        const handlers = createAstroHandler({ apps: buildSimpleUserApi() });
+        expect(typeof handlers.ALL).toBe('function');
+        for (const m of ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'HEAD', 'OPTIONS']) {
+            expect(typeof handlers[m]).toBe('function');
+        }
+    });
+    test('GET roundtrips through the underlying Hono app', async () => {
+        const { ALL } = createAstroHandler({ apps: buildSimpleUserApi() });
+        const apiContext = fakeApiContext({
+            request: new Request('https://example.test/users/1'),
+            url: new URL('https://example.test/users/1'),
+        });
+        const res = await ALL(apiContext);
+        expect(res.status).toBe(200);
+        expect(await res.json()).toEqual({ id: '1', name: 'Ada' });
+    });
+});
+describe('createAstroHandler — pathPrefix + getAstroContext', () => {
+    test('strips pathPrefix before delegating', async () => {
+        // Underlying Hono app has no /api in its routes.
+        const app = buildSimpleUserApi();
+        const { ALL } = createAstroHandler({ apps: app, pathPrefix: '/api' });
+        const apiContext = fakeApiContext({
+            request: new Request('https://example.test/api/users/1'),
+            url: new URL('https://example.test/api/users/1'),
+        });
+        const res = await ALL(apiContext);
+        expect(res.status).toBe(200);
+        expect(await res.json()).toEqual({ id: '1', name: 'Ada' });
+    });
+    test('returns 404 directly when request path is outside the prefix', async () => {
+        const { ALL } = createAstroHandler({ apps: buildSimpleUserApi(), pathPrefix: '/api' });
+        const apiContext = fakeApiContext({
+            request: new Request('https://example.test/somewhere-else'),
+            url: new URL('https://example.test/somewhere-else'),
+        });
+        const res = await ALL(apiContext);
+        expect(res.status).toBe(404);
+    });
+    test('factory closure can read APIContext via getAstroContext', async () => {
+        const API = Procedures();
+        API.Create('WhoAmI', { path: '/whoami', method: 'get', schema: { returnType: Type.Object({ userId: Type.Union([Type.String(), Type.Null()]) }) } }, async (ctx) => ({ userId: ctx.user?.id ?? null }));
+        const app = new HonoAPIAppBuilder()
+            .register(API, (c) => {
+            const astro = getAstroContext(c);
+            return { user: astro.locals.user ?? null };
+        })
+            .build();
+        const { ALL } = createAstroHandler({ apps: app });
+        const apiContext = fakeApiContext({
+            locals: { user: { id: 'u-42' } },
+            request: new Request('https://example.test/whoami'),
+            url: new URL('https://example.test/whoami'),
+        });
+        const res = await ALL(apiContext);
+        expect(res.status).toBe(200);
+        expect(await res.json()).toEqual({ userId: 'u-42' });
+    });
+});
+describe('createAstroHandler — multi-app dispatch', () => {
+    function makeAppWithRoute(path, status, body) {
+        const app = new Hono();
+        app.all(path, (c) => c.json(body, status));
+        return app;
+    }
+    test('first 404 falls through to the second app', async () => {
+        const a = makeAppWithRoute('/only-a', 200, { from: 'a' });
+        const b = makeAppWithRoute('/only-b', 200, { from: 'b' });
+        const { ALL } = createAstroHandler({ apps: [a, b] });
+        const apiContext = fakeApiContext({
+            request: new Request('https://example.test/only-b'),
+            url: new URL('https://example.test/only-b'),
+        });
+        const res = await ALL(apiContext);
+        expect(res.status).toBe(200);
+        expect(await res.json()).toEqual({ from: 'b' });
+    });
+    test('a non-404 response from the first app short-circuits dispatch', async () => {
+        const a = makeAppWithRoute('/error', 500, { boom: true });
+        const b = makeAppWithRoute('/error', 200, { from: 'b' });
+        const { ALL } = createAstroHandler({ apps: [a, b] });
+        const apiContext = fakeApiContext({
+            request: new Request('https://example.test/error'),
+            url: new URL('https://example.test/error'),
+        });
+        const res = await ALL(apiContext);
+        expect(res.status).toBe(500);
+        expect(await res.json()).toEqual({ boom: true });
+    });
+    test('all-404 returns the adapter\'s own 404 with empty body', async () => {
+        const a = makeAppWithRoute('/x', 200, { from: 'a' });
+        const b = makeAppWithRoute('/y', 200, { from: 'b' });
+        const { ALL } = createAstroHandler({ apps: [a, b] });
+        const apiContext = fakeApiContext({
+            request: new Request('https://example.test/nope'),
+            url: new URL('https://example.test/nope'),
+        });
+        const res = await ALL(apiContext);
+        expect(res.status).toBe(404);
+        expect(await res.text()).toBe('');
+    });
+});
+describe('createAstroHandler — streams', () => {
+    test('SSE events from a HonoStream builder pass through the adapter', async () => {
+        const STREAM = Procedures();
+        STREAM.CreateStream('Counter', {
+            scope: 'counter',
+            version: 1,
+            schema: {
+                yieldType: Type.Object({ n: Type.Number() }),
+            },
+        }, async function* () {
+            yield { n: 1 };
+            yield { n: 2 };
+            yield { n: 3 };
+        });
+        const streamApp = new HonoStreamAppBuilder().register(STREAM, () => ({})).build();
+        const { ALL } = createAstroHandler({ apps: streamApp });
+        const apiContext = fakeApiContext({
+            request: new Request('https://example.test/counter/counter/1', { method: 'GET' }),
+            url: new URL('https://example.test/counter/counter/1'),
+        });
+        const res = await ALL(apiContext);
+        expect(res.status).toBe(200);
+        expect(res.headers.get('content-type')).toContain('text/event-stream');
+        // Drain the SSE body and assert all three events appear in order.
+        const text = await res.text();
+        expect(text).toContain('event: Counter');
+        expect(text).toContain('data: {"n":1}');
+        expect(text).toContain('data: {"n":2}');
+        expect(text).toContain('data: {"n":3}');
+    });
+});
+describe('createAstroHandler — abort signal', () => {
+    test("aborting the incoming request aborts the procedure handler's ctx.signal", async () => {
+        let observedSignal;
+        const aborted = new Promise((resolve) => {
+            const API = Procedures();
+            API.Create('Hang', { path: '/hang', method: 'get', schema: { returnType: Type.Object({ ok: Type.Boolean() }) } }, async (ctx) => {
+                observedSignal = ctx.signal;
+                ctx.signal?.addEventListener('abort', () => resolve(), { once: true });
+                // Wait for abort or a generous timeout.
+                await new Promise((r) => setTimeout(r, 200));
+                return { ok: true };
+            });
+            const app = new HonoAPIAppBuilder().register(API, () => ({})).build();
+            const { ALL } = createAstroHandler({ apps: app });
+            const controller = new AbortController();
+            const apiContext = fakeApiContext({
+                request: new Request('https://example.test/hang', { signal: controller.signal }),
+                url: new URL('https://example.test/hang'),
+            });
+            ALL(apiContext).catch(() => { });
+            setTimeout(() => controller.abort(), 20);
+        });
+        await aborted;
+        expect(observedSignal?.aborted).toBe(true);
+    });
+});
+//# sourceMappingURL=index.test.js.map