@rotorsoft/act-http 1.2.1 → 1.4.0

package/dist/@types/hono/index.d.ts

@@ -0,0 +1,109 @@
+import type { Act, Actor, Schema, Schemas } from "@rotorsoft/act";
+import type { IdempotencyStore } from "@rotorsoft/act-ops/idempotency";
+import type { Context, MiddlewareHandler } from "hono";
+import { Hono } from "hono";
+import { type ActorExtractor } from "../api/index.js";
+/**
+ * Hono context variables this subpath contributes. The generic on
+ * the returned middleware threads it through so routes downstream
+ * of {@link authenticated} see `c.get("actor")` typed without a
+ * manual cast.
+ */
+export type ActMiddlewareVariables = {
+    actor: Actor;
+};
+/**
+ * Per-call options for {@link hono}. The host supplies the four
+ * seams the package can't make decisions on:
+ *
+ * - `actor` — auth resolver. Receives the Hono context, returns the
+ *   `Actor` that flows onto `c.get("actor")` for every generated
+ *   route (via an internal {@link authenticated}).
+ * - `stream` — stream-id resolver. Receives the action name, the
+ *   validated body, and the Hono context; returns the target
+ *   stream. Singleton aggregates return a constant; per-tenant
+ *   aggregates pull from headers, path, or body.
+ * - `expectedVersion` (optional) — optimistic-concurrency resolver.
+ *   Hosts typically read it from an `If-Match` header on the
+ *   request, or from the client's last-known snapshot. Returning
+ *   `undefined` skips the check for that call — handy when only
+ *   some actions are concurrency-sensitive.
+ * - `idempotency` (optional) — when set, the route honors
+ *   `Idempotency-Key` via {@link withIdempotency}. The host
+ *   supplies the `IdempotencyStore`; `keyFrom` defaults to reading
+ *   the `Idempotency-Key` header. On a duplicate claim, the route
+ *   responds `409 Conflict` — the contract intentionally doesn't
+ *   cache the original handler's result, matching the
+ *   receiver-side "ack the duplicate" semantics.
+ * - `basePath` (optional, default `"/api"`) — Hono basePath the
+ *   routes mount under.
+ */
+export type HonoOptions = {
+    readonly actor: ActorExtractor;
+    readonly stream: (action_name: string, input: unknown, c: Context) => string | Promise<string>;
+    readonly expectedVersion?: (action_name: string, input: unknown, c: Context) => number | undefined | Promise<number | undefined>;
+    readonly idempotency?: {
+        readonly store: IdempotencyStore;
+        readonly keyFrom?: (c: Context) => string | undefined;
+    };
+    readonly basePath?: string;
+};
+/**
+ * Build a Hono middleware that runs an {@link ActorExtractor} once
+ * per call and stashes the resolved {@link Actor} under
+ * `c.set("actor", ...)` so downstream routes can read it via
+ * `c.get("actor")`. The generator at {@link hono} uses this
+ * internally; it's also exported so hosts that want to compose
+ * their own route chain (logging, tracing, custom auth flavors)
+ * can wire it directly:
+ *
+ * ```ts
+ * import { Hono } from "hono";
+ * import { authenticated, type ActMiddlewareVariables } from "@rotorsoft/act-http/hono";
+ *
+ * const api = new Hono<{ Variables: ActMiddlewareVariables }>();
+ * api.use("*", authenticated((c) => resolveUserFromJwt(c)));
+ * api.get("/me", (c) => c.json(c.get("actor"))); // typed
+ * ```
+ *
+ * Errors thrown by the extractor surface as `401 Unauthorized` with
+ * the shared {@link ApiError} envelope.
+ */
+export declare function authenticated(extractor: ActorExtractor): MiddlewareHandler<{
+    Variables: ActMiddlewareVariables;
+}>;
+/**
+ * Build a typed Hono REST surface from a built `Act` instance.
+ *
+ * Walks `app.registry.actions` once and emits one
+ * `POST /actions/<actionName>` per action under the configured
+ * `basePath` (default `/api`). Each route:
+ *
+ * 1. Runs the internal {@link authenticated} middleware —
+ *    `options.actor` resolves the {@link Actor} once and stashes
+ *    it under `c.get("actor")`.
+ * 2. Validates the JSON body against the action's Zod schema via
+ *    `@hono/zod-validator`. Failures short-circuit with `422`.
+ * 3. Resolves the target stream via
+ *    `options.stream(name, input, c)`.
+ * 4. (Optionally) resolves `expectedVersion` for optimistic
+ *    concurrency.
+ * 5. (Optionally) claims the `Idempotency-Key` via
+ *    {@link withIdempotency} — responds `409` on duplicate.
+ * 6. Calls
+ *    `app.do(name, { stream, actor, expectedVersion? }, input)`.
+ * 7. Maps any thrown framework error onto the shared
+ *    {@link ApiError} envelope via {@link toApiError}, returning
+ *    the conventional HTTP status (`409` / `412` for concurrency,
+ *    `422` for validation, `400` for non-retryable, etc.).
+ *
+ * @param app A built `Act` orchestrator.
+ * @param options Auth, stream, expected-version, idempotency, and
+ *   base-path seams.
+ * @returns A Hono app covering every registered action under
+ *   `<basePath>/actions/<name>`.
+ */
+export declare function hono(app: Act<Schemas, Schemas, Schemas, Record<string, Schema>>, options: HonoOptions): Hono<{
+    Variables: ActMiddlewareVariables;
+}>;
+//# sourceMappingURL=index.d.ts.map

package/dist/@types/hono/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/hono/index.ts"],"names":[],"mappings":"AAgDA,OAAO,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAClE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAC;AACvE,OAAO,KAAK,EAAE,OAAO,EAAE,iBAAiB,EAAE,MAAM,MAAM,CAAC;AACvD,OAAO,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AAC5B,OAAO,EACL,KAAK,cAAc,EAIpB,MAAM,iBAAiB,CAAC;AAEzB;;;;;GAKG;AACH,MAAM,MAAM,sBAAsB,GAAG;IACnC,KAAK,EAAE,KAAK,CAAC;CACd,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,MAAM,WAAW,GAAG;IACxB,QAAQ,CAAC,KAAK,EAAE,cAAc,CAAC;IAC/B,QAAQ,CAAC,MAAM,EAAE,CACf,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,OAAO,EACd,CAAC,EAAE,OAAO,KACP,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAC9B,QAAQ,CAAC,eAAe,CAAC,EAAE,CACzB,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,OAAO,EACd,CAAC,EAAE,OAAO,KACP,MAAM,GAAG,SAAS,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAAC;IACtD,QAAQ,CAAC,WAAW,CAAC,EAAE;QACrB,QAAQ,CAAC,KAAK,EAAE,gBAAgB,CAAC;QACjC,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC,EAAE,OAAO,KAAK,MAAM,GAAG,SAAS,CAAC;KACvD,CAAC;IACF,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;CAC5B,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,aAAa,CAC3B,SAAS,EAAE,cAAc,GACxB,iBAAiB,CAAC;IAAE,SAAS,EAAE,sBAAsB,CAAA;CAAE,CAAC,CAe1D;AAKD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,IAAI,CAClB,GAAG,EAAE,GAAG,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,EAC3D,OAAO,EAAE,WAAW,GACnB,IAAI,CAAC;IAAE,SAAS,EAAE,sBAAsB,CAAA;CAAE,CAAC,CAyE7C"}

package/dist/@types/trpc/index.d.ts

@@ -0,0 +1,168 @@
+/**
+ * @packageDocumentation
+ * @module act-http/trpc
+ *
+ * tRPC subpath for the auto-generated API epic (#835). Walks the
+ * registry of a built `Act` once at function call and emits a typed
+ * router that exposes every registered action as a flat `mutation`,
+ * matching the shape hand-written tRPC routers in the Act ecosystem
+ * already use.
+ *
+ * Usage:
+ *
+ * ```ts
+ * import { trpc } from "@rotorsoft/act-http/trpc";
+ *
+ * const router = trpc(app, {
+ *   actor: (ctx) => ({ id: ctx.user.id, name: ctx.user.name }),
+ *   stream: (action, input, ctx) => input.stream ?? ctx.tenant,
+ * });
+ *
+ * // Client sees:
+ * //   appRouter.PressKey.mutate({ key: "5" })
+ * //   appRouter.OpenTicket.mutate({ title: "..." })
+ * ```
+ *
+ * The route shape is flat: one procedure per registered action at
+ * the top level. Action names are the unique identifiers across
+ * the registry (the framework already enforces no duplicates), so
+ * an extra namespace tier would be overhead in the common case.
+ * Pure mutations for this slice; query/projection wiring lives in
+ * a follow-up. See `libs/act-http/README.md` for the full surface
+ * walkthrough.
+ *
+ * **Actor lives on the context.** The generator wires an internal
+ * tRPC middleware that runs the host's
+ * {@link TrpcOptions.actor | actor extractor} once per call and
+ * injects the resolved {@link Actor} onto the downstream context as
+ * `ctx.actor`. Every generated mutation reads from there — auth
+ * resolves at the procedure boundary, not inside each action body,
+ * and any composed middleware (logging, tracing) sees the same
+ * `ctx.actor`. The middleware factory is also exported as
+ * {@link authenticated} for hosts that need to compose it into
+ * their own procedure chain.
+ *
+ * Composes the shared utilities at `@rotorsoft/act-http/api`:
+ * {@link ActorExtractor} for the auth seam, {@link toApiError} for
+ * the uniform error→status/code mapping, {@link withIdempotency}
+ * for `Idempotency-Key` dedup. Three transports (this one, Hono,
+ * OpenAPI) ride the same utilities so a client talking to two
+ * transports never sees two error shapes for the same framework
+ * error.
+ */
+import type { Act, Schema, Schemas } from "@rotorsoft/act";
+import type { IdempotencyStore } from "@rotorsoft/act-ops/idempotency";
+import { type ActorExtractor } from "../api/index.js";
+/**
+ * Per-call options for {@link trpc}. The host supplies the three
+ * seams the package can't make decisions on:
+ *
+ * - `actor` — auth resolver. Receives the tRPC context, returns the
+ *   `Actor` that flows onto `ctx.actor` for every generated
+ *   procedure (via an internal {@link authenticated}).
+ * - `stream` — stream-id resolver. Receives the action name, the
+ *   validated action input, and the original tRPC context; returns
+ *   the target stream. Singleton aggregates return a constant;
+ *   per-tenant aggregates pull from input or context.
+ * - `expectedVersion` (optional) — optimistic-concurrency resolver.
+ *   When set, the procedure threads the resolved value through
+ *   `target.expectedVersion` so `app.do` refuses to commit if the
+ *   stream has moved. Hosts typically read it from an `If-Match`
+ *   header on the underlying HTTP request, or pull it from the
+ *   client's last-known snapshot. Returning `undefined` skips the
+ *   check for that call — handy when only some actions are
+ *   concurrency-sensitive.
+ * - `idempotency` (optional) — when set, the procedure honors
+ *   `Idempotency-Key` via the shared
+ *   {@link withIdempotency} helper. The host supplies the
+ *   `IdempotencyStore` and a `keyFrom` extractor that reads the key
+ *   out of the tRPC context (typically a header). On a duplicate
+ *   claim, the procedure throws a `CONFLICT` `TRPCError` — the
+ *   receiver-side convention of "ack the duplicate" doesn't carry
+ *   over because the contract intentionally does not cache the
+ *   original handler's result.
+ *
+ * @template Ctx The host's tRPC context shape. Flows end-to-end —
+ *   procedures see this exact context type (plus `actor`) at
+ *   runtime.
+ */
+export type TrpcOptions<Ctx> = {
+    readonly actor: ActorExtractor;
+    readonly stream: (action_name: string, input: unknown, ctx: Ctx) => string | Promise<string>;
+    readonly expectedVersion?: (action_name: string, input: unknown, ctx: Ctx) => number | undefined | Promise<number | undefined>;
+    readonly idempotency?: {
+        readonly store: IdempotencyStore;
+        readonly keyFrom: (ctx: Ctx) => string | undefined;
+    };
+};
+/**
+ * Build a tRPC middleware that runs an {@link ActorExtractor} once
+ * per call and forwards the resolved {@link Actor} on the
+ * downstream context as `ctx.actor`. The generator at
+ * {@link trpc} uses this internally; it's also exported so hosts
+ * that want to compose their own procedure chain (logging,
+ * tracing, custom auth flavors) can wire it directly:
+ *
+ * ```ts
+ * import { initTRPC } from "@trpc/server";
+ * import { authenticated } from "@rotorsoft/act-http/trpc";
+ *
+ * type Ctx = { user?: { id: string; name: string } };
+ * const t = initTRPC.context<Ctx>().create();
+ *
+ * const authed = t.procedure.use(
+ *   authenticated((ctx) => {
+ *     if (!ctx.user) throw new Error("not authenticated");
+ *     return { id: ctx.user.id, name: ctx.user.name };
+ *   })
+ * );
+ *
+ * // Inside any procedure built off `authed`, `ctx.actor: Actor`.
+ * ```
+ *
+ * The middleware is unaware of the host's `t` instance — it returns
+ * a structurally-typed function that any tRPC `procedure.use(...)`
+ * accepts. Errors thrown by the extractor surface unchanged
+ * (typically wrap them as `TRPCError({ code: "UNAUTHORIZED" })`
+ * in the extractor body).
+ */
+export declare function authenticated(extractor: ActorExtractor): any;
+/**
+ * Build a typed tRPC router from a built `Act` instance.
+ *
+ * Walks `app.registry.actions` once and emits one flat mutation per
+ * action under `router.<actionName>`. The framework already enforces
+ * no duplicate action names across states, so a flat tier reads
+ * cleanly at the client and matches the hand-written router shape
+ * adopters already have. Each mutation:
+ *
+ * 1. Runs the internal {@link authenticated} — `options.actor`
+ *    resolves the {@link Actor} once and injects it onto
+ *    `ctx.actor`.
+ * 2. Resolves the target stream via `options.stream(name, input, ctx)`.
+ * 3. (Optionally) claims the `Idempotency-Key` via
+ *    {@link withIdempotency} — throws `CONFLICT` on duplicate.
+ * 4. Calls `app.do(name, { stream, actor: ctx.actor }, input)`.
+ * 5. Maps any thrown framework error onto a `TRPCError` via
+ *    {@link toApiError}.
+ *
+ * The returned router's procedure inputs come straight from each
+ * action's Zod schema; outputs are the framework's
+ * `Snapshot<TState, TEvents>[]` shape. Strong typing flows
+ * end-to-end via tRPC's normal inference path — the client sees
+ * `appRouter.Calculator.PressKey.mutate({ key: "5" })` as a typed
+ * call without any codegen.
+ *
+ * @template Ctx The tRPC context shape the host's runtime feeds in.
+ *   Flows through `actor`, `stream`, and `idempotency.keyFrom` so
+ *   the operator's existing context types just work. The internal
+ *   middleware augments `Ctx` with `{ actor: Actor }` on the
+ *   downstream procedure context.
+ *
+ * @param app A built `Act` orchestrator.
+ * @param options Auth, stream, and (optional) idempotency seams.
+ * @returns A tRPC router covering every registered action, grouped
+ *   by owning state.
+ */
+export declare function trpc<Ctx extends object = object>(app: Act<any, Schemas, Schemas, Record<string, Schema>>, options: TrpcOptions<Ctx>): never;
+//# sourceMappingURL=index.d.ts.map

package/dist/@types/trpc/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/trpc/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AACH,OAAO,KAAK,EAAE,GAAG,EAAS,MAAM,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAClE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAC;AAEvE,OAAO,EACL,KAAK,cAAc,EAGpB,MAAM,iBAAiB,CAAC;AAEzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,MAAM,MAAM,WAAW,CAAC,GAAG,IAAI;IAC7B,QAAQ,CAAC,KAAK,EAAE,cAAc,CAAC;IAC/B,QAAQ,CAAC,MAAM,EAAE,CACf,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,OAAO,EACd,GAAG,EAAE,GAAG,KACL,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAC9B,QAAQ,CAAC,eAAe,CAAC,EAAE,CACzB,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,OAAO,EACd,GAAG,EAAE,GAAG,KACL,MAAM,GAAG,SAAS,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAAC;IACtD,QAAQ,CAAC,WAAW,CAAC,EAAE;QACrB,QAAQ,CAAC,KAAK,EAAE,gBAAgB,CAAC;QACjC,QAAQ,CAAC,OAAO,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,MAAM,GAAG,SAAS,CAAC;KACpD,CAAC;CACH,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH,wBAAgB,aAAa,CAAC,SAAS,EAAE,cAAc,GAAG,GAAG,CAW5D;AA+CD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,wBAAgB,IAAI,CAAC,GAAG,SAAS,MAAM,GAAG,MAAM,EAE9C,GAAG,EAAE,GAAG,CAAC,GAAG,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,EACvD,OAAO,EAAE,WAAW,CAAC,GAAG,CAAC,SAkE1B"}

package/dist/api/index.js

@@ -1,59 +1,8 @@
-// src/api/errors.ts
 import {
-  ConcurrencyError,
-  InvariantError,
-  NonRetryableError,
-  StreamClosedError,
-  ValidationError
-} from "@rotorsoft/act";
-var ERROR_MAP = {
-  ValidationError: { status: 422, code: "VALIDATION" },
-  InvariantError: { status: 409, code: "INVARIANT" },
-  ConcurrencyError: { status: 412, code: "CONCURRENCY" },
-  StreamClosedError: { status: 410, code: "STREAM_CLOSED" },
-  NonRetryableError: { status: 400, code: "NON_RETRYABLE" }
-};
-var lookup_known = (err) => {
-  if (err instanceof ValidationError) return { name: "ValidationError" };
-  if (err instanceof InvariantError) return { name: "InvariantError" };
-  if (err instanceof ConcurrencyError) return { name: "ConcurrencyError" };
-  if (err instanceof StreamClosedError) return { name: "StreamClosedError" };
-  if (err instanceof NonRetryableError) return { name: "NonRetryableError" };
-  return null;
-};
-function toApiError(err) {
-  const known = lookup_known(err);
-  if (known) {
-    const entry = ERROR_MAP[known.name];
-    return {
-      status: entry.status,
-      body: {
-        error: known.name,
-        detail: err.message,
-        code: entry.code
-      }
-    };
-  }
-  if (err instanceof Error) {
-    return {
-      status: 500,
-      body: { error: "InternalError", detail: err.message, code: "INTERNAL" }
-    };
-  }
-  return {
-    status: 500,
-    body: { error: "InternalError", code: "INTERNAL" }
-  };
-}
-
-// src/api/idempotency.ts
-async function withIdempotency(store, key, handler) {
-  const fresh = await store.claim(key);
-  if (!fresh) {
-    return { deduped: true };
-  }
-  return { deduped: false, result: await handler() };
-}
+  ERROR_MAP,
+  toApiError,
+  withIdempotency
+} from "../chunk-Z6FVXDDU.js";
 export {
   ERROR_MAP,
   toApiError,

package/dist/api/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/api/errors.ts","../../src/api/idempotency.ts"],"sourcesContent":["import {\n  ConcurrencyError,\n  InvariantError,\n  NonRetryableError,\n  StreamClosedError,\n  ValidationError,\n} from \"@rotorsoft/act\";\n\n/**\n * Uniform error envelope shipped over the wire by every act-http\n * transport. Hosts get the same shape from REST, tRPC, and OpenAPI —\n * a client that talks to two transports doesn't have to invent two\n * error parsers.\n *\n * - `error` — the framework error name (`\"ValidationError\"`,\n *   `\"InvariantError\"`, …). Stable identifier, safe to switch on.\n * - `detail` — the framework's message text. Human-readable; not\n *   parsed by clients.\n * - `code` — a machine-readable status code from {@link ERROR_MAP}\n *   for clients that prefer enum-style branching over name strings.\n */\nexport type ApiError = {\n  error: string;\n  detail?: string;\n  code?: string;\n};\n\n/**\n * Status + code pair for one known framework error.\n */\nexport type ErrorMapEntry = {\n  status: number;\n  code: string;\n};\n\n/**\n * The single table that maps framework error types to HTTP status\n * codes and machine-readable codes. One table, three consumers\n * (Hono, tRPC, OpenAPI) — cross-transport consistency by\n * construction.\n *\n * Operators wanting different mappings wrap the generated transport\n * rather than mutating this — the consistency is the load-bearing\n * property, not the specific status codes.\n */\nexport const ERROR_MAP = {\n  ValidationError: { status: 422, code: \"VALIDATION\" },\n  InvariantError: { status: 409, code: \"INVARIANT\" },\n  ConcurrencyError: { status: 412, code: \"CONCURRENCY\" },\n  StreamClosedError: { status: 410, code: \"STREAM_CLOSED\" },\n  NonRetryableError: { status: 400, code: \"NON_RETRYABLE\" },\n} as const satisfies Record<string, ErrorMapEntry>;\n\nconst lookup_known = (\n  err: unknown\n): { name: keyof typeof ERROR_MAP } | null => {\n  if (err instanceof ValidationError) return { name: \"ValidationError\" };\n  if (err instanceof InvariantError) return { name: \"InvariantError\" };\n  if (err instanceof ConcurrencyError) return { name: \"ConcurrencyError\" };\n  if (err instanceof StreamClosedError) return { name: \"StreamClosedError\" };\n  if (err instanceof NonRetryableError) return { name: \"NonRetryableError\" };\n  return null;\n};\n\n/**\n * Translate an unknown thrown value into the canonical\n * {@link ApiError} envelope plus HTTP status. Each transport's error\n * boundary calls this once and forwards the result to the wire.\n *\n * Known framework errors map per {@link ERROR_MAP}. Everything else\n * surfaces as a 500 with `code: \"INTERNAL\"`; the `detail` field is\n * populated when the throw was an `Error` instance, omitted\n * otherwise (a thrown string or object doesn't get to leak its\n * payload to the client).\n */\nexport function toApiError(err: unknown): { status: number; body: ApiError } {\n  const known = lookup_known(err);\n  if (known) {\n    const entry = ERROR_MAP[known.name];\n    return {\n      status: entry.status,\n      body: {\n        error: known.name,\n        detail: (err as Error).message,\n        code: entry.code,\n      },\n    };\n  }\n  if (err instanceof Error) {\n    return {\n      status: 500,\n      body: { error: \"InternalError\", detail: err.message, code: \"INTERNAL\" },\n    };\n  }\n  return {\n    status: 500,\n    body: { error: \"InternalError\", code: \"INTERNAL\" },\n  };\n}\n","import type { IdempotencyStore } from \"@rotorsoft/act-ops/idempotency\";\n\n/**\n * Result of a {@link withIdempotency} call.\n *\n * - `{ deduped: false, result }` — the claim was fresh; the handler\n *   ran and produced `result`.\n * - `{ deduped: true }` — the claim was already taken; the handler\n *   was *not* invoked. The caller decides how to respond (typically\n *   a 2xx with no body, matching the receiver-side convention).\n *\n * Note: the contract does not cache the previous response. A\n * duplicate call returns the deduped marker only — replaying the\n * original handler's output would require a response-caching\n * adapter, which is out of scope here. The receiver-side convention\n * (and the convention the generated transports follow) is \"ack the\n * duplicate; do nothing else.\"\n */\nexport type IdempotencyResult<T> =\n  | { deduped: false; result: T }\n  | { deduped: true };\n\n/**\n * Wrap an action handler so the framework honors `Idempotency-Key`\n * dedup. Acquires the key via {@link IdempotencyStore.claim}, runs\n * the handler exactly when the claim was fresh, and skips the\n * handler entirely on a duplicate.\n *\n * Reuses the contract `@rotorsoft/act-ops/idempotency` already\n * defines for the receiver-side `Idempotency-Key` story. A single\n * `IdempotencyStore` implementation covers both halves of the \"Act\n * over the wire\" surface — receiver and generated API.\n */\nexport async function withIdempotency<T>(\n  store: IdempotencyStore,\n  key: string,\n  handler: () => Promise<T>\n): Promise<IdempotencyResult<T>> {\n  const fresh = await store.claim(key);\n  if (!fresh) {\n    return { deduped: true };\n  }\n  return { deduped: false, result: await handler() };\n}\n"],"mappings":";AAAA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAuCA,IAAM,YAAY;AAAA,EACvB,iBAAiB,EAAE,QAAQ,KAAK,MAAM,aAAa;AAAA,EACnD,gBAAgB,EAAE,QAAQ,KAAK,MAAM,YAAY;AAAA,EACjD,kBAAkB,EAAE,QAAQ,KAAK,MAAM,cAAc;AAAA,EACrD,mBAAmB,EAAE,QAAQ,KAAK,MAAM,gBAAgB;AAAA,EACxD,mBAAmB,EAAE,QAAQ,KAAK,MAAM,gBAAgB;AAC1D;AAEA,IAAM,eAAe,CACnB,QAC4C;AAC5C,MAAI,eAAe,gBAAiB,QAAO,EAAE,MAAM,kBAAkB;AACrE,MAAI,eAAe,eAAgB,QAAO,EAAE,MAAM,iBAAiB;AACnE,MAAI,eAAe,iBAAkB,QAAO,EAAE,MAAM,mBAAmB;AACvE,MAAI,eAAe,kBAAmB,QAAO,EAAE,MAAM,oBAAoB;AACzE,MAAI,eAAe,kBAAmB,QAAO,EAAE,MAAM,oBAAoB;AACzE,SAAO;AACT;AAaO,SAAS,WAAW,KAAkD;AAC3E,QAAM,QAAQ,aAAa,GAAG;AAC9B,MAAI,OAAO;AACT,UAAM,QAAQ,UAAU,MAAM,IAAI;AAClC,WAAO;AAAA,MACL,QAAQ,MAAM;AAAA,MACd,MAAM;AAAA,QACJ,OAAO,MAAM;AAAA,QACb,QAAS,IAAc;AAAA,QACvB,MAAM,MAAM;AAAA,MACd;AAAA,IACF;AAAA,EACF;AACA,MAAI,eAAe,OAAO;AACxB,WAAO;AAAA,MACL,QAAQ;AAAA,MACR,MAAM,EAAE,OAAO,iBAAiB,QAAQ,IAAI,SAAS,MAAM,WAAW;AAAA,IACxE;AAAA,EACF;AACA,SAAO;AAAA,IACL,QAAQ;AAAA,IACR,MAAM,EAAE,OAAO,iBAAiB,MAAM,WAAW;AAAA,EACnD;AACF;;;ACjEA,eAAsB,gBACpB,OACA,KACA,SAC+B;AAC/B,QAAM,QAAQ,MAAM,MAAM,MAAM,GAAG;AACnC,MAAI,CAAC,OAAO;AACV,WAAO,EAAE,SAAS,KAAK;AAAA,EACzB;AACA,SAAO,EAAE,SAAS,OAAO,QAAQ,MAAM,QAAQ,EAAE;AACnD;","names":[]}
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/chunk-Z6FVXDDU.js

@@ -0,0 +1,63 @@
+// src/api/errors.ts
+import {
+  ConcurrencyError,
+  InvariantError,
+  NonRetryableError,
+  StreamClosedError,
+  ValidationError
+} from "@rotorsoft/act";
+var ERROR_MAP = {
+  ValidationError: { status: 422, code: "VALIDATION" },
+  InvariantError: { status: 409, code: "INVARIANT" },
+  ConcurrencyError: { status: 412, code: "CONCURRENCY" },
+  StreamClosedError: { status: 410, code: "STREAM_CLOSED" },
+  NonRetryableError: { status: 400, code: "NON_RETRYABLE" }
+};
+var lookup_known = (err) => {
+  if (err instanceof ValidationError) return { name: "ValidationError" };
+  if (err instanceof InvariantError) return { name: "InvariantError" };
+  if (err instanceof ConcurrencyError) return { name: "ConcurrencyError" };
+  if (err instanceof StreamClosedError) return { name: "StreamClosedError" };
+  if (err instanceof NonRetryableError) return { name: "NonRetryableError" };
+  return null;
+};
+function toApiError(err) {
+  const known = lookup_known(err);
+  if (known) {
+    const entry = ERROR_MAP[known.name];
+    return {
+      status: entry.status,
+      body: {
+        error: known.name,
+        detail: err.message,
+        code: entry.code
+      }
+    };
+  }
+  if (err instanceof Error) {
+    return {
+      status: 500,
+      body: { error: "InternalError", detail: err.message, code: "INTERNAL" }
+    };
+  }
+  return {
+    status: 500,
+    body: { error: "InternalError", code: "INTERNAL" }
+  };
+}
+
+// src/api/idempotency.ts
+async function withIdempotency(store, key, handler) {
+  const fresh = await store.claim(key);
+  if (!fresh) {
+    return { deduped: true };
+  }
+  return { deduped: false, result: await handler() };
+}
+
+export {
+  ERROR_MAP,
+  toApiError,
+  withIdempotency
+};
+//# sourceMappingURL=chunk-Z6FVXDDU.js.map

package/dist/chunk-Z6FVXDDU.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/api/errors.ts","../src/api/idempotency.ts"],"sourcesContent":["import {\n  ConcurrencyError,\n  InvariantError,\n  NonRetryableError,\n  StreamClosedError,\n  ValidationError,\n} from \"@rotorsoft/act\";\n\n/**\n * Uniform error envelope shipped over the wire by every act-http\n * transport. Hosts get the same shape from REST, tRPC, and OpenAPI —\n * a client that talks to two transports doesn't have to invent two\n * error parsers.\n *\n * - `error` — the framework error name (`\"ValidationError\"`,\n *   `\"InvariantError\"`, …). Stable identifier, safe to switch on.\n * - `detail` — the framework's message text. Human-readable; not\n *   parsed by clients.\n * - `code` — a machine-readable status code from {@link ERROR_MAP}\n *   for clients that prefer enum-style branching over name strings.\n */\nexport type ApiError = {\n  error: string;\n  detail?: string;\n  code?: string;\n};\n\n/**\n * Status + code pair for one known framework error.\n */\nexport type ErrorMapEntry = {\n  status: number;\n  code: string;\n};\n\n/**\n * The single table that maps framework error types to HTTP status\n * codes and machine-readable codes. One table, three consumers\n * (Hono, tRPC, OpenAPI) — cross-transport consistency by\n * construction.\n *\n * Operators wanting different mappings wrap the generated transport\n * rather than mutating this — the consistency is the load-bearing\n * property, not the specific status codes.\n */\nexport const ERROR_MAP = {\n  ValidationError: { status: 422, code: \"VALIDATION\" },\n  InvariantError: { status: 409, code: \"INVARIANT\" },\n  ConcurrencyError: { status: 412, code: \"CONCURRENCY\" },\n  StreamClosedError: { status: 410, code: \"STREAM_CLOSED\" },\n  NonRetryableError: { status: 400, code: \"NON_RETRYABLE\" },\n} as const satisfies Record<string, ErrorMapEntry>;\n\nconst lookup_known = (\n  err: unknown\n): { name: keyof typeof ERROR_MAP } | null => {\n  if (err instanceof ValidationError) return { name: \"ValidationError\" };\n  if (err instanceof InvariantError) return { name: \"InvariantError\" };\n  if (err instanceof ConcurrencyError) return { name: \"ConcurrencyError\" };\n  if (err instanceof StreamClosedError) return { name: \"StreamClosedError\" };\n  if (err instanceof NonRetryableError) return { name: \"NonRetryableError\" };\n  return null;\n};\n\n/**\n * Translate an unknown thrown value into the canonical\n * {@link ApiError} envelope plus HTTP status. Each transport's error\n * boundary calls this once and forwards the result to the wire.\n *\n * Known framework errors map per {@link ERROR_MAP}. Everything else\n * surfaces as a 500 with `code: \"INTERNAL\"`; the `detail` field is\n * populated when the throw was an `Error` instance, omitted\n * otherwise (a thrown string or object doesn't get to leak its\n * payload to the client).\n */\nexport function toApiError(err: unknown): { status: number; body: ApiError } {\n  const known = lookup_known(err);\n  if (known) {\n    const entry = ERROR_MAP[known.name];\n    return {\n      status: entry.status,\n      body: {\n        error: known.name,\n        detail: (err as Error).message,\n        code: entry.code,\n      },\n    };\n  }\n  if (err instanceof Error) {\n    return {\n      status: 500,\n      body: { error: \"InternalError\", detail: err.message, code: \"INTERNAL\" },\n    };\n  }\n  return {\n    status: 500,\n    body: { error: \"InternalError\", code: \"INTERNAL\" },\n  };\n}\n","import type { IdempotencyStore } from \"@rotorsoft/act-ops/idempotency\";\n\n/**\n * Result of a {@link withIdempotency} call.\n *\n * - `{ deduped: false, result }` — the claim was fresh; the handler\n *   ran and produced `result`.\n * - `{ deduped: true }` — the claim was already taken; the handler\n *   was *not* invoked. The caller decides how to respond (typically\n *   a 2xx with no body, matching the receiver-side convention).\n *\n * Note: the contract does not cache the previous response. A\n * duplicate call returns the deduped marker only — replaying the\n * original handler's output would require a response-caching\n * adapter, which is out of scope here. The receiver-side convention\n * (and the convention the generated transports follow) is \"ack the\n * duplicate; do nothing else.\"\n */\nexport type IdempotencyResult<T> =\n  | { deduped: false; result: T }\n  | { deduped: true };\n\n/**\n * Wrap an action handler so the framework honors `Idempotency-Key`\n * dedup. Acquires the key via {@link IdempotencyStore.claim}, runs\n * the handler exactly when the claim was fresh, and skips the\n * handler entirely on a duplicate.\n *\n * Reuses the contract `@rotorsoft/act-ops/idempotency` already\n * defines for the receiver-side `Idempotency-Key` story. A single\n * `IdempotencyStore` implementation covers both halves of the \"Act\n * over the wire\" surface — receiver and generated API.\n */\nexport async function withIdempotency<T>(\n  store: IdempotencyStore,\n  key: string,\n  handler: () => Promise<T>\n): Promise<IdempotencyResult<T>> {\n  const fresh = await store.claim(key);\n  if (!fresh) {\n    return { deduped: true };\n  }\n  return { deduped: false, result: await handler() };\n}\n"],"mappings":";AAAA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAuCA,IAAM,YAAY;AAAA,EACvB,iBAAiB,EAAE,QAAQ,KAAK,MAAM,aAAa;AAAA,EACnD,gBAAgB,EAAE,QAAQ,KAAK,MAAM,YAAY;AAAA,EACjD,kBAAkB,EAAE,QAAQ,KAAK,MAAM,cAAc;AAAA,EACrD,mBAAmB,EAAE,QAAQ,KAAK,MAAM,gBAAgB;AAAA,EACxD,mBAAmB,EAAE,QAAQ,KAAK,MAAM,gBAAgB;AAC1D;AAEA,IAAM,eAAe,CACnB,QAC4C;AAC5C,MAAI,eAAe,gBAAiB,QAAO,EAAE,MAAM,kBAAkB;AACrE,MAAI,eAAe,eAAgB,QAAO,EAAE,MAAM,iBAAiB;AACnE,MAAI,eAAe,iBAAkB,QAAO,EAAE,MAAM,mBAAmB;AACvE,MAAI,eAAe,kBAAmB,QAAO,EAAE,MAAM,oBAAoB;AACzE,MAAI,eAAe,kBAAmB,QAAO,EAAE,MAAM,oBAAoB;AACzE,SAAO;AACT;AAaO,SAAS,WAAW,KAAkD;AAC3E,QAAM,QAAQ,aAAa,GAAG;AAC9B,MAAI,OAAO;AACT,UAAM,QAAQ,UAAU,MAAM,IAAI;AAClC,WAAO;AAAA,MACL,QAAQ,MAAM;AAAA,MACd,MAAM;AAAA,QACJ,OAAO,MAAM;AAAA,QACb,QAAS,IAAc;AAAA,QACvB,MAAM,MAAM;AAAA,MACd;AAAA,IACF;AAAA,EACF;AACA,MAAI,eAAe,OAAO;AACxB,WAAO;AAAA,MACL,QAAQ;AAAA,MACR,MAAM,EAAE,OAAO,iBAAiB,QAAQ,IAAI,SAAS,MAAM,WAAW;AAAA,IACxE;AAAA,EACF;AACA,SAAO;AAAA,IACL,QAAQ;AAAA,IACR,MAAM,EAAE,OAAO,iBAAiB,MAAM,WAAW;AAAA,EACnD;AACF;;;ACjEA,eAAsB,gBACpB,OACA,KACA,SAC+B;AAC/B,QAAM,QAAQ,MAAM,MAAM,MAAM,GAAG;AACnC,MAAI,CAAC,OAAO;AACV,WAAO,EAAE,SAAS,KAAK;AAAA,EACzB;AACA,SAAO,EAAE,SAAS,OAAO,QAAQ,MAAM,QAAQ,EAAE;AACnD;","names":[]}

package/dist/hono/index.cjs

@@ -0,0 +1,192 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/hono/index.ts
+var hono_exports = {};
+__export(hono_exports, {
+  authenticated: () => authenticated,
+  hono: () => hono
+});
+module.exports = __toCommonJS(hono_exports);
+
+// ../../node_modules/.pnpm/@hono+zod-validator@0.8.0_hono@4.12.23_zod@4.4.3/node_modules/@hono/zod-validator/dist/index.js
+var import_validator = require("hono/validator");
+function zValidatorFunction(target, schema, hook, options) {
+  return (0, import_validator.validator)(target, async (value, c) => {
+    let validatorValue = value;
+    if (target === "header" && "_def" in schema || target === "header" && "_zod" in schema) {
+      const schemaKeys = Object.keys("in" in schema ? schema.in.shape : schema.shape);
+      const caseInsensitiveKeymap = Object.fromEntries(schemaKeys.map((key) => [key.toLowerCase(), key]));
+      validatorValue = Object.fromEntries(Object.entries(value).map(([key, value$1]) => [caseInsensitiveKeymap[key] || key, value$1]));
+    }
+    const result = options && options.validationFunction ? await options.validationFunction(schema, validatorValue) : await schema.safeParseAsync(validatorValue);
+    if (hook) {
+      const hookResult = await hook({
+        data: validatorValue,
+        ...result,
+        target
+      }, c);
+      if (hookResult) {
+        if (hookResult instanceof Response) return hookResult;
+        if ("response" in hookResult) return hookResult.response;
+      }
+    }
+    if (!result.success) return c.json(result, 400);
+    return result.data;
+  });
+}
+var zValidator = zValidatorFunction;
+
+// src/hono/index.ts
+var import_hono = require("hono");
+
+// src/api/errors.ts
+var import_act = require("@rotorsoft/act");
+var ERROR_MAP = {
+  ValidationError: { status: 422, code: "VALIDATION" },
+  InvariantError: { status: 409, code: "INVARIANT" },
+  ConcurrencyError: { status: 412, code: "CONCURRENCY" },
+  StreamClosedError: { status: 410, code: "STREAM_CLOSED" },
+  NonRetryableError: { status: 400, code: "NON_RETRYABLE" }
+};
+var lookup_known = (err) => {
+  if (err instanceof import_act.ValidationError) return { name: "ValidationError" };
+  if (err instanceof import_act.InvariantError) return { name: "InvariantError" };
+  if (err instanceof import_act.ConcurrencyError) return { name: "ConcurrencyError" };
+  if (err instanceof import_act.StreamClosedError) return { name: "StreamClosedError" };
+  if (err instanceof import_act.NonRetryableError) return { name: "NonRetryableError" };
+  return null;
+};
+function toApiError(err) {
+  const known = lookup_known(err);
+  if (known) {
+    const entry = ERROR_MAP[known.name];
+    return {
+      status: entry.status,
+      body: {
+        error: known.name,
+        detail: err.message,
+        code: entry.code
+      }
+    };
+  }
+  if (err instanceof Error) {
+    return {
+      status: 500,
+      body: { error: "InternalError", detail: err.message, code: "INTERNAL" }
+    };
+  }
+  return {
+    status: 500,
+    body: { error: "InternalError", code: "INTERNAL" }
+  };
+}
+
+// src/api/idempotency.ts
+async function withIdempotency(store, key, handler) {
+  const fresh = await store.claim(key);
+  if (!fresh) {
+    return { deduped: true };
+  }
+  return { deduped: false, result: await handler() };
+}
+
+// src/hono/index.ts
+function authenticated(extractor) {
+  return async (c, next) => {
+    try {
+      const actor = await extractor(c);
+      c.set("actor", actor);
+      await next();
+    } catch (err) {
+      const body = {
+        error: "Unauthorized",
+        detail: err instanceof Error ? err.message : void 0,
+        code: "UNAUTHORIZED"
+      };
+      return c.json(body, 401);
+    }
+  };
+}
+var default_key_from = (c) => c.req.header("idempotency-key");
+function hono(app, options) {
+  const base_path = options.basePath ?? "/api";
+  const api = new import_hono.Hono().basePath(
+    base_path
+  );
+  api.use("*", authenticated(options.actor));
+  const key_from = options.idempotency?.keyFrom ?? default_key_from;
+  for (const [action_name, state] of Object.entries(app.registry.actions)) {
+    const schema = state.actions[action_name];
+    api.post(
+      `/actions/${action_name}`,
+      zValidator("json", schema),
+      async (c) => {
+        try {
+          const input = c.req.valid("json");
+          const actor = c.get("actor");
+          const stream = await options.stream(action_name, input, c);
+          const expected_version = options.expectedVersion ? await options.expectedVersion(action_name, input, c) : void 0;
+          const target = expected_version === void 0 ? { stream, actor } : { stream, actor, expectedVersion: expected_version };
+          if (options.idempotency) {
+            const key = key_from(c);
+            if (!key) {
+              const body = {
+                error: "BadRequest",
+                detail: "Idempotency-Key required",
+                code: "BAD_REQUEST"
+              };
+              return c.json(body, 400);
+            }
+            const outcome = await withIdempotency(
+              options.idempotency.store,
+              key,
+              () => app.do(action_name, target, input)
+            );
+            if (outcome.deduped) {
+              const body = {
+                error: "Conflict",
+                detail: "Idempotency-Key already used; original result not cached",
+                code: "CONFLICT"
+              };
+              return c.json(body, 409);
+            }
+            return c.json(outcome.result);
+          }
+          const snapshots = await app.do(
+            action_name,
+            target,
+            input
+          );
+          return c.json(snapshots);
+        } catch (err) {
+          const { status, body } = toApiError(err);
+          return c.json(body, status);
+        }
+      }
+    );
+  }
+  return api;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  authenticated,
+  hono
+});
+//# sourceMappingURL=index.cjs.map