@smthrs/gateway 0.34.0 → 1.0.0-rc.3

package/dist/cjs/GatewaySchema.d.ts.map

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

package/dist/cjs/GatewaySchema.js

@@ -0,0 +1,141 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var GatewaySchema_exports = {};
+__export(GatewaySchema_exports, {
+  ApprovalsSelector: () => ApprovalsSelector,
+  DeltaFrame: () => DeltaFrame,
+  FlowDurationsSelector: () => FlowDurationsSelector,
+  GatewayFrame: () => GatewayFrame,
+  GatewayHealth: () => GatewayHealth,
+  HeartbeatFrame: () => HeartbeatFrame,
+  NodeOutputSelector: () => NodeOutputSelector,
+  ProjectionCursor: () => ProjectionCursor,
+  ProjectionName: () => ProjectionName,
+  ProjectionSelector: () => ProjectionSelector,
+  ProjectionSnapshot: () => ProjectionSnapshot,
+  RowFrame: () => RowFrame,
+  RunEventsSelector: () => RunEventsSelector,
+  RunSummarySelector: () => RunSummarySelector,
+  RunTreeSelector: () => RunTreeSelector,
+  SnapshotEndFrame: () => SnapshotEndFrame,
+  SnapshotStartFrame: () => SnapshotStartFrame,
+  TranscriptSelector: () => TranscriptSelector,
+  WorkspaceRunsSelector: () => WorkspaceRunsSelector,
+  rowSchemaFor: () => rowSchemaFor
+});
+module.exports = __toCommonJS(GatewaySchema_exports);
+var import_control = require("@smthrs/control");
+var import_effect = require("effect");
+var GatewayProjection = __toESM(require("./GatewayProjection.js"), 1);
+const GatewayHealth = import_effect.Schema.Struct({
+  workspaceHash: import_effect.Schema.String,
+  gatewayId: import_effect.Schema.String,
+  protocolVersion: import_effect.Schema.String,
+  capabilities: import_effect.Schema.optionalKey(import_effect.Schema.Array(import_effect.Schema.String))
+});
+const WorkspaceRunsSelector = import_effect.Schema.TaggedStruct("workspace-runs", {
+  flowId: import_effect.Schema.optionalKey(import_effect.Schema.NonEmptyString)
+});
+const RunSummarySelector = import_effect.Schema.TaggedStruct("run-summary", { runId: import_effect.Schema.String });
+const RunEventsSelector = import_effect.Schema.TaggedStruct("run-events", { runId: import_effect.Schema.String });
+const TranscriptSelector = import_effect.Schema.TaggedStruct("transcript", { runId: import_effect.Schema.String });
+const RunTreeSelector = import_effect.Schema.TaggedStruct("run-tree", { runId: import_effect.Schema.String });
+const ApprovalsSelector = import_effect.Schema.TaggedStruct("approvals", {
+  runId: import_effect.Schema.optional(import_effect.Schema.String)
+});
+const NodeOutputSelector = import_effect.Schema.TaggedStruct("node-output", {
+  runId: import_effect.Schema.String,
+  nodeId: import_effect.Schema.String
+});
+const FlowDurationsSelector = import_effect.Schema.TaggedStruct("flow-durations", {
+  flowId: import_effect.Schema.String
+});
+const served = [
+  [WorkspaceRunsSelector, GatewayProjection.RunSummaryRow],
+  [RunSummarySelector, GatewayProjection.RunSummaryRow],
+  [RunEventsSelector, import_control.ControlSchema.ControlEvent],
+  [TranscriptSelector, GatewayProjection.TranscriptRow],
+  [RunTreeSelector, GatewayProjection.RunTreeRow],
+  [ApprovalsSelector, GatewayProjection.ApprovalRow],
+  [NodeOutputSelector, GatewayProjection.NodeOutputRow],
+  [FlowDurationsSelector, GatewayProjection.FlowDurationRow]
+];
+const overServed = (map) => served.map(map);
+const ProjectionSelector = import_effect.Schema.Union(
+  overServed(([selector]) => selector)
+);
+const ProjectionName = import_effect.Schema.Literals(
+  overServed(([selector]) => selector.fields._tag.schema.literal)
+);
+const rowSchemas = Object.fromEntries(
+  served.map(([selector, row]) => [selector.fields._tag.schema.literal, row])
+);
+const rowSchemaFor = (selector) => rowSchemas[selector._tag];
+const ProjectionCursor = import_effect.Schema.Struct({
+  selector: ProjectionSelector,
+  projection: ProjectionName,
+  runId: import_effect.Schema.NullOr(import_effect.Schema.String),
+  value: import_effect.Schema.Int.check(
+    import_effect.Schema.isGreaterThanOrEqualTo(0),
+    import_effect.Schema.isLessThanOrEqualTo(Number.MAX_SAFE_INTEGER)
+  ),
+  offset: import_effect.Schema.Int.check(
+    import_effect.Schema.isGreaterThanOrEqualTo(0),
+    import_effect.Schema.isLessThanOrEqualTo(Number.MAX_SAFE_INTEGER)
+  )
+});
+const snapshotMember = (selector, row) => import_effect.Schema.Struct({ selector, cursor: ProjectionCursor, rows: import_effect.Schema.Array(row) });
+const rowMember = (selector, row) => import_effect.Schema.TaggedStruct("row", { selector, cursor: ProjectionCursor, row });
+const deltaMember = (selector, row) => import_effect.Schema.TaggedStruct("delta", { selector, cursor: ProjectionCursor, delta: import_effect.Schema.Array(row) });
+const ProjectionSnapshot = import_effect.Schema.Union(
+  overServed(([selector, row]) => snapshotMember(selector, row))
+);
+const SnapshotStartFrame = import_effect.Schema.TaggedStruct("snapshot-start", {
+  selector: ProjectionSelector,
+  cursor: ProjectionCursor
+});
+const RowFrame = import_effect.Schema.Union(
+  overServed(([selector, row]) => rowMember(selector, row))
+);
+const SnapshotEndFrame = import_effect.Schema.TaggedStruct("snapshot-end", {
+  selector: ProjectionSelector,
+  cursor: ProjectionCursor
+});
+const DeltaFrame = import_effect.Schema.Union(
+  overServed(([selector, row]) => deltaMember(selector, row))
+);
+const HeartbeatFrame = import_effect.Schema.TaggedStruct("heartbeat", { atMs: import_effect.Schema.Number });
+const GatewayFrame = import_effect.Schema.Union([
+  SnapshotStartFrame,
+  ...RowFrame.members,
+  SnapshotEndFrame,
+  ...DeltaFrame.members,
+  HeartbeatFrame
+]);
+//# sourceMappingURL=GatewaySchema.js.map

package/dist/cjs/GatewaySchema.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/GatewaySchema.ts"],
+  "sourcesContent": ["/**\n * Wire schemas shared by the gateway read path, subscriptions, and singleton\n * lifecycle.\n *\n * @since 0.1.0\n */\n\nimport { ControlSchema } from \"@smthrs/control\"\nimport { Schema } from \"effect\"\nimport * as GatewayProjection from \"./GatewayProjection.ts\"\n\n/**\n * Health response used to prove a singleton belongs to this workspace.\n *\n * @since 0.1.0\n * @category models\n */\nexport const GatewayHealth = Schema.Struct({\n  workspaceHash: Schema.String,\n  gatewayId: Schema.String,\n  protocolVersion: Schema.String,\n  capabilities: Schema.optionalKey(Schema.Array(Schema.String))\n})\n\n/**\n * Health response used for singleton identity probes.\n *\n * @since 0.1.0\n * @category models\n */\nexport type GatewayHealth = typeof GatewayHealth.Type\n\n/**\n * A selector for a workspace-wide run list.\n *\n * @since 0.1.0\n * @category models\n */\nexport const WorkspaceRunsSelector = Schema.TaggedStruct(\"workspace-runs\", {\n  flowId: Schema.optionalKey(Schema.NonEmptyString)\n})\n\n/**\n * A selector for a workspace-wide run list.\n *\n * @since 0.1.0\n * @category models\n */\nexport type WorkspaceRunsSelector = typeof WorkspaceRunsSelector.Type\n\n/**\n * A selector for one run's summary.\n *\n * @since 0.1.0\n * @category models\n */\nexport const RunSummarySelector = Schema.TaggedStruct(\"run-summary\", { runId: Schema.String })\n\n/**\n * A selector for one run's summary.\n *\n * @since 0.1.0\n * @category models\n */\nexport type RunSummarySelector = typeof RunSummarySelector.Type\n\n/**\n * A selector for one run's ordered lifecycle events.\n *\n * @since 0.1.0\n * @category models\n */\nexport const RunEventsSelector = Schema.TaggedStruct(\"run-events\", { runId: Schema.String })\n\n/**\n * A selector for one run's ordered lifecycle events.\n *\n * @since 0.1.0\n * @category models\n */\nexport type RunEventsSelector = typeof RunEventsSelector.Type\n\n/**\n * A selector for one run's transcript projection.\n *\n * @since 0.1.0\n * @category models\n */\nexport const TranscriptSelector = Schema.TaggedStruct(\"transcript\", { runId: Schema.String })\n\n/**\n * A selector for one run's transcript projection.\n *\n * @since 0.1.0\n * @category models\n */\nexport type TranscriptSelector = typeof TranscriptSelector.Type\n\n/**\n * A selector for one run's flattened tree nodes.\n *\n * @since 0.1.0\n * @category models\n */\nexport const RunTreeSelector = Schema.TaggedStruct(\"run-tree\", { runId: Schema.String })\n\n/**\n * A selector for one run's flattened tree nodes.\n *\n * @since 0.1.0\n * @category models\n */\nexport type RunTreeSelector = typeof RunTreeSelector.Type\n\n/**\n * A selector for approvals.\n *\n * Without `runId` it lists the workspace's pending gates, which is the\n * approvals inbox. With one it lists that run's gates including the decided\n * ones, which is what a run card renders: a gate a human already answered\n * still belongs on the card that asked.\n *\n * @since 0.1.0\n * @category models\n */\nexport const ApprovalsSelector = Schema.TaggedStruct(\"approvals\", {\n  runId: Schema.optional(Schema.String)\n})\n\n/**\n * A selector for approvals.\n *\n * @since 0.1.0\n * @category models\n */\nexport type ApprovalsSelector = typeof ApprovalsSelector.Type\n\n/**\n * A selector for one node's output projection.\n *\n * @since 0.1.0\n * @category models\n */\nexport const NodeOutputSelector = Schema.TaggedStruct(\"node-output\", {\n  runId: Schema.String,\n  nodeId: Schema.String\n})\n\n/**\n * A selector for one node's output projection.\n *\n * @since 0.1.0\n * @category models\n */\nexport type NodeOutputSelector = typeof NodeOutputSelector.Type\n\n/**\n * A selector for one flow's measured node durations.\n *\n * This is the one projection that is neither a workspace listing nor scoped\n * to a run: it folds the history of one flow across the runs that executed\n * it, which is what makes it a prediction rather than a report.\n *\n * @since 0.1.0\n * @category models\n */\nexport const FlowDurationsSelector = Schema.TaggedStruct(\"flow-durations\", {\n  flowId: Schema.String\n})\n\n/**\n * A selector for one flow's measured node durations.\n *\n * @since 0.1.0\n * @category models\n */\nexport type FlowDurationsSelector = typeof FlowDurationsSelector.Type\n\n/** A schema for a tagged selector, whose tag names its projection. */\ninterface SelectorSchema extends Schema.Top {\n  readonly Type: { readonly _tag: string }\n}\n\n/** The shape of the served table: one selector paired with one row schema. */\ntype ServedTable = ReadonlyArray<readonly [SelectorSchema, Schema.Top]>\n\n/**\n * The row schema each served selector answers with.\n *\n * This table is the selector-to-row pairing, and it exists once. The selector\n * union, the projection names, `rowSchemaFor`, `ProjectionSnapshot`,\n * `RowFrame`, and `DeltaFrame` all derive from it, so serving one more\n * projection is one more entry here rather than five mirrored lists that can\n * disagree with each other.\n */\nconst served = [\n  [WorkspaceRunsSelector, GatewayProjection.RunSummaryRow],\n  [RunSummarySelector, GatewayProjection.RunSummaryRow],\n  [RunEventsSelector, ControlSchema.ControlEvent],\n  [TranscriptSelector, GatewayProjection.TranscriptRow],\n  [RunTreeSelector, GatewayProjection.RunTreeRow],\n  [ApprovalsSelector, GatewayProjection.ApprovalRow],\n  [NodeOutputSelector, GatewayProjection.NodeOutputRow],\n  [FlowDurationsSelector, GatewayProjection.FlowDurationRow]\n] as const satisfies ServedTable\n\n/** The served table as the type every derivation below maps over. */\ntype Served = typeof served\n\n/**\n * Maps the served table into a tuple whose members keep their own types.\n *\n * `Array.prototype.map` widens a tuple to an array of its element union, which\n * would collapse each derived union into an uncorrelated cross product of\n * every selector with every row. The mapped tuple type each caller names is\n * that correlation, and this restates it for the value.\n */\nconst overServed = <M>(map: (pair: Served[number]) => unknown): M => served.map(map) as unknown as M\n\n/** The selector schema of each served pair, in table order. */\ntype SelectorsOf<T extends ServedTable> = { readonly [K in keyof T]: T[K][0] }\n\n/** The projection name of each served pair, in table order. */\ntype NamesOf<T extends ServedTable> = { readonly [K in keyof T]: T[K][0][\"Type\"][\"_tag\"] }\n\n/**\n * A projection selected for a snapshot or watch subscription.\n *\n * @since 0.1.0\n * @category models\n */\nexport const ProjectionSelector = Schema.Union(\n  overServed<SelectorsOf<Served>>(([selector]) => selector)\n)\n\n/**\n * A projection selected for a snapshot or watch subscription.\n *\n * @since 0.1.0\n * @category models\n */\nexport type ProjectionSelector = typeof ProjectionSelector.Type\n\n/**\n * Projection names served by the gateway read path.\n *\n * @since 0.1.0\n * @category models\n */\nexport const ProjectionName = Schema.Literals(\n  overServed<NamesOf<Served>>(([selector]) => selector.fields._tag.schema.literal)\n)\n\n/**\n * A gateway projection name.\n *\n * @since 0.1.0\n * @category models\n */\nexport type ProjectionName = typeof ProjectionName.Type\n\n/** Each served row schema, keyed by the name of the selector it answers. */\ntype RowSchemas = { readonly [P in Served[number] as P[0][\"Type\"][\"_tag\"]]: P[1] }\n\nconst rowSchemas = Object.fromEntries(\n  served.map(([selector, row]) => [selector.fields._tag.schema.literal, row])\n) as RowSchemas\n\n/**\n * The row schema one selector answers with, so a client decodes a snapshot\n * instead of casting it.\n *\n * A literal selector keeps its own row schema: `rowSchemaFor({ _tag:\n * \"approvals\" })` decodes to `ApprovalRow`, not to the union of every row.\n *\n * @param selector the selector whose row schema the client needs\n * @since 1.0.0\n * @category schemas\n */\nexport const rowSchemaFor = <S extends ProjectionSelector>(selector: S): RowSchemas[S[\"_tag\"]] =>\n  rowSchemas[selector._tag] as RowSchemas[S[\"_tag\"]]\n\n/**\n * The row type one selector's projection is made of.\n *\n * @since 1.0.0\n * @category models\n */\nexport type RowOf<S extends ProjectionSelector> = RowSchemas[S[\"_tag\"]][\"Type\"]\n\n/**\n * A monotonic cursor for one projection and optional run scope.\n *\n * `runId` is null for workspace projections and records the source run for\n * per-run projections, even when a selector later gains more fields. Control\n * journal sequences belong to per-run partitions, so no workspace-wide\n * sequence exists. A workspace cursor therefore has value `0` and a null run,\n * and a workspace projection cannot resume from a cursor.\n *\n * @since 0.1.0\n * @category models\n */\nexport const ProjectionCursor = Schema.Struct({\n  selector: ProjectionSelector,\n  projection: ProjectionName,\n  runId: Schema.NullOr(Schema.String),\n  value: Schema.Int.check(\n    Schema.isGreaterThanOrEqualTo(0),\n    Schema.isLessThanOrEqualTo(Number.MAX_SAFE_INTEGER)\n  ),\n  offset: Schema.Int.check(\n    Schema.isGreaterThanOrEqualTo(0),\n    Schema.isLessThanOrEqualTo(Number.MAX_SAFE_INTEGER)\n  )\n})\n\n/**\n * A monotonic projection cursor.\n *\n * @since 0.1.0\n * @category models\n */\nexport type ProjectionCursor = typeof ProjectionCursor.Type\n\n/** One snapshot member: every row one selector projects, at one cursor. */\nconst snapshotMember = <S extends Schema.Top, R extends Schema.Top>(selector: S, row: R) =>\n  Schema.Struct({ selector, cursor: ProjectionCursor, rows: Schema.Array(row) })\n\n/** One row frame: a single row of one selector's projection. */\nconst rowMember = <S extends Schema.Top, R extends Schema.Top>(selector: S, row: R) =>\n  Schema.TaggedStruct(\"row\", { selector, cursor: ProjectionCursor, row })\n\n/** One delta frame: the rows one selector's projection changed by. */\nconst deltaMember = <S extends Schema.Top, R extends Schema.Top>(selector: S, row: R) =>\n  Schema.TaggedStruct(\"delta\", { selector, cursor: ProjectionCursor, delta: Schema.Array(row) })\n\ntype SnapshotMembersOf<T extends ServedTable> = {\n  readonly [K in keyof T]: ReturnType<typeof snapshotMember<T[K][0], T[K][1]>>\n}\n\ntype RowMembersOf<T extends ServedTable> = {\n  readonly [K in keyof T]: ReturnType<typeof rowMember<T[K][0], T[K][1]>>\n}\n\ntype DeltaMembersOf<T extends ServedTable> = {\n  readonly [K in keyof T]: ReturnType<typeof deltaMember<T[K][0], T[K][1]>>\n}\n\n/**\n * Every row one selector currently projects, and the cursor they were read\n * at. A client that follows the same selector from this cursor sees each\n * later change exactly once.\n *\n * @since 1.0.0\n * @category models\n */\nexport const ProjectionSnapshot = Schema.Union(\n  overServed<SnapshotMembersOf<Served>>(([selector, row]) => snapshotMember(selector, row))\n)\n\n/**\n * A projection snapshot and the cursor it was read at.\n *\n * @since 1.0.0\n * @category models\n */\nexport type ProjectionSnapshot = typeof ProjectionSnapshot.Type\n\n/**\n * The start of a selector snapshot.\n *\n * @since 0.1.0\n * @category models\n */\nexport const SnapshotStartFrame = Schema.TaggedStruct(\"snapshot-start\", {\n  selector: ProjectionSelector,\n  cursor: ProjectionCursor\n})\n\n/**\n * The start of a selector snapshot.\n *\n * @since 0.1.0\n * @category models\n */\nexport type SnapshotStartFrame = typeof SnapshotStartFrame.Type\n\n/**\n * A row emitted during a selector snapshot.\n *\n * @since 0.1.0\n * @category models\n */\nexport const RowFrame = Schema.Union(\n  overServed<RowMembersOf<Served>>(([selector, row]) => rowMember(selector, row))\n)\n\n/**\n * A row emitted during a selector snapshot.\n *\n * @since 0.1.0\n * @category models\n */\nexport type RowFrame = typeof RowFrame.Type\n\n/**\n * The end of a selector snapshot.\n *\n * @since 0.1.0\n * @category models\n */\nexport const SnapshotEndFrame = Schema.TaggedStruct(\"snapshot-end\", {\n  selector: ProjectionSelector,\n  cursor: ProjectionCursor\n})\n\n/**\n * The end of a selector snapshot.\n *\n * @since 0.1.0\n * @category models\n */\nexport type SnapshotEndFrame = typeof SnapshotEndFrame.Type\n\n/**\n * A projection mutation after snapshot completion.\n *\n * `delta` replaces the selector's rows, except for the two append-only\n * projections: a `run-events` delta carries the one event that arrived and a\n * `transcript` delta carries the rows that event contributed, and a client\n * appends those to the rows it already holds.\n *\n * @since 0.1.0\n * @category models\n */\nexport const DeltaFrame = Schema.Union(\n  overServed<DeltaMembersOf<Served>>(([selector, row]) => deltaMember(selector, row))\n)\n\n/**\n * A projection mutation after snapshot completion.\n *\n * @since 0.1.0\n * @category models\n */\nexport type DeltaFrame = typeof DeltaFrame.Type\n\n/**\n * A keepalive frame for an active subscription.\n *\n * @since 0.1.0\n * @category models\n */\nexport const HeartbeatFrame = Schema.TaggedStruct(\"heartbeat\", { atMs: Schema.Number })\n\n/**\n * A keepalive frame for an active subscription.\n *\n * @since 0.1.0\n * @category models\n */\nexport type HeartbeatFrame = typeof HeartbeatFrame.Type\n\n/**\n * A frame sent by the gateway subscription protocol.\n *\n * @since 0.1.0\n * @category models\n */\nexport const GatewayFrame = Schema.Union([\n  SnapshotStartFrame,\n  ...RowFrame.members,\n  SnapshotEndFrame,\n  ...DeltaFrame.members,\n  HeartbeatFrame\n])\n\n/**\n * A frame sent by the gateway subscription protocol.\n *\n * @since 0.1.0\n * @category models\n */\nexport type GatewayFrame = typeof GatewayFrame.Type\n\n/**\n * The snapshot one selector answers with.\n *\n * A literal selector keeps its own rows: `SnapshotOf<ApprovalsSelector>` has\n * `ApprovalRow` rows, so a caller reads `requestId` without an assertion. A\n * selector union maps to the snapshot union, which is what a caller holding a\n * selector chosen at runtime still gets.\n *\n * @since 1.0.0\n * @category models\n */\nexport type SnapshotOf<S extends ProjectionSelector> = Extract<\n  ProjectionSnapshot,\n  { readonly selector: { readonly _tag: S[\"_tag\"] } }\n>\n\n/**\n * The frames one selector's subscription emits.\n *\n * Snapshot brackets and keepalives carry no rows and belong to every\n * selector; the row and delta frames are the selector's own.\n *\n * @since 1.0.0\n * @category models\n */\nexport type FrameOf<S extends ProjectionSelector> =\n  | SnapshotStartFrame\n  | SnapshotEndFrame\n  | HeartbeatFrame\n  | Extract<RowFrame, { readonly selector: { readonly _tag: S[\"_tag\"] } }>\n  | Extract<DeltaFrame, { readonly selector: { readonly _tag: S[\"_tag\"] } }>\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/cjs/GatewayServer.d.ts

@@ -0,0 +1,427 @@
+/**
+ * The assembled workspace gateway: one HTTP surface carrying the control
+ * plane, the sync read path, the served projections, and a health probe.
+ *
+ * Mounts:
+ *
+ * | Path | Protocol | Serves |
+ * | --- | --- | --- |
+ * | `POST /rpc` | RPC over HTTP | `@smthrs/control` `ControlRpcs` |
+ * | `/rpc/ws` | RPC over WebSocket | `ControlRpcs`, including a kept-alive `Watch` |
+ * | `POST /projections` | RPC over HTTP | `GatewayRpcs` |
+ * | `/projections/ws` | RPC over WebSocket | `GatewayRpcs`, including `Projection.Subscribe` |
+ * | `POST /sync` | RPC over HTTP | `@smthrs/sync` `SyncRpcs` |
+ * | `/sync/ws` | RPC over WebSocket | `SyncRpcs` |
+ * | `GET /health` | JSON | `GatewaySchema.GatewayHealth` plus the package version |
+ * | `POST /auth/ticket` | JSON | A single-use {@link Ticket} that opens one protected socket |
+ *
+ * `/health` is deliberately unauthenticated: a supervisor decides whether to
+ * keep or replace a gateway process by asking which workspace it belongs to,
+ * and a probe that needed a credential could not answer that question about a
+ * gateway it did not start. The response carries identity only: the
+ * workspace hash, the gateway id, the protocol version, and the package
+ * version. It never carries a token, a run, or a path.
+ *
+ * @since 1.0.0
+ */
+import { Control } from "@smthrs/control/Control";
+import * as SyncServer from "@smthrs/sync/SyncServer";
+import { Effect, Layer, Schema } from "effect";
+import { HttpRouter } from "effect/unstable/http";
+import { RpcSerialization, RpcServer } from "effect/unstable/rpc";
+import { GatewayError } from "./GatewayError.ts";
+import { Projections } from "./Projections.ts";
+import * as RuntimeBridge from "./RuntimeBridge.ts";
+/**
+ * What `GET /health` answers: the `GatewaySchema.GatewayHealth` identity plus
+ * the version of the package serving it.
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export declare const Health: Schema.Struct<{
+    readonly version: Schema.String;
+    readonly runtimeBridge: Schema.optional<Schema.Struct<{
+        readonly protocol: Schema.Literal<"smithers.flow-runtime/v1">;
+        readonly runtimeArtifactDigest: Schema.String;
+        readonly sourceRevision: Schema.String;
+        readonly ownerGeneration: Schema.Int;
+    }>>;
+    readonly workspaceHash: Schema.String;
+    readonly gatewayId: Schema.String;
+    readonly protocolVersion: Schema.String;
+    readonly capabilities: Schema.optionalKey<Schema.$Array<Schema.String>>;
+}>;
+/**
+ * What `GET /health` answers.
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export type Health = typeof Health.Type;
+/**
+ * Mounts the unauthenticated health probe.
+ *
+ * @param health the identity this process serves under
+ * @since 1.0.0
+ * @category layers
+ */
+export declare const layerHealth: (health: Health) => Layer.Layer<never, never, HttpRouter.HttpRouter>;
+/**
+ * The gateway's own RPC handlers over the read path and the control plane.
+ *
+ * @since 1.0.0
+ * @category layers
+ */
+export declare const layerHandlers: Layer.Layer<import("effect/unstable/rpc/Rpc").Handler<"Projection.Snapshot"> | import("effect/unstable/rpc/Rpc").Handler<"Projection.Subscribe"> | import("effect/unstable/rpc/Rpc").Handler<"Approval.Submit"> | import("effect/unstable/rpc/Rpc").Handler<"Run.Fork"> | import("effect/unstable/rpc/Rpc").Handler<"Run.Verify">, never, Control | Projections>;
+/**
+ * The kind a `Watch` keepalive carries.
+ *
+ * `ControlRpcs.Watch` answers `ControlSchema.ControlEvent` and has no frame of
+ * its own for a keepalive, so the gateway publishes one as an event whose kind
+ * no emitter uses. A fold that does not know the kind ignores it, which is
+ * what every fold in this package and in `@smthrs/cli` `Forensics` already
+ * does with an unknown kind.
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export declare const watchHeartbeatKind = "control.gateway.heartbeat";
+/**
+ * The control service the `/rpc` mounts read through: the ambient one, with
+ * the keepalive merged into `watch`.
+ *
+ * Wrapping the service rather than re-declaring the handlers keeps
+ * `@smthrs/control` `ControlServer` the single definition of what every
+ * procedure does, including the principal it stamps on every mutation that
+ * records who asked. Only `watch` behaves differently, and only in what it
+ * adds.
+ *
+ * @since 1.0.0
+ * @category layers
+ */
+export declare const layerKeepAlive: (millis?: number) => Layer.Layer<Control, never, Control>;
+/**
+ * The read path the `/projections` mounts serve through: the ambient one, with
+ * a followed subscription's keepalive re-timed to the bind's cadence.
+ *
+ * `Projections.make` already merges a `heartbeat` frame at the cadence it was
+ * built with. A host that supplies `Projections.layer` and sets the cadence at
+ * the bind expects one option to govern both keepalives, so this replaces the
+ * service's beats with beats at the bind's cadence rather than adding a second
+ * channel. Snapshot reads are left alone: they have to end.
+ *
+ * @param millis how often an idle followed subscription emits a keepalive
+ * @since 1.0.0
+ * @category layers
+ */
+export declare const layerProjectionsKeepAlive: (millis: number) => Layer.Layer<Projections, never, Projections>;
+/**
+ * Mounts the control plane on `POST /rpc` and `/rpc/ws`, with the keepalive.
+ *
+ * @param millis how often an idle followed watch emits one, defaulting to
+ * `Projections.heartbeatIntervalMillis`
+ * @since 1.0.0
+ * @category layers
+ */
+export declare const layerControlHttp: (millis?: number | undefined) => Layer.Layer<RpcServer.Protocol, never, Control | import("@smthrs/control/ControlRpcs").ControlAuth | HttpRouter.HttpRouter | RpcSerialization.RpcSerialization>;
+/**
+ * Mounts the gateway's projections on `POST /projections` and
+ * `/projections/ws`.
+ *
+ * Both protocols are mounted together because a client reads a snapshot over
+ * the request/response path and follows deltas over the socket, and pointing
+ * those at two different servers would let them disagree.
+ *
+ * @since 1.0.0
+ * @category layers
+ */
+export declare const layerProjectionsHttp: Layer.Layer<RpcServer.Protocol, never, Control | import("@smthrs/control/ControlRpcs").ControlAuth | HttpRouter.HttpRouter | RpcSerialization.RpcSerialization | Projections>;
+/**
+ * Mounts the sync read path on `POST /sync` and `/sync/ws`.
+ *
+ * @since 1.0.0
+ * @category layers
+ */
+export declare const layerSyncHttp: Layer.Layer<RpcServer.Protocol, never, HttpRouter.HttpRouter | RpcSerialization.RpcSerialization | import("@smthrs/sync/SyncRpcs").SyncAuth | SyncServer.SyncServer>;
+/**
+ * The POST mounts that carry RPC request messages and nothing else.
+ *
+ * @since 1.0.0
+ * @category constants
+ */
+export declare const rpcPaths: ReadonlyArray<string>;
+/**
+ * POST mounts whose request bodies are bounded before their handlers read.
+ *
+ * @since 1.0.0
+ * @category constants
+ */
+export declare const boundedPostPaths: ReadonlyArray<string>;
+/**
+ * RPC paths whose upgrade or request must pass edge authentication.
+ *
+ * `POST /rpc` is deliberately not one of them. The control mount authenticates
+ * in band through `@smthrs/control` `ControlRpcs.ControlAuth`, whose declared
+ * error is `ControlError.Unauthorized`, and that typed control error is the
+ * refusal the control plane publishes: "Missing, malformed, empty, and
+ * incorrect credentials all return the same typed `Unauthorized` control
+ * error" (`packages/smithers/gateway/docs/guides/serve-beyond-loopback.md`). An edge 401 answered
+ * ahead of the mount, and `ControlClient` filters a non-2xx status, so every
+ * refusal reached a caller as a `TransportError`, the one error class
+ * `@smthrs/control` reserves for a request that failed *before* a declared
+ * control response reached it. It also made the gateway refuse a call
+ * differently from `NodeControl.layerServer` hosting the very same
+ * `ControlRpcs`. The body limit below still applies to `/rpc`, so an
+ * unauthenticated caller buys one bounded body read and nothing else.
+ *
+ * The `/rpc/ws` upgrade stays here. A socket is a resource the server holds
+ * open, the RPC middleware can only refuse frames on a socket that already
+ * exists, and a refused handshake has no RPC channel to answer a typed error
+ * on, so its refusal is a transport fact either way.
+ *
+ * @category constants
+ * @since 1.0.0
+ */
+export declare const protectedPaths: ReadonlyArray<string>;
+/**
+ * The mount a request target reaches, spelled the way {@link rpcPaths} and
+ * {@link protectedPaths} spell it.
+ *
+ * The guard runs before the router and has to reach the router's verdict, or
+ * an alias walks past the credential check and the body limit and is answered
+ * by the mount anyway. Measured against `HttpRouter` on this tree, all of
+ * `/%72pc`, `/rpc;transport-parameter`, `/rpc/`, `//rpc`, `///rpc`, `/rpc//`,
+ * `/RPC`, `/./rpc`, and `/foo/../rpc` reach the `/rpc` handler, while
+ * `/rpc%2f`, `/rpc%3Bp`, `/%2frpc`, and `/rpc%20` do not. This is not only
+ * about crafted aliases: `@smthrs/control` `ControlClient`'s HTTP protocol
+ * posts every call to `/rpc/`, so a literal comparison skipped the body limit
+ * on the path the product's own client uses.
+ *
+ * Each segment is therefore taken without its `;` parameter, empty segments are
+ * dropped, and what is left is decoded with `decodeURI` and compared without
+ * regard to case. `decodeURI` is the decoder rather than `decodeURIComponent`
+ * because it leaves a reserved character encoded, which is what keeps
+ * `/rpc%2f` a different path here exactly as it is to the router. An invalid
+ * escape is left as written, since it names no mount either way.
+ *
+ * Dot segments are resolved by `URL` before the split. The normalization errs
+ * toward matching: a spelling this resolves to a mount that the router then
+ * refuses is answered 401 rather than 404, which costs an unauthenticated
+ * caller nothing it was entitled to.
+ *
+ * @param url the request target, origin-relative or absolute
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const routedPath: (url: string) => string;
+/**
+ * The mount that exchanges a bearer credential for a WebSocket {@link Ticket}.
+ *
+ * @since 1.0.0
+ * @category constants
+ */
+export declare const ticketPath = "/auth/ticket";
+/**
+ * The protected socket mounts a {@link Ticket} opens.
+ *
+ * @since 1.0.0
+ * @category constants
+ */
+export declare const ticketPaths: ReadonlyArray<string>;
+/**
+ * How long an unredeemed {@link Ticket} stays valid (thirty seconds).
+ *
+ * @since 1.0.0
+ * @category constants
+ */
+export declare const defaultTicketMillis = 30000;
+/**
+ * What `POST /auth/ticket` answers.
+ *
+ * A browser `WebSocket` cannot set an `Authorization` header, so a browser
+ * client first posts its bearer to `/auth/ticket`, then opens a protected
+ * socket as `<mount>?ticket=<ticket>` within `expiresInMs`. The first upgrade
+ * that presents the ticket consumes it, whether or not the upgrade completes;
+ * a replay or a late one is refused 401. The socket then runs under the
+ * bearer the ticket was issued for, so every frame authenticates as it would
+ * with the header.
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export declare const Ticket: Schema.Struct<{
+    readonly ticket: Schema.String;
+    readonly expiresInMs: Schema.Number;
+}>;
+/**
+ * What `POST /auth/ticket` answers.
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export type Ticket = typeof Ticket.Type;
+/**
+ * Default maximum request body accepted by an RPC mount (one MiB).
+ *
+ * @category constants
+ * @since 1.0.0
+ */
+export declare const defaultMaxRequestBodyBytes: number;
+/**
+ * Ingress policy enforced before an RPC transport parses a request.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export interface IngressOptions {
+    /** Accepted Host header names, without ports. Defaults to loopback names. */
+    readonly allowedHosts?: ReadonlyArray<string> | undefined;
+    readonly maxRequestBodyBytes?: number | undefined;
+    /** Confine requests to loopback Host values and browser origins. */
+    readonly loopbackOnly?: boolean | undefined;
+    /**
+     * Edge authentication for {@link protectedPaths}, told which mount the
+     * request reaches. When set, `POST /auth/ticket` exchanges a credential it
+     * accepts for a {@link Ticket}, and a redeemed ticket's credential is judged
+     * again for the mount its upgrade reaches.
+     */
+    readonly authorize?: (headers: Readonly<Record<string, string>>, path: string) => Effect.Effect<boolean>;
+    /** How long an unredeemed ticket stays valid. Default {@link defaultTicketMillis}. */
+    readonly ticketMillis?: number | undefined;
+}
+/**
+ * The names that mean this machine only, as a bind address is spelled.
+ *
+ * This is a list of spellings a person types, not a subnet test: `127.0.0.2`
+ * is loopback to the kernel and is not on it. The Node host's
+ * `isLoopbackHost`, the Host-header names below, and the ingress regex all
+ * derive from this one list so widening it is one edit.
+ *
+ * @since 1.0.0
+ * @category constants
+ */
+export declare const loopbackHostNames: ReadonlyArray<string>;
+/**
+ * {@link loopbackHostNames} as a Host header spells them: an IPv6 address is
+ * bracketed as a URL authority. This is the default `allowedHosts`.
+ *
+ * @since 1.0.0
+ * @category constants
+ */
+export declare const loopbackHostHeaderNames: ReadonlyArray<string>;
+/**
+ * Whether a failed request-body read hit the configured size limit rather than
+ * failing for another reason.
+ *
+ * `@effect/platform-node` raises the limit as an `HttpServerError` whose
+ * `reason` is a `RequestParseError` carrying the `Error("maxBytes exceeded")`
+ * that `@effect/platform-node-shared` `NodeStream.toString` throws
+ * (`NodeHttpIncomingMessage.text` passes `MaxBodySize` in as `maxBytes`, and
+ * `NodeHttpServer`'s `ServerRequestImpl` wraps whatever it throws). Nothing on
+ * the wire distinguishes it otherwise, so the check is that exact shape and a
+ * version bump of those packages is the thing to re-read it against.
+ *
+ * Every other read failure, a transport reset among them, is not a size
+ * overflow. Answering 413 for all of them told a client to shrink a request
+ * that was never too big.
+ *
+ * @param error the failure a body read produced
+ * @since 1.0.0
+ * @category predicates
+ */
+export declare const exceededBodyLimit: (error: unknown) => boolean;
+/**
+ * The refusal a failed request-body read earns, and the status it answers
+ * under.
+ *
+ * A body over the limit is 413 `request_too_large`. Every other read failure,
+ * a truncated body or a reset transport among them, is 400
+ * `malformed_request`: the request cannot be retried smaller, because its size
+ * was never the problem.
+ *
+ * @param path the mount the request was made to
+ * @param maxBytes the configured limit
+ * @param error the failure the body read produced
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const bodyRefusal: (path: string, maxBytes: number, error: unknown) => {
+    readonly error: GatewayError;
+    readonly status: number;
+};
+/**
+ * Whether a request body carries at least one RPC message the server can act
+ * on.
+ *
+ * The transport's own parser answers, not a second reading of the wire
+ * format: whatever `RpcSerialization` the host composed decodes the body, and
+ * the answer is no only when that decode throws or yields no tagged message.
+ * A body naming a procedure that does not exist is a yes — that is an
+ * RPC-level defect the protocol itself reports.
+ *
+ * A binary framing is always a yes. Its body is not text, so there is nothing
+ * to read here, and the mount owns it.
+ *
+ * @since 1.0.0
+ * @category predicates
+ */
+export declare const carriesRpcRequest: (serialization: RpcSerialization.RpcSerialization["Service"], body: string) => boolean;
+/**
+ * Enforces local Host/Origin policy and edge authentication before reading a
+ * body or upgrading a socket, then validates RPC body size and framing.
+ *
+ * `effect/unstable/rpc` hands every decoded message to the server loop, and a
+ * body that decodes to something else — `{}`, `[]`, prose, nothing at all —
+ * reached it as a message with no tag and died there, so the gateway answered
+ * `500 Internal Server Error` with an empty body (release validation). That is the
+ * wrong half of the contract twice over: it tells an operator the gateway
+ * broke, and it tells a client to retry a request that can never succeed.
+ *
+ * The body reader is cached per request, so reading the body here does not
+ * consume the body the mount reads. It is read through the reader the mount
+ * uses, `text` under a JSON serialization and `arrayBuffer` under a binary
+ * one, so the bytes the mount decodes are the bytes the client sent.
+ *
+ * @since 1.0.0
+ * @category layers
+ */
+export declare const layerIngress: (options?: IngressOptions) => Layer.Layer<never, GatewayError, never> | Layer.Layer<never, never, HttpRouter.HttpRouter | RpcSerialization.RpcSerialization>;
+/**
+ * How an assembled gateway is configured.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export interface LayerOptions {
+    /**
+     * How often an idle followed `Watch` on `/rpc/ws` and an idle followed
+     * `Projection.Subscribe` on `/projections/ws` emit a keepalive. Unset, the
+     * `Watch` keepalive runs at `Projections.heartbeatIntervalMillis` and the
+     * supplied `Projections` service keeps the cadence it was built with.
+     */
+    readonly heartbeatMillis?: number | undefined;
+    /** The ingress policy the RPC mounts run behind. */
+    readonly ingress?: IngressOptions | undefined;
+    /** Enables the authenticated Go-to-Control runtime bridge. */
+    readonly runtimeBridge?: RuntimeBridge.Config | undefined;
+}
+/**
+ * The whole gateway surface, as one application layer a host serves.
+ *
+ * The caller supplies the transport serialization, the authentication
+ * middleware for both RPC groups, and the services the mounts read through
+ * (`Control`, `Projections`, `SyncServer`). `@smthrs/gateway/node/NodeGateway`
+ * is the Node host that binds this to a socket.
+ *
+ * A keepalive cadence or a body limit that is not a positive safe integer is
+ * refused here, before anything binds, through the layer's typed
+ * `GatewayError` channel.
+ *
+ * @param health the identity `GET /health` answers with
+ * @param options the keepalive cadence and the ingress policy
+ * @since 1.0.0
+ * @category layers
+ */
+export declare const layer: (health: Health, options?: LayerOptions) => Layer.Layer<never, GatewayError, never> | Layer.Layer<RpcServer.Protocol, GatewayError | import("@smthrs/sync/SyncError").SyncError, Control | import("@smthrs/control/ControlRpcs").ControlAuth | HttpRouter.HttpRouter | RpcSerialization.RpcSerialization | import("@smthrs/sync/SyncRpcs").SyncAuth | SyncServer.SyncServer | Projections | HttpRouter.Request<"Requires", Control>>;
+//# sourceMappingURL=GatewayServer.d.ts.map

package/dist/cjs/GatewayServer.d.ts.map

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