@smthrs/gateway 0.35.0 → 1.0.0-rc.4

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

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

package/dist/cjs/RuntimeBridge.js

@@ -0,0 +1,598 @@
+"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 RuntimeBridge_exports = {};
+__export(RuntimeBridge_exports, {
+  BridgeError: () => BridgeError,
+  Command: () => Command,
+  CommandReceipt: () => CommandReceipt,
+  CommandResponse: () => CommandResponse,
+  DecisionCommand: () => DecisionCommand,
+  ErrorResponse: () => ErrorResponse,
+  Identity: () => Identity,
+  LaunchCommand: () => LaunchCommand,
+  LifecycleCommand: () => LifecycleCommand,
+  ObserveRequest: () => ObserveRequest,
+  ObserveResponse: () => ObserveResponse,
+  SignalCommand: () => SignalCommand,
+  SteerCommand: () => SteerCommand,
+  execute: () => execute,
+  layer: () => layer,
+  monitor: () => monitor,
+  observe: () => observe,
+  protocol: () => protocol
+});
+module.exports = __toCommonJS(RuntimeBridge_exports);
+var import_Control = require("@smthrs/control/Control");
+var ControlError = __toESM(require("@smthrs/control/ControlError"), 1);
+var import_ControlExecutor = require("@smthrs/control/ControlExecutor");
+var import_ControlSchema = require("@smthrs/control/ControlSchema");
+var Fault = __toESM(require("@smthrs/flow/Fault"), 1);
+var import_effect = require("effect");
+var import_http = require("effect/unstable/http");
+var import_GatewayProjection = require("./GatewayProjection.js");
+var Projections = __toESM(require("./Projections.js"), 1);
+var import_RunTrace = require("./RunTrace.js");
+const protocol = "smithers.flow-runtime/v1";
+const Sha256 = import_effect.Schema.String.check(import_effect.Schema.isPattern(/^[0-9a-f]{64}$/));
+const SourceRevision = import_effect.Schema.String.check(import_effect.Schema.isPattern(/^[0-9a-f]{40}$/));
+const PositiveSafeInteger = import_effect.Schema.Int.check(
+  import_effect.Schema.isGreaterThan(0),
+  import_effect.Schema.isLessThanOrEqualTo(Number.MAX_SAFE_INTEGER)
+);
+const RequestId = import_effect.Schema.NonEmptyString.check(import_effect.Schema.isMaxLength(1024));
+const observationCursorPattern = /^(?:(0|[1-9][0-9]*)|v1:(0|[1-9][0-9]*):(0|[1-9][0-9]*))?(?![\s\S])/;
+const Identity = import_effect.Schema.Struct({
+  protocol: import_effect.Schema.Literal(protocol),
+  runtimeArtifactDigest: Sha256,
+  sourceRevision: SourceRevision,
+  ownerGeneration: PositiveSafeInteger
+});
+const common = {
+  protocol: import_effect.Schema.Literal(protocol),
+  applicationRequestId: RequestId,
+  ownerGeneration: PositiveSafeInteger
+};
+const LaunchPin = import_effect.Schema.Struct({
+  flow: import_effect.Schema.NonEmptyString,
+  sourceCommit: SourceRevision,
+  executionDigest: Sha256
+});
+const LaunchCommand = import_effect.Schema.Struct({
+  ...common,
+  operation: import_effect.Schema.Literal("launch"),
+  attempt: PositiveSafeInteger,
+  runId: import_effect.Schema.optional(import_effect.Schema.NonEmptyString),
+  runtimeArtifactDigest: Sha256,
+  sourceRevision: SourceRevision,
+  flowId: import_effect.Schema.NonEmptyString,
+  payload: import_effect.Schema.Json,
+  pin: import_effect.Schema.optional(LaunchPin)
+});
+const DecisionCommand = import_effect.Schema.Struct({
+  ...common,
+  operation: import_effect.Schema.Literals(["approve", "deny"]),
+  approval: import_ControlSchema.ApprovalPayload
+});
+const SignalCommand = import_effect.Schema.Struct({
+  ...common,
+  operation: import_effect.Schema.Literal("signal"),
+  runId: import_effect.Schema.NonEmptyString,
+  signal: import_ControlSchema.SignalPayload
+});
+const Steer = import_effect.Schema.Union([
+  import_effect.Schema.Struct({ kind: import_effect.Schema.Literal("Message"), body: import_effect.Schema.String }),
+  import_effect.Schema.Struct({ kind: import_effect.Schema.Literal("Seat"), seat: import_effect.Schema.NonEmptyString }),
+  import_effect.Schema.Struct({
+    kind: import_effect.Schema.Literal("Thinking"),
+    thinking: import_effect.Schema.Literals(["none", "minimal", "low", "medium", "high", "xhigh"])
+  }),
+  import_effect.Schema.Struct({ kind: import_effect.Schema.Literal("Tools"), toolNames: import_effect.Schema.NonEmptyArray(import_effect.Schema.NonEmptyString) })
+]);
+const SteerCommand = import_effect.Schema.Struct({
+  version: import_effect.Schema.optional(import_effect.Schema.Number),
+  ...common,
+  operation: import_effect.Schema.Literal("steer"),
+  runId: import_effect.Schema.NonEmptyString,
+  messageId: import_effect.Schema.NonEmptyString,
+  createdAt: import_effect.Schema.Number,
+  attribution: import_ControlSchema.MessageSteer.fields.attribution,
+  steer: Steer
+});
+const LifecycleCommand = import_effect.Schema.Struct({
+  ...common,
+  /** Completion is a host-only lifecycle operation. @since 1.0.0 */
+  operation: import_effect.Schema.Literals(["cancel", "resume", "complete"]),
+  runId: import_effect.Schema.NonEmptyString,
+  reason: import_effect.Schema.optional(import_effect.Schema.String)
+});
+const Command = import_effect.Schema.Union([
+  LaunchCommand,
+  DecisionCommand,
+  SignalCommand,
+  SteerCommand,
+  LifecycleCommand
+]);
+const ObserveRequest = import_effect.Schema.Struct({
+  protocol: import_effect.Schema.Literal(protocol),
+  runId: import_effect.Schema.NonEmptyString,
+  afterCursor: import_effect.Schema.optional(import_effect.Schema.String.check(import_effect.Schema.isPattern(observationCursorPattern))),
+  limit: import_effect.Schema.optional(PositiveSafeInteger)
+});
+const CommandReceipt = import_effect.Schema.Struct({
+  runId: import_effect.Schema.NonEmptyString,
+  operationId: import_effect.Schema.NonEmptyString,
+  status: import_effect.Schema.Literals(["running", "completed"]),
+  argv: import_effect.Schema.NonEmptyArray(import_effect.Schema.String),
+  exitCode: import_effect.Schema.optionalKey(import_effect.Schema.Int),
+  stderr: import_effect.Schema.optionalKey(import_effect.Schema.String),
+  fault: import_effect.Schema.optionalKey(import_effect.Schema.Literals(["factory", "infra"]))
+});
+class BridgeError extends import_effect.Schema.TaggedError()("@smthrs/gateway/RuntimeBridgeError", {
+  code: import_effect.Schema.Literals([
+    "invalid_request",
+    "artifact_mismatch",
+    "source_mismatch",
+    "stale_owner",
+    "run_not_found",
+    "resource_limit",
+    "unavailable",
+    "internal"
+  ]),
+  message: import_effect.Schema.String,
+  retryable: import_effect.Schema.Boolean
+}) {
+}
+const decodeCommand = import_effect.Schema.decodeUnknownEffect(Command);
+const decodeObserve = import_effect.Schema.decodeUnknownEffect(ObserveRequest);
+const terminal = /* @__PURE__ */ new Set(["completed", "failed", "cancelled"]);
+const retryableCodes = /* @__PURE__ */ new Set(["transport_error", "unavailable", "persistence_failed", "launch_failed"]);
+const notFoundCodes = /* @__PURE__ */ new Set(["run_not_found", "flow_not_found", "plan_not_found"]);
+const conflictCodes = /* @__PURE__ */ new Set(["stale_owner", "artifact_mismatch", "source_mismatch", "conflict"]);
+const defaultEventLimit = 250;
+const maximumEventLimit = 1e3;
+const idempotencyKey = (input, suffix) => `bridge:v1:${input.applicationRequestId}:${suffix}`;
+const validateOwner = (config, input) => input.ownerGeneration === config.ownerGeneration ? import_effect.Effect.void : import_effect.Effect.fail(
+  new BridgeError({ code: "stale_owner", message: "Runtime owner generation is stale", retryable: true })
+);
+const execute = (config, control, principal, input) => import_effect.Effect.gen(function* () {
+  yield* validateOwner(config, input);
+  switch (input.operation) {
+    case "launch": {
+      if (input.runtimeArtifactDigest !== config.runtimeArtifactDigest) {
+        return yield* import_effect.Effect.fail(
+          new BridgeError({
+            code: "artifact_mismatch",
+            message: "Runtime artifact digest does not match the owning host",
+            retryable: false
+          })
+        );
+      }
+      if (input.sourceRevision !== config.sourceRevision) {
+        return yield* import_effect.Effect.fail(
+          new BridgeError({
+            code: "source_mismatch",
+            message: "Flow source revision does not match the owning host",
+            retryable: false
+          })
+        );
+      }
+      if (input.pin !== void 0 && input.pin.sourceCommit !== config.sourceRevision) {
+        return yield* import_effect.Effect.fail(
+          new BridgeError({
+            code: "source_mismatch",
+            message: "Flow source revision does not match the pinned launch",
+            retryable: false
+          })
+        );
+      }
+      const plan = yield* control.plan({
+        flowId: input.flowId,
+        input: input.payload,
+        idempotencyKey: idempotencyKey(input, "plan")
+      });
+      const plannedSource = plan.graph?.sourceRevision ?? config.verifiedCatalogSourceRevision;
+      if (plannedSource !== input.sourceRevision) {
+        return yield* import_effect.Effect.fail(
+          new BridgeError({
+            code: "source_mismatch",
+            message: "Flow source revision does not match the immutable request",
+            retryable: false
+          })
+        );
+      }
+      if (input.pin !== void 0 && (plan.executionDigest === void 0 || input.pin.flow === input.flowId && plan.executionDigest !== input.pin.executionDigest)) {
+        return yield* import_effect.Effect.fail(
+          new BridgeError({
+            code: "source_mismatch",
+            message: "Flow execution digest does not match the pinned launch",
+            retryable: false
+          })
+        );
+      }
+      const receipt = yield* control.run({
+        _tag: "Plan",
+        planId: plan.planId,
+        digest: plan.digest,
+        envelope: plan.envelope,
+        idempotencyKey: idempotencyKey(input, `run:${input.runId ?? input.attempt}`),
+        principal,
+        ...input.runId === void 0 ? {} : { reservedRunId: input.runId }
+      });
+      return {
+        operation: input.operation,
+        applicationRequestId: input.applicationRequestId,
+        ownerGeneration: input.ownerGeneration,
+        runtimeArtifactDigest: config.runtimeArtifactDigest,
+        sourceRevision: input.sourceRevision,
+        planId: plan.planId,
+        planDigest: plan.digest,
+        ...plan.executionDigest === void 0 ? {} : { executionDigest: plan.executionDigest },
+        envelope: plan.envelope,
+        approval: plan.approval,
+        receipt
+      };
+    }
+    case "approve":
+    case "deny": {
+      const request = {
+        ...input.approval,
+        idempotencyKey: idempotencyKey(input, input.operation),
+        principal
+      };
+      const receipt = yield* input.operation === "approve" ? control.approve(request) : control.deny(request);
+      return { operation: input.operation, applicationRequestId: input.applicationRequestId, receipt };
+    }
+    case "signal": {
+      const receipt = yield* control.signal({
+        runId: input.runId,
+        signal: input.signal,
+        idempotencyKey: idempotencyKey(input, "signal"),
+        principal
+      });
+      return { operation: input.operation, applicationRequestId: input.applicationRequestId, receipt };
+    }
+    case "steer": {
+      const receipt = yield* control.steer({
+        runId: input.runId,
+        idempotencyKey: idempotencyKey(input, "steer"),
+        ...input.version === void 0 ? {} : { version: input.version },
+        message: {
+          ...input.steer,
+          runId: input.runId,
+          messageId: input.messageId,
+          createdAt: input.createdAt,
+          ...input.attribution === void 0 ? {} : { attribution: input.attribution },
+          principal
+        }
+      });
+      return { operation: input.operation, applicationRequestId: input.applicationRequestId, receipt };
+    }
+    // This authenticated host bridge is not a catalog or public Control
+    // verb. The executor validates the completed native child and resumes
+    // its retained parent to settle from that child's committed result.
+    case "complete": {
+      const executor = yield* import_effect.Effect.serviceOption(import_ControlExecutor.ControlExecutor);
+      const complete = config.requestComplete ?? (executor._tag === "Some" ? executor.value.requestComplete : void 0);
+      if (complete === void 0) {
+        return yield* import_effect.Effect.fail(
+          new BridgeError({
+            code: "unavailable",
+            message: "Completed-module settlement is unavailable",
+            retryable: true
+          })
+        );
+      }
+      const receipt = yield* complete({ runId: input.runId, receiptId: idempotencyKey(input, "complete") });
+      return { operation: input.operation, applicationRequestId: input.applicationRequestId, receipt };
+    }
+    case "cancel":
+    case "resume": {
+      const request = {
+        runId: input.runId,
+        idempotencyKey: idempotencyKey(input, input.operation),
+        ...input.reason === void 0 ? {} : { reason: input.reason },
+        principal
+      };
+      const receipt = yield* input.operation === "cancel" ? control.cancel(request) : control.resume(request);
+      return { operation: input.operation, applicationRequestId: input.applicationRequestId, receipt };
+    }
+  }
+});
+const cursorPosition = (cursor) => {
+  if (cursor === void 0 || cursor === "") return import_effect.Effect.succeed(void 0);
+  const match = observationCursorPattern.exec(cursor);
+  const sequence = Number(match?.[1] ?? match?.[2]);
+  const offset = match?.[3] === void 0 ? void 0 : Number(match[3]);
+  const valid = (value) => Number.isSafeInteger(value) && value >= 0 && value < Number.MAX_SAFE_INTEGER;
+  return match !== null && valid(sequence) && (offset === void 0 || valid(offset)) ? import_effect.Effect.succeed({ sequence, ...offset === void 0 ? {} : { offset } }) : import_effect.Effect.fail(
+    new BridgeError({
+      code: "invalid_request",
+      message: "Observation cursor is invalid or out of range",
+      retryable: false
+    })
+  );
+};
+const encodedCursor = (cursor) => cursor.offset === void 0 ? String(cursor.sequence) : `v1:${cursor.sequence}:${cursor.offset}`;
+const observe = (control, input, receipts) => import_effect.Effect.gen(function* () {
+  const after = yield* cursorPosition(input.afterCursor);
+  const limit = Math.min(input.limit ?? defaultEventLimit, maximumEventLimit);
+  const listed = yield* control.list({ _tag: "runs", filters: { runId: input.runId }, limit: 1 });
+  const summary = listed._tag === "runs" ? listed.items[0] : void 0;
+  if (summary === void 0) {
+    return yield* import_effect.Effect.fail(
+      new BridgeError({ code: "run_not_found", message: "Runtime execution was not found", retryable: true })
+    );
+  }
+  const events = Array.from(
+    yield* import_effect.Stream.runCollect(import_effect.Stream.take(
+      control.watch({
+        runId: input.runId,
+        ...after === void 0 ? {} : after.offset === void 0 ? { afterSequence: after.sequence } : { afterCursor: after },
+        follow: false
+      }),
+      limit + 1
+    ))
+  );
+  const page = events.slice(0, limit);
+  const last = page.at(-1);
+  let finalOutput;
+  let failure = {};
+  if (terminal.has(summary.status)) {
+    const projections = yield* Projections.make(control);
+    const snapshot = yield* projections.snapshot({ _tag: "run-summary", runId: input.runId });
+    const row = snapshot.rows.find(import_effect.Schema.is(import_GatewayProjection.RunSummaryRow));
+    if (row === void 0 || row.runId !== summary.runId || row.flowId !== summary.flowId || row.status !== summary.status || row.planId !== summary.planId || row.planDigest !== summary.planDigest) {
+      return yield* import_effect.Effect.fail(
+        new BridgeError({ code: "internal", message: "Terminal result observation changed", retryable: true })
+      );
+    }
+    finalOutput = row.finalOutput;
+    failure = {
+      ...row.failureFault === void 0 ? {} : { failureFault: row.failureFault },
+      ...row.failureTag === void 0 ? {} : { failureTag: row.failureTag }
+    };
+  }
+  const hostSummary = yield* import_effect.Schema.decodeUnknownEffect(import_ControlSchema.RunSummary)(summary);
+  const commandReceipt = receipts === void 0 ? void 0 : yield* receipts(input.runId);
+  if (commandReceipt !== void 0 && commandReceipt.runId !== input.runId) {
+    return yield* import_effect.Effect.fail(
+      new BridgeError({ code: "internal", message: "Host command receipt names another run", retryable: false })
+    );
+  }
+  return {
+    run: {
+      ...hostSummary,
+      ...commandReceipt === void 0 ? {} : { commandReceipt },
+      ...finalOutput === void 0 ? {} : { finalOutput },
+      ...failure
+    },
+    events: page,
+    nextCursor: last === void 0 ? input.afterCursor ?? "" : encodedCursor(last.cursor ?? { sequence: last.sequence }),
+    hasMore: events.length > limit,
+    terminal: terminal.has(summary.status)
+  };
+});
+const monitorJournals = /* @__PURE__ */ new WeakMap();
+const monitorJournalBytes = 64 * 1024 * 1024;
+const monitor = (control, runId, at) => import_effect.Effect.gen(function* () {
+  const listed = yield* control.list({ _tag: "runs", filters: { runId }, limit: 1 });
+  const run = listed._tag === "runs" ? listed.items[0] : void 0;
+  if (run === void 0 || run.runId !== runId) {
+    return yield* new BridgeError({
+      code: "run_not_found",
+      message: "Runtime execution was not found",
+      retryable: false
+    });
+  }
+  const cache = monitorJournals.get(control) ?? /* @__PURE__ */ new Map();
+  monitorJournals.set(control, cache);
+  const cached = cache.get(runId);
+  const last = cached?.records.at(-1)?.sequence;
+  const consumed = last === void 0 ? 0 : cached.records.filter((row) => row.sequence === last).length;
+  let skipped = 0;
+  const suffix = Array.from(
+    yield* import_effect.Stream.runCollect(
+      control.watch({
+        runId,
+        follow: false,
+        ...last === void 0 || last === 0 ? {} : { afterSequence: last - 1 }
+      }).pipe(
+        import_effect.Stream.filter(
+          (row) => last === void 0 || row.sequence > last || row.sequence === last && skipped++ >= consumed
+        ),
+        import_effect.Stream.take(Projections.maxEventsScanned + 1)
+      )
+    )
+  );
+  const records = [...cached?.records ?? [], ...suffix];
+  if (records.length > Projections.maxEventsScanned) {
+    return yield* new BridgeError({
+      code: "resource_limit",
+      message: "Run journal exceeds the inspection limit",
+      retryable: false
+    });
+  }
+  const bytes = (cached?.bytes ?? 0) + suffix.reduce((sum, row) => sum + new TextEncoder().encode(JSON.stringify(row)).byteLength, 0);
+  const current = cache.get(runId);
+  if (bytes <= monitorJournalBytes && (current === void 0 || current.records.length <= records.length)) {
+    cache.delete(runId);
+    cache.set(runId, { records, bytes });
+    let total = [...cache.values()].reduce((sum, entry) => sum + entry.bytes, 0);
+    while (cache.size > 32 || total > monitorJournalBytes) {
+      const oldest = cache.keys().next().value;
+      total -= cache.get(oldest).bytes;
+      cache.delete(oldest);
+    }
+  }
+  const folded = (0, import_RunTrace.monitorFromJournal)({ runId, flowId: run.flowId, status: run.status }, records, at);
+  let start = Infinity;
+  let end = 0;
+  for (const row of records) {
+    if (row.occurredAt > 0) {
+      start = Math.min(start, row.occurredAt);
+      end = Math.max(end, row.occurredAt);
+    }
+  }
+  const value = {
+    ...folded,
+    ...end === 0 ? {} : { extent: { start: new Date(start).toISOString(), end: new Date(end).toISOString() } }
+  };
+  if (at === void 0) delete value.journal;
+  if (new TextEncoder().encode(JSON.stringify(value)).byteLength > Projections.maxProjectionBytes) {
+    return yield* new BridgeError({
+      code: "resource_limit",
+      message: "Run monitor exceeds the inspection limit",
+      retryable: false
+    });
+  }
+  return value;
+});
+const CommandResponse = import_effect.Schema.Struct({
+  protocol: import_effect.Schema.Literal(protocol),
+  ok: import_effect.Schema.Literal(true),
+  value: import_effect.Schema.Struct({
+    operation: import_effect.Schema.String,
+    applicationRequestId: import_effect.Schema.String,
+    ownerGeneration: import_effect.Schema.optional(PositiveSafeInteger),
+    runtimeArtifactDigest: import_effect.Schema.optional(Sha256),
+    sourceRevision: import_effect.Schema.optional(SourceRevision),
+    planId: import_effect.Schema.optional(import_effect.Schema.String),
+    planDigest: import_effect.Schema.optional(Sha256),
+    executionDigest: import_effect.Schema.optional(Sha256),
+    envelope: import_effect.Schema.optional(import_effect.Schema.Json),
+    approval: import_effect.Schema.optional(import_ControlSchema.ApprovalPayload),
+    receipt: import_ControlSchema.Receipt
+  })
+});
+const ObserveResponse = import_effect.Schema.Struct({
+  protocol: import_effect.Schema.Literal(protocol),
+  ok: import_effect.Schema.Literal(true),
+  value: import_effect.Schema.Struct({
+    run: import_effect.Schema.Struct({
+      ...import_ControlSchema.RunSummary.fields,
+      finalOutput: import_effect.Schema.optional(import_effect.Schema.String),
+      failureFault: import_effect.Schema.optional(Fault.Class),
+      failureTag: import_effect.Schema.optional(import_effect.Schema.String),
+      commandReceipt: import_effect.Schema.optionalKey(CommandReceipt)
+    }),
+    events: import_effect.Schema.Array(import_ControlSchema.ControlEvent),
+    nextCursor: import_effect.Schema.String,
+    hasMore: import_effect.Schema.Boolean,
+    terminal: import_effect.Schema.Boolean
+  })
+});
+const ErrorResponse = import_effect.Schema.Struct({
+  protocol: import_effect.Schema.Literal(protocol),
+  ok: import_effect.Schema.Literal(false),
+  error: import_effect.Schema.Struct({ code: import_effect.Schema.String, message: import_effect.Schema.String, retryable: import_effect.Schema.Boolean })
+});
+const errorResponse = (cause) => {
+  const known = import_effect.Schema.is(ControlError.ControlErrorSchema)(cause);
+  const code = cause instanceof BridgeError || known ? cause.code : "internal";
+  const retryable = cause instanceof BridgeError ? cause.retryable : cause instanceof ControlError.TransportError ? cause.retryable : retryableCodes.has(code);
+  const message = cause instanceof BridgeError ? cause.message : "Runtime bridge failed";
+  const status = code === "unauthorized" ? 401 : notFoundCodes.has(code) ? 404 : conflictCodes.has(code) ? 409 : retryable ? 503 : code === "internal" ? 500 : 400;
+  return import_http.HttpServerResponse.jsonUnsafe({ protocol, ok: false, error: { code, message, retryable } }, { status });
+};
+const respondToFailure = (operation) => (cause) => {
+  const response = errorResponse(cause);
+  if (cause instanceof BridgeError) return import_effect.Effect.succeed(response);
+  const code = import_effect.Schema.is(ControlError.ControlErrorSchema)(cause) ? cause.code : "internal";
+  return import_effect.Effect.logError({ message: "Runtime bridge request failed", operation, code, cause }).pipe(
+    import_effect.Effect.as(response)
+  );
+};
+const readJson = import_effect.Effect.gen(function* () {
+  const request = yield* import_http.HttpServerRequest.HttpServerRequest;
+  const text = yield* request.text;
+  return yield* import_effect.Effect.try({
+    try: () => JSON.parse(text),
+    catch: () => new BridgeError({ code: "invalid_request", message: "Request body must be JSON", retryable: false })
+  });
+});
+const authenticated = (config, effect) => import_effect.Effect.gen(function* () {
+  const request = yield* import_http.HttpServerRequest.HttpServerRequest;
+  const principal = yield* config.authenticate(request.headers);
+  return yield* effect(principal);
+});
+const layer = (config) => {
+  const command = authenticated(config, (principal) => import_effect.Effect.gen(function* () {
+    const body = yield* readJson;
+    const input = yield* decodeCommand(body).pipe(import_effect.Effect.mapError(
+      () => new BridgeError({
+        code: "invalid_request",
+        message: "Request does not match the runtime bridge contract",
+        retryable: false
+      })
+    ));
+    const control = yield* import_Control.Control;
+    const value = yield* execute(config, control, principal, input);
+    return import_http.HttpServerResponse.jsonUnsafe({ protocol, ok: true, value });
+  })).pipe(
+    import_effect.Effect.catch(respondToFailure("runtime-bridge.command")),
+    import_effect.Effect.withSpan("runtime-bridge.command")
+  );
+  const observation = authenticated(config, () => import_effect.Effect.gen(function* () {
+    const body = yield* readJson;
+    const input = yield* decodeObserve(body).pipe(import_effect.Effect.mapError(
+      () => new BridgeError({
+        code: "invalid_request",
+        message: "Request does not match the observation contract",
+        retryable: false
+      })
+    ));
+    const control = yield* import_Control.Control;
+    const value = yield* observe(control, input, config.commandReceipt);
+    return import_http.HttpServerResponse.jsonUnsafe({ protocol, ok: true, value });
+  })).pipe(
+    import_effect.Effect.catch(respondToFailure("runtime-bridge.observe")),
+    import_effect.Effect.withSpan("runtime-bridge.observe")
+  );
+  const inspection = authenticated(config, () => import_effect.Effect.gen(function* () {
+    const body = yield* readJson;
+    const input = yield* import_effect.Schema.decodeUnknownEffect(import_effect.Schema.Struct({
+      protocol: import_effect.Schema.Literal(protocol),
+      runId: import_effect.Schema.NonEmptyString,
+      at: import_effect.Schema.optional(import_effect.Schema.Int.check(import_effect.Schema.isGreaterThanOrEqualTo(0)))
+    }))(body).pipe(import_effect.Effect.mapError(
+      () => new BridgeError({ code: "invalid_request", message: "Invalid monitor request", retryable: false })
+    ));
+    const control = yield* import_Control.Control;
+    return import_http.HttpServerResponse.jsonUnsafe({
+      protocol,
+      ok: true,
+      value: yield* monitor(control, input.runId, input.at)
+    });
+  })).pipe(import_effect.Effect.catch(respondToFailure("runtime-bridge.observe")));
+  return import_http.HttpRouter.add("POST", "/runtime/v1/command", command).pipe(
+    import_effect.Layer.merge(import_http.HttpRouter.add("POST", "/runtime/v1/monitor", inspection)),
+    import_effect.Layer.merge(import_http.HttpRouter.add("POST", "/runtime/v1/observe", observation))
+  );
+};
+//# sourceMappingURL=RuntimeBridge.js.map