@sixthsummit/ship-api 0.0.0-stage → 4.1.1

package/lib/client.d.ts

@@ -0,0 +1,139 @@
+/**
+ * Typed client export — `@sixthsummit/ship-api/client`.
+ *
+ * The load-bearing subpath for the v4 cross-framework contract: schema
+ * changes propagate through TypeScript types end-to-end (Drizzle table →
+ * `drizzle-zod` schema → Hono route with `zValidator` → `c.req.valid()`
+ * → `hc<ShipApiClient>()` typed client) with **no codegen step**.
+ *
+ * Why a dedicated subpath: consumers (ShipAngular web, React Native +
+ * Expo mobile, internal microservices) only need `hono/client`'s tiny
+ * runtime — pulling the full framework barrel would drag in pino /
+ * BullMQ / OpenTelemetry / Drizzle / pg, which the client side neither
+ * needs nor can run (Hono client is universal; the framework runtime is
+ * Node-only). This file re-exports `hc` + the types `hc()` consumers
+ * actually use, so the dependency graph stays narrow.
+ *
+ * # Consumer pattern
+ *
+ * The consumer's app file pins the typed client by aliasing `typeof app`:
+ *
+ * ```ts
+ * // src/app.ts (server)
+ * import { createApp } from "@sixthsummit/ship-api";
+ * const app = createApp();
+ * // …register module routes…
+ * export type ShipApiClient = typeof app;
+ * export { app };
+ * ```
+ *
+ * The web / mobile / microservice consumer imports the type only — no
+ * runtime cost — and instantiates `hc<ShipApiClient>()`:
+ *
+ * ```ts
+ * // src/api.ts (client)
+ * import { hc, type InferRequestType, type InferResponseType }
+ *   from "@sixthsummit/ship-api/client";
+ * import type { ShipApiClient } from "@my-org/api/app";
+ *
+ * export const api = hc<ShipApiClient>(import.meta.env.VITE_API_BASE_URL, {
+ *   init: { credentials: "include" },     // forward auth cookies
+ * });
+ *
+ * const me = await api.me.$get();
+ * if (me.ok) {
+ *   const account = await me.json();      // typed end-to-end
+ * }
+ * ```
+ *
+ * # Why not export a fixed `ShipApiClient` from the framework
+ *
+ * The framework registers no application routes itself — `createApp()`
+ * returns an empty `Hono<AppEnv>`; modules add the routes the consumer
+ * cares about. A framework-side `ShipApiClient` type would describe the
+ * framework's own routes (none), not the consumer's. The consumer aliases
+ * `typeof app` after their modules register, so the type reflects exactly
+ * the routes the consumer's app exposes.
+ *
+ * # Type-preservation note (sub-apps, mounted at root)
+ *
+ * Hono's RPC client typing flows through the chained return values of
+ * `app.METHOD(...)`. Each module builds its own bounded chain on a fresh
+ * `createModuleApp("name")` and the consumer mounts every module onto the
+ * root with `root.route("/", subApp)` — modules keep their **absolute**
+ * paths, so the client shape and the route registry are identical to a
+ * single flat app:
+ *
+ * ```ts
+ * const root = createApp({ cors });
+ * registerErrorHandlers(root);          // root owns cross-cutting concerns
+ * root.use("*", httpLogger());
+ * const app = root
+ *   .route("/", buildAccountsApp({ service, provider }))
+ *   .route("/", buildOAuthApp({ ... }));
+ * export type ShipApiClient = typeof app;   // api.accounts.$get — flat shape
+ * ```
+ *
+ * Mounting each module as its own sub-app (rather than chaining every
+ * module's routes onto one app) keeps each TypeScript route-type
+ * instantiation bounded, so the typed client scales to many modules
+ * without `tsc` blowing its instantiation budget.
+ *
+ * Module route functions still return the chained app AND stay generic
+ * over Hono's schema parameter — `.get()`/`.post()` resolve on the
+ * parameter's declared type, so a plain `(app: Hono<AppEnv>)` signature
+ * widens an already-chained app and erases every previously registered
+ * route from the client type (as does `<T extends Hono<AppEnv>>`, which
+ * resolves the methods on the constraint):
+ *
+ * ```ts
+ * export const meRoutes = <S extends Schema>(app: Hono<AppEnv, S>) =>
+ *   app.get("/me", requireAuth(), handler);
+ * // returns Hono<AppEnv, S & {me route}> — types accumulate per module
+ *
+ * export const buildMeApp = () => meRoutes(createModuleApp("me"));
+ * ```
+ */
+export { type ApplyGlobalResponse, type ClientRequest, type ClientRequestOptions, type ClientResponse, DetailedError, type Fetch, hc, type InferRequestType, type InferResponseType, type PickResponseByStatusCode, parseResponse, } from "hono/client";
+/**
+ * Optional helper alias — for consumers who want a single named type to
+ * pass around their codebase. Equivalent to `ReturnType<typeof hc<TApp>>`
+ * but without the generic instantiation noise.
+ *
+ * ```ts
+ * import type { ShipApiClient as InferShipApiClient }
+ *   from "@sixthsummit/ship-api/client";
+ * import type { ShipApiClient } from "@my-org/api/app";
+ *
+ * export type Api = InferShipApiClient<ShipApiClient>;
+ * ```
+ *
+ * Type-only alias — costs zero bundle bytes.
+ */
+export type ShipApiClient<TApp extends import("hono").Hono<any, any, any>> = ReturnType<typeof import("hono/client").hc<TApp>>;
+/**
+ * `hc()` client narrowed to **success-status** responses (200 | 201) only.
+ *
+ * ShipAPI shapes every error response centrally — `registerErrorHandlers(app)`
+ * turns the AppError taxonomy into a uniform JSON envelope, and the typed
+ * client's custom `fetch` handles non-2xx (401 refresh/retry) before your
+ * code sees the response. When errors are handled centrally like this, the
+ * client doesn't need each route's error-body union; narrowing to the success
+ * status simplifies callsite types (`await res.json()` is the 200 body, no
+ * `res.ok` discriminator needed) and trims the per-route type the client
+ * carries:
+ *
+ * ```ts
+ * import { hc, type ShipApiSuccessClient } from "@sixthsummit/ship-api/client";
+ * import type { ShipApiClient as App } from "@my-org/api";
+ *
+ * // success-only — drops 4xx/5xx response shapes from the client type:
+ * const api: ShipApiSuccessClient<App> = hc(BASE_URL, { init: { credentials: "include" } });
+ * const account = await (await api.accounts[":id"].$get({ param: { id } })).json();
+ * ```
+ *
+ * Reach for the plain `hc<App>()` form only on the rare route where you need
+ * to read a typed error body. Type-only alias — costs zero bundle bytes.
+ */
+export type ShipApiSuccessClient<TApp extends import("hono").Hono<any, any, any>> = ReturnType<typeof import("hono/client").hc<import("hono/client").PickResponseByStatusCode<TApp, 200 | 201>>>;
+//# sourceMappingURL=client.d.ts.map

package/lib/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+FG;AAEH,OAAO,EACL,KAAK,mBAAmB,EACxB,KAAK,aAAa,EAClB,KAAK,oBAAoB,EACzB,KAAK,cAAc,EACnB,aAAa,EACb,KAAK,KAAK,EACV,EAAE,EACF,KAAK,gBAAgB,EACrB,KAAK,iBAAiB,EACtB,KAAK,wBAAwB,EAC7B,aAAa,GACd,MAAM,aAAa,CAAC;AAErB;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,aAAa,CAAC,IAAI,SAAS,OAAO,MAAM,EAAE,IAAI,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,IAAI,UAAU,CACrF,cAAc,aAAa,EAAE,EAAE,CAAC,IAAI,CAAC,CACtC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,MAAM,oBAAoB,CAAC,IAAI,SAAS,OAAO,MAAM,EAAE,IAAI,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,IAAI,UAAU,CAC5F,cAAc,aAAa,EAAE,EAAE,CAAC,OAAO,aAAa,EAAE,wBAAwB,CAAC,IAAI,EAAE,GAAG,GAAG,GAAG,CAAC,CAAC,CACjG,CAAC"}

package/lib/client.js

@@ -0,0 +1,98 @@
+/**
+ * Typed client export — `@sixthsummit/ship-api/client`.
+ *
+ * The load-bearing subpath for the v4 cross-framework contract: schema
+ * changes propagate through TypeScript types end-to-end (Drizzle table →
+ * `drizzle-zod` schema → Hono route with `zValidator` → `c.req.valid()`
+ * → `hc<ShipApiClient>()` typed client) with **no codegen step**.
+ *
+ * Why a dedicated subpath: consumers (ShipAngular web, React Native +
+ * Expo mobile, internal microservices) only need `hono/client`'s tiny
+ * runtime — pulling the full framework barrel would drag in pino /
+ * BullMQ / OpenTelemetry / Drizzle / pg, which the client side neither
+ * needs nor can run (Hono client is universal; the framework runtime is
+ * Node-only). This file re-exports `hc` + the types `hc()` consumers
+ * actually use, so the dependency graph stays narrow.
+ *
+ * # Consumer pattern
+ *
+ * The consumer's app file pins the typed client by aliasing `typeof app`:
+ *
+ * ```ts
+ * // src/app.ts (server)
+ * import { createApp } from "@sixthsummit/ship-api";
+ * const app = createApp();
+ * // …register module routes…
+ * export type ShipApiClient = typeof app;
+ * export { app };
+ * ```
+ *
+ * The web / mobile / microservice consumer imports the type only — no
+ * runtime cost — and instantiates `hc<ShipApiClient>()`:
+ *
+ * ```ts
+ * // src/api.ts (client)
+ * import { hc, type InferRequestType, type InferResponseType }
+ *   from "@sixthsummit/ship-api/client";
+ * import type { ShipApiClient } from "@my-org/api/app";
+ *
+ * export const api = hc<ShipApiClient>(import.meta.env.VITE_API_BASE_URL, {
+ *   init: { credentials: "include" },     // forward auth cookies
+ * });
+ *
+ * const me = await api.me.$get();
+ * if (me.ok) {
+ *   const account = await me.json();      // typed end-to-end
+ * }
+ * ```
+ *
+ * # Why not export a fixed `ShipApiClient` from the framework
+ *
+ * The framework registers no application routes itself — `createApp()`
+ * returns an empty `Hono<AppEnv>`; modules add the routes the consumer
+ * cares about. A framework-side `ShipApiClient` type would describe the
+ * framework's own routes (none), not the consumer's. The consumer aliases
+ * `typeof app` after their modules register, so the type reflects exactly
+ * the routes the consumer's app exposes.
+ *
+ * # Type-preservation note (sub-apps, mounted at root)
+ *
+ * Hono's RPC client typing flows through the chained return values of
+ * `app.METHOD(...)`. Each module builds its own bounded chain on a fresh
+ * `createModuleApp("name")` and the consumer mounts every module onto the
+ * root with `root.route("/", subApp)` — modules keep their **absolute**
+ * paths, so the client shape and the route registry are identical to a
+ * single flat app:
+ *
+ * ```ts
+ * const root = createApp({ cors });
+ * registerErrorHandlers(root);          // root owns cross-cutting concerns
+ * root.use("*", httpLogger());
+ * const app = root
+ *   .route("/", buildAccountsApp({ service, provider }))
+ *   .route("/", buildOAuthApp({ ... }));
+ * export type ShipApiClient = typeof app;   // api.accounts.$get — flat shape
+ * ```
+ *
+ * Mounting each module as its own sub-app (rather than chaining every
+ * module's routes onto one app) keeps each TypeScript route-type
+ * instantiation bounded, so the typed client scales to many modules
+ * without `tsc` blowing its instantiation budget.
+ *
+ * Module route functions still return the chained app AND stay generic
+ * over Hono's schema parameter — `.get()`/`.post()` resolve on the
+ * parameter's declared type, so a plain `(app: Hono<AppEnv>)` signature
+ * widens an already-chained app and erases every previously registered
+ * route from the client type (as does `<T extends Hono<AppEnv>>`, which
+ * resolves the methods on the constraint):
+ *
+ * ```ts
+ * export const meRoutes = <S extends Schema>(app: Hono<AppEnv, S>) =>
+ *   app.get("/me", requireAuth(), handler);
+ * // returns Hono<AppEnv, S & {me route}> — types accumulate per module
+ *
+ * export const buildMeApp = () => meRoutes(createModuleApp("me"));
+ * ```
+ */
+export { DetailedError, hc, parseResponse, } from "hono/client";
+//# sourceMappingURL=client.js.map

package/lib/client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.js","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+FG;AAEH,OAAO,EAKL,aAAa,EAEb,EAAE,EAIF,aAAa,GACd,MAAM,aAAa,CAAC"}

package/lib/contract/application.d.ts

@@ -0,0 +1,3 @@
+/** @deprecated Import contract application types from `@sixthsummit/ship-contract/application`. */
+export type * from "@sixthsummit/ship-contract/application";
+//# sourceMappingURL=application.d.ts.map

package/lib/contract/application.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"application.d.ts","sourceRoot":"","sources":["../../src/contract/application.ts"],"names":[],"mappings":"AAAA,mGAAmG;AACnG,mBAAmB,wCAAwC,CAAC"}

package/lib/contract/application.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=application.js.map

package/lib/contract/application.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"application.js","sourceRoot":"","sources":["../../src/contract/application.ts"],"names":[],"mappings":""}

package/lib/contract/client.d.ts

@@ -0,0 +1,3 @@
+/** @deprecated Import the browser client from `@sixthsummit/ship-contract/client`. */
+export * from "@sixthsummit/ship-contract/client";
+//# sourceMappingURL=client.d.ts.map

package/lib/contract/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/contract/client.ts"],"names":[],"mappings":"AAAA,sFAAsF;AACtF,cAAc,mCAAmC,CAAC"}

package/lib/contract/client.js

@@ -0,0 +1,3 @@
+/** @deprecated Import the browser client from `@sixthsummit/ship-contract/client`. */
+export * from "@sixthsummit/ship-contract/client";
+//# sourceMappingURL=client.js.map

package/lib/contract/client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.js","sourceRoot":"","sources":["../../src/contract/client.ts"],"names":[],"mappings":"AAAA,sFAAsF;AACtF,cAAc,mCAAmC,CAAC"}

package/lib/contract/index.d.ts

@@ -0,0 +1,3 @@
+/** @deprecated Install and import `@sixthsummit/ship-contract`. */
+export * from "@sixthsummit/ship-contract";
+//# sourceMappingURL=index.d.ts.map

package/lib/contract/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/contract/index.ts"],"names":[],"mappings":"AAAA,mEAAmE;AACnE,cAAc,4BAA4B,CAAC"}

package/lib/contract/index.js

@@ -0,0 +1,3 @@
+/** @deprecated Install and import `@sixthsummit/ship-contract`. */
+export * from "@sixthsummit/ship-contract";
+//# sourceMappingURL=index.js.map

package/lib/contract/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/contract/index.ts"],"names":[],"mappings":"AAAA,mEAAmE;AACnE,cAAc,4BAA4B,CAAC"}

package/lib/contract/manifest.d.ts

@@ -0,0 +1,3 @@
+/** @deprecated Import manifest types from `@sixthsummit/ship-contract/manifest`. */
+export type * from "@sixthsummit/ship-contract/manifest";
+//# sourceMappingURL=manifest.d.ts.map

package/lib/contract/manifest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manifest.d.ts","sourceRoot":"","sources":["../../src/contract/manifest.ts"],"names":[],"mappings":"AAAA,oFAAoF;AACpF,mBAAmB,qCAAqC,CAAC"}

package/lib/contract/manifest.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=manifest.js.map

package/lib/contract/manifest.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"manifest.js","sourceRoot":"","sources":["../../src/contract/manifest.ts"],"names":[],"mappings":""}

package/lib/contract/openapi.d.ts

@@ -0,0 +1,3 @@
+/** @deprecated Import OpenAPI projection from `@sixthsummit/ship-contract/openapi`. */
+export * from "@sixthsummit/ship-contract/openapi";
+//# sourceMappingURL=openapi.d.ts.map

package/lib/contract/openapi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openapi.d.ts","sourceRoot":"","sources":["../../src/contract/openapi.ts"],"names":[],"mappings":"AAAA,uFAAuF;AACvF,cAAc,oCAAoC,CAAC"}

package/lib/contract/openapi.js

@@ -0,0 +1,3 @@
+/** @deprecated Import OpenAPI projection from `@sixthsummit/ship-contract/openapi`. */
+export * from "@sixthsummit/ship-contract/openapi";
+//# sourceMappingURL=openapi.js.map

package/lib/contract/openapi.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"openapi.js","sourceRoot":"","sources":["../../src/contract/openapi.ts"],"names":[],"mappings":"AAAA,uFAAuF;AACvF,cAAc,oCAAoC,CAAC"}

package/lib/contract/project.d.ts

@@ -0,0 +1,3 @@
+/** @deprecated Import contract projection from `@sixthsummit/ship-contract/project`. */
+export * from "@sixthsummit/ship-contract/project";
+//# sourceMappingURL=project.d.ts.map

package/lib/contract/project.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project.d.ts","sourceRoot":"","sources":["../../src/contract/project.ts"],"names":[],"mappings":"AAAA,wFAAwF;AACxF,cAAc,oCAAoC,CAAC"}

package/lib/contract/project.js

@@ -0,0 +1,3 @@
+/** @deprecated Import contract projection from `@sixthsummit/ship-contract/project`. */
+export * from "@sixthsummit/ship-contract/project";
+//# sourceMappingURL=project.js.map

package/lib/contract/project.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"project.js","sourceRoot":"","sources":["../../src/contract/project.ts"],"names":[],"mappings":"AAAA,wFAAwF;AACxF,cAAc,oCAAoC,CAAC"}

package/lib/contract/schema.d.ts

@@ -0,0 +1,3 @@
+/** @deprecated Import contract schemas from `@sixthsummit/ship-contract/schema`. */
+export * from "@sixthsummit/ship-contract/schema";
+//# sourceMappingURL=schema.d.ts.map

package/lib/contract/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/contract/schema.ts"],"names":[],"mappings":"AAAA,oFAAoF;AACpF,cAAc,mCAAmC,CAAC"}

package/lib/contract/schema.js

@@ -0,0 +1,3 @@
+/** @deprecated Import contract schemas from `@sixthsummit/ship-contract/schema`. */
+export * from "@sixthsummit/ship-contract/schema";
+//# sourceMappingURL=schema.js.map

package/lib/contract/schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.js","sourceRoot":"","sources":["../../src/contract/schema.ts"],"names":[],"mappings":"AAAA,oFAAoF;AACpF,cAAc,mCAAmC,CAAC"}

package/lib/drizzle/index.d.ts

@@ -0,0 +1,3 @@
+/** @deprecated Install and import `@sixthsummit/ship-drizzle`. */
+export * from "@sixthsummit/ship-drizzle";
+//# sourceMappingURL=index.d.ts.map

package/lib/drizzle/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/drizzle/index.ts"],"names":[],"mappings":"AAAA,kEAAkE;AAClE,cAAc,2BAA2B,CAAC"}

package/lib/drizzle/index.js

@@ -0,0 +1,3 @@
+/** @deprecated Install and import `@sixthsummit/ship-drizzle`. */
+export * from "@sixthsummit/ship-drizzle";
+//# sourceMappingURL=index.js.map

package/lib/drizzle/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/drizzle/index.ts"],"names":[],"mappings":"AAAA,kEAAkE;AAClE,cAAc,2BAA2B,CAAC"}

package/lib/hono/auth.d.ts

@@ -0,0 +1,6 @@
+import { type HeaderCredential, type HonoAuthenticationOptions } from "@sixthsummit/ship-hono";
+import type { AuthenticatedAccount, AuthProvider } from "../app/auth/AuthProvider.js";
+export * from "@sixthsummit/ship-hono";
+/** @deprecated Migration bridge for the monolithic v4 AuthProvider contract. */
+export declare function honoAuthProvider<TAccount extends AuthenticatedAccount>(provider: AuthProvider<TAccount>): HonoAuthenticationOptions<HeaderCredential>;
+//# sourceMappingURL=auth.d.ts.map

package/lib/hono/auth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth.d.ts","sourceRoot":"","sources":["../../src/hono/auth.ts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,gBAAgB,EACrB,KAAK,yBAAyB,EAE/B,MAAM,wBAAwB,CAAC;AAChC,OAAO,KAAK,EAAE,oBAAoB,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAEtF,cAAc,wBAAwB,CAAC;AAEvC,gFAAgF;AAChF,wBAAgB,gBAAgB,CAAC,QAAQ,SAAS,oBAAoB,EACpE,QAAQ,EAAE,YAAY,CAAC,QAAQ,CAAC,GAC/B,yBAAyB,CAAC,gBAAgB,CAAC,CAyC7C"}

package/lib/hono/auth.js

@@ -0,0 +1,54 @@
+import { defineActorResolver, operationActor } from "@sixthsummit/ship-core";
+import { requestHeadersCredential, } from "@sixthsummit/ship-hono";
+export * from "@sixthsummit/ship-hono";
+/** @deprecated Migration bridge for the monolithic v4 AuthProvider contract. */
+export function honoAuthProvider(provider) {
+    const actors = defineActorResolver({
+        id: `v4.${normalizeResolverId(provider.name)}`,
+        resolve: async ({ credential, operation }) => {
+            try {
+                const verification = await provider.verify({ headers: credential ?? {} });
+                if (!verification.ok) {
+                    if (verification.reason === "missing-token")
+                        return Object.freeze({ ok: true });
+                    return Object.freeze({
+                        ok: false,
+                        reason: verification.reason === "provider-error"
+                            ? "unavailable"
+                            : "invalid-credential",
+                    });
+                }
+                const account = await provider.resolve(verification.claims);
+                if (account === null) {
+                    return provider.onUnknownAccount === "next"
+                        ? Object.freeze({ ok: true })
+                        : Object.freeze({ ok: false, reason: "forbidden" });
+                }
+                const granted = [];
+                if (operation.access.kind === "permissions" && account.hasPermission) {
+                    for (const permission of operation.access.permissions) {
+                        if (await account.hasPermission(permission))
+                            granted.push(permission);
+                    }
+                }
+                return Object.freeze({
+                    ok: true,
+                    actor: operationActor({ id: account.id, permissions: granted }),
+                });
+            }
+            catch {
+                return Object.freeze({ ok: false, reason: "unavailable" });
+            }
+        },
+    });
+    return Object.freeze({ credentials: requestHeadersCredential(), actors });
+}
+function normalizeResolverId(value) {
+    const normalized = value
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9-]+/gu, "-")
+        .replace(/^-+|-+$/gu, "");
+    return normalized.length > 0 && /^[a-z]/u.test(normalized) ? normalized : "provider";
+}
+//# sourceMappingURL=auth.js.map

package/lib/hono/auth.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth.js","sourceRoot":"","sources":["../../src/hono/auth.ts"],"names":[],"mappings":"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"}

package/lib/hono/index.d.ts

@@ -0,0 +1,4 @@
+/** @deprecated Import the redesign HTTP adapter from `@sixthsummit/ship-hono`. */
+export * from "@sixthsummit/ship-hono";
+export { honoAuthProvider } from "./auth.js";
+//# sourceMappingURL=index.d.ts.map

package/lib/hono/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/hono/index.ts"],"names":[],"mappings":"AAAA,kFAAkF;AAClF,cAAc,wBAAwB,CAAC;AACvC,OAAO,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC"}

package/lib/hono/index.js

@@ -0,0 +1,4 @@
+/** @deprecated Import the redesign HTTP adapter from `@sixthsummit/ship-hono`. */
+export * from "@sixthsummit/ship-hono";
+export { honoAuthProvider } from "./auth.js";
+//# sourceMappingURL=index.js.map

package/lib/hono/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/hono/index.ts"],"names":[],"mappings":"AAAA,kFAAkF;AAClF,cAAc,wBAAwB,CAAC;AACvC,OAAO,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC"}

package/lib/http/app/createApp.d.ts

@@ -0,0 +1,132 @@
+import { type Context, type Env, Hono } from "hono";
+import { type RouteRegistry } from "../../app/registry/routes.js";
+import { type RegisterHealthRoutesOptions } from "./health.js";
+/**
+ * The framework's standard `Hono.Env` shape — what `c.get(...)` is keyed by.
+ * Consumers extend this in their own `AppEnv` type if they want richer
+ * variables (e.g., a typed `db` set by an init middleware).
+ */
+export interface AppEnvVariables {
+    requestId?: string;
+    /** Authenticated account, set by `requireAuth`. Type is widened to keep the
+     *  framework agnostic of the resolved account shape. */
+    user?: unknown;
+    /** Per-request scoped logger (child of the framework `logger`). */
+    logger?: unknown;
+}
+export interface AppEnv extends Env {
+    Variables: AppEnvVariables;
+}
+export interface CorsOptions {
+    /**
+     * Allowed origins. Accepts a single origin string, an explicit
+     * allowlist, or a per-request resolver that returns the matched
+     * origin (or `null`/`undefined` to deny).
+     *
+     * `"*"` (wildcard) is permitted **only** when `credentials !== true` —
+     * the wildcard + credentials combination is rejected by browsers
+     * per the CORS spec and is the single most common framework
+     * misconfig in production. We throw at config time so the failure
+     * mode is "boot error" not "subtle CSRF defense bypass at runtime."
+     */
+    origin: string | readonly string[] | ((origin: string, c: Context) => string | null | undefined);
+    /** Methods allowed on cross-origin requests. */
+    allowMethods?: readonly string[];
+    /** Request headers permitted via the `Access-Control-Allow-Headers` response. */
+    allowHeaders?: readonly string[];
+    /** Response headers the browser exposes to client JS. */
+    exposeHeaders?: readonly string[];
+    /** Preflight cache duration in seconds (`Access-Control-Max-Age`). */
+    maxAge?: number;
+    /**
+     * Whether to allow credentials (cookies, Authorization headers). For
+     * cookie-auth flows in this framework — the default — this must be
+     * `true` *and* `origin` must be an explicit allowlist (not `"*"`).
+     */
+    credentials?: boolean;
+}
+export interface CreateAppOptions {
+    /**
+     * Inject an alternative registry (tests). Defaults to the framework-wide
+     * `routeRegistry` singleton.
+     */
+    registry?: RouteRegistry;
+    /**
+     * CORS configuration. When supplied, `hono/cors` is wired as global
+     * middleware ahead of any route registration. The framework rejects
+     * the wildcard + credentials combination at config time — that
+     * pairing is spec-invalid and silently bypasses CSRF defenses if
+     * the browser ever honors it (some non-browser HTTP clients do).
+     *
+     * For a typical multi-tenant SaaS:
+     *   `cors: { origin: env.CORS_ORIGINS, credentials: true }`
+     * where `CORS_ORIGINS` is an env-driven `https://app.example.com,
+     * https://admin.example.com` allowlist.
+     */
+    cors?: CorsOptions;
+    /**
+     * Health routes. By default `createApp` mounts unauthenticated
+     * `GET /livez` and `GET /readyz` (backed by the framework-wide
+     * `healthCheckRegistry`) before anything else is registered, so consumer
+     * middleware added afterwards — `requireAuth`, rate limiting, `httpLogger`
+     * — never runs for them. They are not added to the route registry.
+     *
+     * Pass an object to configure them (`prefix`, `readyzTimeoutMs`,
+     * `registry` — the same options as `registerHealthRoutes`), or `false` to
+     * mount nothing and wire them yourself. Default `{}` (mounted at root,
+     * 3-second per-check timeout).
+     */
+    health?: false | RegisterHealthRoutesOptions;
+}
+/**
+ * `Hono<AppEnv>` factory with route-method interception.
+ *
+ * Every `app.get/post/put/patch/delete` call is wrapped: the wrapper walks
+ * the passed handlers, reads any framework metadata tags, pushes a
+ * `RouteEntry` to the registry, then delegates to Hono's real method.
+ *
+ * User code looks identical to plain Hono — no `defineRoute` ceremony, no
+ * decorators, no codegen. The metadata is captured invisibly.
+ *
+ * Routes registered without `validate` / `requireAuth` are still captured —
+ * just schema-less / anonymous, which is *correct*: agents see exactly what's
+ * there, including unprotected endpoints (which the `ship-reviewer` agent
+ * can flag as convention violations).
+ */
+export declare function createApp(opts?: CreateAppOptions): Hono<AppEnv>;
+export interface CreateModuleAppOptions {
+    /** Inject an alternative registry (tests). Defaults to the framework-wide
+     *  `routeRegistry` singleton — the same one `createApp` populates. */
+    registry?: RouteRegistry;
+}
+/**
+ * `Hono<AppEnv>` factory for a **module sub-app** — the building block of the
+ * v4 mount-at-root composition.
+ *
+ * A module's `defineXxxRoutes(createModuleApp("xxx"), deps)` builds its own
+ * bounded route chain on a fresh app, which the consumer mounts onto the root
+ * with `root.route("/", buildXxxApp(deps))`. Splitting each module into its
+ * own sub-app (rather than chaining every module's routes onto one app) keeps
+ * each TypeScript route-type instantiation bounded, so the `hc()` typed client
+ * scales to many modules without `tsc` blowing its instantiation budget.
+ *
+ * Identical to `createApp` except:
+ *   - it wires **no CORS** and is not meant to be the server root (global
+ *     cross-cutting middleware — `cors`, `httpLogger`, `registerErrorHandlers`
+ *     — belong on the root app the sub-app is mounted onto, never here);
+ *   - every captured `RouteEntry` is stamped with `module`, lighting up the
+ *     Module column in `/dev/routes` and the `module` filter in `list_routes`;
+ *   - `app.onError`, `app.notFound`, and global `app.use("*", …)` are
+ *     **guarded** — they throw at dev time, because a sub-app error/not-found
+ *     handler silently shadows the root's uniform AppError shape and global
+ *     sub-app middleware breaks the root-wraps-everything ordering. (Per-route
+ *     middleware — `requireAuth`/`requirePermission`/`validate` passed as route
+ *     handlers — and **path-scoped** `app.use("/x/*", …)` are still allowed.)
+ *
+ * Because module sub-apps register their **absolute** paths (`/accounts`,
+ * `/accounts/:id`) and are mounted at the root (`route("/", …)`), the registry
+ * records the same absolute paths it always has — `execute_route`,
+ * `find_route_collisions`, and `/dev/routes` need no prefix math.
+ */
+export declare function createModuleApp(moduleName: string, opts?: CreateModuleAppOptions): Hono<AppEnv>;
+//# sourceMappingURL=createApp.d.ts.map

package/lib/http/app/createApp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createApp.d.ts","sourceRoot":"","sources":["../../../src/http/app/createApp.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,OAAO,EAAE,KAAK,GAAG,EAAE,IAAI,EAA0B,MAAM,MAAM,CAAC;AAE5E,OAAO,EAGL,KAAK,aAAa,EAEnB,MAAM,8BAA8B,CAAC;AActC,OAAO,EAAE,KAAK,2BAA2B,EAAwB,MAAM,aAAa,CAAC;AAErF;;;;GAIG;AACH,MAAM,WAAW,eAAe;IAC9B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;4DACwD;IACxD,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,mEAAmE;IACnE,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,WAAW,MAAO,SAAQ,GAAG;IACjC,SAAS,EAAE,eAAe,CAAC;CAC5B;AAED,MAAM,WAAW,WAAW;IAC1B;;;;;;;;;;OAUG;IACH,MAAM,EAAE,MAAM,GAAG,SAAS,MAAM,EAAE,GAAG,CAAC,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,EAAE,OAAO,KAAK,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC,CAAC;IACjG,gDAAgD;IAChD,YAAY,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACjC,iFAAiF;IACjF,YAAY,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACjC,yDAAyD;IACzD,aAAa,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,sEAAsE;IACtE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;;OAIG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAED,MAAM,WAAW,gBAAgB;IAC/B;;;OAGG;IACH,QAAQ,CAAC,EAAE,aAAa,CAAC;IACzB;;;;;;;;;;;OAWG;IACH,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB;;;;;;;;;;;OAWG;IACH,MAAM,CAAC,EAAE,KAAK,GAAG,2BAA2B,CAAC;CAC9C;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,SAAS,CAAC,IAAI,GAAE,gBAAqB,GAAG,IAAI,CAAC,MAAM,CAAC,CAsCnE;AAED,MAAM,WAAW,sBAAsB;IACrC;0EACsE;IACtE,QAAQ,CAAC,EAAE,aAAa,CAAC;CAC1B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,eAAe,CAC7B,UAAU,EAAE,MAAM,EAClB,IAAI,GAAE,sBAA2B,GAChC,IAAI,CAAC,MAAM,CAAC,CAMd"}