@corca-org/ceal-host-linux-arm64 1.0.0

package/libexec/ceal-host/relay.mjs

@@ -0,0 +1,2987 @@
+#!/usr/bin/env node
+
+// packages/ceal-client-protocol/src/canonical-json.ts
+function cealCanonicalJson(value) {
+  if (value === null || typeof value === "string" || typeof value === "boolean") return JSON.stringify(value);
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) throw new TypeError("Ceal canonical JSON does not support non-finite numbers.");
+    return JSON.stringify(value);
+  }
+  if (value === void 0) throw new TypeError("Ceal canonical JSON does not support undefined values.");
+  if (Array.isArray(value)) {
+    const entries = [];
+    for (let index = 0; index < value.length; index += 1) {
+      if (!Object.hasOwn(value, index)) throw new TypeError("Ceal canonical JSON does not support sparse arrays.");
+      entries.push(cealCanonicalJson(value[index]));
+    }
+    return `[${entries.join(",")}]`;
+  }
+  if (!isPlainRecord(value)) throw new TypeError("Ceal canonical JSON only supports JSON data.");
+  return `{${Object.keys(value).sort(cealCompareOrdered).map((key) => `${JSON.stringify(key)}:${cealCanonicalJson(value[key])}`).join(",")}}`;
+}
+function cealCompareOrdered(left, right) {
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+function isPlainRecord(value) {
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+
+// packages/ceal-client-protocol/client-wire-contract.json
+var client_wire_contract_default = {
+  schema_version: "ceal.client_wire_contract.v1",
+  canonical_json: {
+    ordering: "utf16_code_unit_ascending"
+  },
+  artifact_descriptor: {
+    operation_contract_bundle_schema_version: "ceal.operation_contract_bundle.v1",
+    schema_version: "ceal.verified_artifact_descriptor.v1",
+    binding_schema_version: "ceal.verified_artifact_binding.v1",
+    kind: "verified_artifact",
+    binding_kind: "catalog",
+    media_type: "application/json",
+    digest: {
+      algorithm: "sha256",
+      encoding: "lowercase_hex",
+      length: 64,
+      pattern: "^[a-f0-9]{64}$"
+    },
+    catalog_revision: {
+      prefix: "catalog:",
+      digest_length: 64,
+      length: 72,
+      pattern: "^catalog:[a-f0-9]{64}$"
+    },
+    max_bytes: 4194304,
+    envelope_max_bytes: 389
+  },
+  command_request: {
+    schema_version: "ceal.command_request.v1",
+    absolute_transport_max_bytes: 65536
+  },
+  command_response: {
+    schema_version: "ceal.command_response.v1",
+    descriptor_field: "verified_artifact",
+    required_fields: [
+      "schema_version",
+      "exit_code",
+      "document"
+    ],
+    optional_fields: [
+      "verified_artifact"
+    ],
+    bare_document_fields: [
+      "invocation",
+      "next",
+      "common_concepts",
+      "operations",
+      "catalog_revision"
+    ],
+    exit_code_max: 125,
+    bare_document_max_bytes: 65536,
+    complete_max_bytes: 66019,
+    absolute_transport_max_bytes: 4194304
+  }
+};
+
+// packages/ceal-client-protocol/src/client-wire-contract.ts
+var CEAL_CLIENT_WIRE_CONTRACT = Object.freeze(client_wire_contract_default);
+var artifact = CEAL_CLIENT_WIRE_CONTRACT.artifact_descriptor;
+var request = CEAL_CLIENT_WIRE_CONTRACT.command_request;
+var response = CEAL_CLIENT_WIRE_CONTRACT.command_response;
+var CEAL_OPERATION_CONTRACT_BUNDLE_SCHEMA_VERSION = artifact.operation_contract_bundle_schema_version;
+var CEAL_VERIFIED_ARTIFACT_DESCRIPTOR_SCHEMA_VERSION = artifact.schema_version;
+var CEAL_VERIFIED_ARTIFACT_BINDING_SCHEMA_VERSION = artifact.binding_schema_version;
+var CEAL_VERIFIED_ARTIFACT_KIND = artifact.kind;
+var CEAL_VERIFIED_ARTIFACT_BINDING_KIND = artifact.binding_kind;
+var CEAL_VERIFIED_ARTIFACT_MEDIA_TYPE = artifact.media_type;
+var CEAL_VERIFIED_ARTIFACT_DIGEST_LENGTH = artifact.digest.length;
+var CEAL_VERIFIED_ARTIFACT_DIGEST_PATTERN = artifact.digest.pattern;
+var CEAL_VERIFIED_ARTIFACT_CATALOG_REVISION_LENGTH = artifact.catalog_revision.length;
+var CEAL_VERIFIED_ARTIFACT_CATALOG_REVISION_PATTERN = artifact.catalog_revision.pattern;
+var CEAL_VERIFIED_ARTIFACT_MAX_BYTES = artifact.max_bytes;
+var CEAL_VERIFIED_ARTIFACT_DESCRIPTOR_MAX_BYTES = artifact.envelope_max_bytes;
+var CEAL_COMMAND_REQUEST_SCHEMA_VERSION = request.schema_version;
+var CEAL_COMMAND_REQUEST_MAX_BYTES = request.absolute_transport_max_bytes;
+var CEAL_COMMAND_RESPONSE_BARE_DOCUMENT_FIELDS = response.bare_document_fields;
+var CEAL_COMMAND_RESPONSE_BARE_DOCUMENT_MAX_BYTES = response.bare_document_max_bytes;
+var CEAL_COMMAND_RESPONSE_MAX_BYTES = response.absolute_transport_max_bytes;
+
+// packages/ceal-client-protocol/src/vocabulary.ts
+function vocabulary(words) {
+  return Object.freeze(words);
+}
+
+// packages/ceal-client-protocol/src/operation-contract-types.ts
+var CEAL_JSON_SCHEMA_2020_12 = "https://json-schema.org/draft/2020-12/schema";
+var CEAL_OPERATION_ERROR_SCHEMA_VERSION = "ceal.operation_error.v1";
+var CEAL_JSON_SCHEMA_TYPES = vocabulary(["object", "array", "string", "integer", "number", "boolean", "null"]);
+var OBSERVATION_POSTURES = vocabulary(["direct_readback", "approved_no_readback", "operator_mediated", "excluded"]);
+var EFFECT_DOMAINS = vocabulary(["none", "gateway_state", "provider", "external_world"]);
+var SAFETY_CLASSES = vocabulary(["routine", "sensitive", "high_impact"]);
+var IDEMPOTENCY_CLASSES = vocabulary(["idempotent", "conditionally_idempotent", "non_idempotent"]);
+var REVERSIBILITY_CLASSES = vocabulary(["none", "reversible", "compensatable", "irreversible"]);
+var COMPENSATION_OWNERS = vocabulary(["none", "connector", "operator"]);
+var CANCELLATION_BOUNDARIES = vocabulary(["before_admission", "before_handoff", "after_handoff_reconcile"]);
+var HANDOFF_CLASSES = vocabulary(["not_applicable", "submission", "effect"]);
+var AUTHORITATIVE_READBACK_CLASSES = vocabulary(["required", "unavailable"]);
+var PROVIDER_READBACK_CLASSES = vocabulary(["required", "not_available", "not_applicable"]);
+var RECONCILIATION_CLASSES = vocabulary(["none", "automatic", "operator"]);
+var NO_READBACK_APPROVAL_CLASSES = vocabulary(["not_applicable", "explicit", "operator"]);
+var REPLAY_PREREQUISITES = vocabulary(["never", "fresh_admission", "reconciled_non_application", "operator_approval"]);
+var UNKNOWN_OUTCOMES = vocabulary(["reconcile", "operator_action", "excluded"]);
+var RECOVERY_OWNERS = vocabulary(["gateway", "connector", "operator"]);
+var CEAL_OPERATION_ADMISSION_STATES = vocabulary(["proposed", "refused", "admitted"]);
+var CEAL_OPERATION_EXECUTION_STATES = vocabulary(["not_started", "started", "completed"]);
+var CEAL_OPERATION_PROVIDER_HANDOFF_STATES = vocabulary(["not_offered", "offered", "accepted", "rejected", "unknown"]);
+var CEAL_OPERATION_EFFECT_STATES = vocabulary(["none", "applied", "failed", "unknown", "compensated"]);
+var CEAL_OPERATION_OBSERVATION_STATES = vocabulary(["not_started", "not_required", "pending", "observed", "unavailable"]);
+var CEAL_OPERATION_RECOVERY_KINDS = vocabulary(["none", "reconcile", "compensate", "operator_action"]);
+var CEAL_OPERATION_RECOVERY_STATUSES = vocabulary(["not_started", "active", "completed"]);
+var CEAL_OPERATION_PROVIDER_READBACK_AVAILABILITY = vocabulary(["not_started", "not_applicable", "not_available", "pending", "available"]);
+var CEAL_OPERATION_OFFERED_HANDOFF_STATES = vocabulary(["accepted", "rejected", "unknown"]);
+var CEAL_OPERATION_APPROVAL_DISPOSITIONS = vocabulary([
+  "approval_not_required_by_policy",
+  "interactive_pending",
+  "interactive_granted",
+  "interactive_denied",
+  "interactive_expired",
+  "interactive_unavailable"
+]);
+
+// packages/ceal-client-protocol/src/gateway-response-types.ts
+var CEAL_CAPABILITY_READINESS_VALUES = vocabulary(["ready", "degraded", "unavailable", "unknown"]);
+var CEAL_TARGET_REQUIREMENTS = vocabulary(["required", "optional", "none"]);
+var CEAL_AUDIT_OUTCOMES = vocabulary(["succeeded", "denied", "failed"]);
+var CEAL_GATEWAY_PROVIDER_STEP_OUTCOMES = vocabulary(["completed", "rejected", "throttled", "failed"]);
+var CEAL_POLICY_DECISIONS = vocabulary(["allowed", "denied", "not_evaluated"]);
+var CEAL_CONNECTOR_ROUTE_PHASES = vocabulary(["scope_observation", "target_selection", "route_resolution"]);
+var CEAL_CONNECTOR_ROUTE_CAUSES = vocabulary(["provider_throttled", "provider_unavailable", "binding_invalid", "scope_limit_exceeded"]);
+var CEAL_WRITE_SOURCE_KINDS = vocabulary(["authenticated_registered_client", "agent_lease_admission", "provider_authenticated_event"]);
+var CEAL_REFRESH_DELIVERIES = vocabulary(["initial", "recovery", "replay", "terminal_failure", "recovery_unavailable"]);
+var CEAL_CLIENT_OPERATIONS = vocabulary(["handshake", "discover", "call", "readback"]);
+var CEAL_WRITE_IDEMPOTENCY_POSTURES = vocabulary(["required", "optional", "not_required"]);
+var CEAL_WRITE_PROVIDER_READBACK_POSTURES = vocabulary(["required", "best_effort", "not_available"]);
+var CEAL_WRITE_ATTRIBUTIONS = vocabulary(["subject", "requester_event", "connector_integration"]);
+var CEAL_PROTOCOL_VERSION = "1.4.0";
+var CEAL_CONNECTOR_ROUTE_FAILURE_KEYS = vocabulary(["connector_kind", "phase", "schema_version"]);
+var CEAL_CLASSIFIED_CONNECTOR_ROUTE_FAILURE_KEYS = vocabulary(["cause", ...CEAL_CONNECTOR_ROUTE_FAILURE_KEYS]);
+var CEAL_UNCLASSIFIED_CONNECTOR_ROUTE_FAILURE_KEYS = vocabulary(["connector_kind", "error_class", "phase", "schema_version"]);
+
+// packages/ceal-client-protocol/src/gateway-validation-primitives.ts
+var CealProtocolValidationError = class extends Error {
+  name = "CealProtocolValidationError";
+  code;
+  constructor(code) {
+    super(code === "invalid_gateway_request" ? "Ceal Gateway request is invalid." : "Ceal client response is invalid.");
+    this.code = code;
+  }
+};
+var SAFE_REF = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u;
+var MAX_SAFE_TOKEN_LENGTH = 64;
+var SAFE_CODE = new RegExp(`^[a-z][a-z0-9_]{0,${MAX_SAFE_TOKEN_LENGTH - 1}}$`, "u");
+var SAFE_CONNECTOR_KIND = new RegExp(`^[a-z][a-z0-9-]{0,${MAX_SAFE_TOKEN_LENGTH - 1}}$`, "u");
+var FORBIDDEN_SECRET_KEY = /^(?:[a-z0-9_]*(?:token|secret|password|credential(?:s)?|private_?key)|api_?key|authorization|bearer|raw_?provider_?payload|provider_?payload)$/iu;
+var FORBIDDEN_AUTHORITY_KEY = /^(?:actor_?ref|owner_?ref|registration_?ref|runner_?ref|auth_?decision|policy_?decision|host_?decision)$/iu;
+var TEXT_ENCODER = new TextEncoder();
+var CEAL_WIRE_SAFE_TEXT_MAX_BYTES = 8 * 1024;
+function assertSafeJsonValue(value, options, depth = 0, count = { value: 0 }) {
+  count.value += 1;
+  if (depth > 8 || count.value > (options.maxNodes ?? 512)) invalidByContext(options);
+  if (value === null || typeof value === "boolean") return;
+  if (typeof value === "number") return assertSafeJsonNumber(value, options);
+  if (typeof value === "string") return assertSafeJsonString(value, options);
+  if (Array.isArray(value)) {
+    return assertSafeJsonArray(value, options, depth, count);
+  }
+  assertSafeJsonRecord(requireRecord(value), options, depth, count);
+}
+function assertSafeJsonNumber(value, options) {
+  if (!Number.isFinite(value)) invalidByContext(options);
+}
+function assertSafeJsonString(value, options) {
+  if (byteLength(value) > CEAL_WIRE_SAFE_TEXT_MAX_BYTES || firstDisallowedControl(value, "multi_line") !== null) invalidByContext(options);
+}
+function assertSafeJsonArray(value, options, depth, count) {
+  if (value.length > 128) invalidByContext(options);
+  for (const item of value) assertSafeJsonValue(item, options, depth + 1, count);
+}
+function assertSafeJsonRecord(record6, options, depth, count) {
+  const entries = Object.entries(record6);
+  if (entries.length > 128) invalidByContext(options);
+  const sourceUrlColumn = options.allowHttpsUrl ? compactSourceUrlColumn(record6.fields) : null;
+  for (const [key, child] of entries) {
+    if (key === "credential_material_included" && child !== false) invalidByContext(options);
+    if (!isSafeNegativeMaterialAssertion(key, child)) assertSafeJsonKey(key, options);
+    if (key === "rows" && sourceUrlColumn !== null) {
+      assertSafeJsonCompactRows(child, sourceUrlColumn, options, depth, count);
+      continue;
+    }
+    assertSafeJsonRecordChild(key, child, options, depth, count);
+  }
+}
+function assertSafeJsonRecordChild(key, child, options, depth, count) {
+  if (options.allowResultContent && (key === "text" || key === "text_preview")) {
+    if (!isSafeResultContent(child, key)) invalidByContext(options);
+    return;
+  }
+  if ((key === "url" || key === "source_url") && options.allowHttpsUrl && isSafeExternalHttpsUrl(child)) return;
+  assertSafeJsonValue(child, options, depth + 1, count);
+}
+function compactSourceUrlColumn(fields) {
+  if (!Array.isArray(fields)) return null;
+  const index = fields.indexOf("source_url");
+  return index < 0 ? null : index;
+}
+function assertSafeJsonCompactRows(value, sourceUrlColumn, options, depth, count) {
+  if (!Array.isArray(value) || value.length > 128) invalidByContext(options);
+  for (const row of value) {
+    if (!Array.isArray(row) || row.length > 128) invalidByContext(options);
+    for (const [index, cell] of row.entries()) {
+      if (index === sourceUrlColumn && (cell === null || isSafeExternalHttpsUrl(cell))) continue;
+      assertSafeJsonValue(cell, options, depth + 2, count);
+    }
+  }
+}
+function isSafeNegativeMaterialAssertion(key, value) {
+  return key === "credential_material_included" && value === false;
+}
+function assertSafeJsonKey(key, options) {
+  const invalid2 = !/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/u.test(key) || FORBIDDEN_SECRET_KEY.test(key) || options.forbidAuthorityKeys && FORBIDDEN_AUTHORITY_KEY.test(key);
+  if (invalid2) invalidByContext(options);
+}
+function isSafeExternalHttpsUrl(value) {
+  if (!isSafeExternalHttpsUrlInput(value)) return false;
+  try {
+    const url = new URL(value);
+    return isSafeExternalHttpsUrlShape(url);
+  } catch {
+    return false;
+  }
+}
+function isSafeExternalHttpsUrlInput(value) {
+  return typeof value === "string" && byteLength(value) <= 2048;
+}
+function isSafeExternalHttpsUrlShape(url) {
+  return url.protocol === "https:" && url.username === "" && url.password === "" && url.hash === "";
+}
+function isSafeResultContent(value, key) {
+  const maximum = key === "text" ? 8192 : 1024;
+  return typeof value === "string" && byteLength(value) <= maximum && firstDisallowedControl(value, "multi_line") === null;
+}
+function normalizeCealSingleLineText(value) {
+  return value.split("").map((character) => hasControlCharacter(character) ? " " : character).join("").trim();
+}
+function byteLength(value) {
+  return TEXT_ENCODER.encode(value).byteLength;
+}
+var LAYOUT_CODE_POINTS = [9, 10, 13];
+function firstDisallowedControl(value, shape) {
+  let index = 0;
+  for (const character of value) {
+    const codePoint = character.codePointAt(0) ?? 0;
+    const laysOutALine = shape === "multi_line" && LAYOUT_CODE_POINTS.includes(codePoint);
+    if (!laysOutALine && (codePoint <= 31 || codePoint === 127)) return { codePoint, index };
+    index += character.length;
+  }
+  return null;
+}
+function hasControlCharacter(value) {
+  return firstDisallowedControl(value, "single_line") !== null;
+}
+var AUTHORITY_METADATA_SUFFIX = "(?:_(?:refs?|revisions?|versions?|generations?|ids?))*$";
+var UNDECLARED_AUTHORITY_STATE_KEY = new RegExp(`(?:^|_)(?:decisions?|authority|grants?|policy|policies|scopes?|tokens?|credentials?|secrets?|permissions?|roles?)${AUTHORITY_METADATA_SUFFIX}`, "iu");
+var UNDECLARED_HANDLE_REF_KEY = new RegExp(`(?:^|_)refs?${AUTHORITY_METADATA_SUFFIX}`, "iu");
+function requireRecord(value) {
+  if (!isCealJsonRecord(value)) invalidRequestOrResponse();
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== Object.prototype && prototype !== null) invalidRequestOrResponse();
+  return value;
+}
+function isCealJsonRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+var CEAL_VALIDATION_STATUSES = vocabulary(["not_applicable", "valid", "invalid"]);
+var CEAL_PARSE_STATUSES = vocabulary(["not_applicable", "parsed", "parse_failed"]);
+function invalidByContext(options) {
+  if (options.forbidAuthorityKeys) invalidRequest();
+  invalidResponse();
+}
+var InvalidWireShapeError = class extends Error {
+};
+function invalidRequestOrResponse() {
+  throw new InvalidWireShapeError();
+}
+function invalidRequest() {
+  throw new CealProtocolValidationError("invalid_gateway_request");
+}
+function invalidResponse() {
+  throw new CealProtocolValidationError("invalid_client_response");
+}
+
+// packages/ceal-client-protocol/src/refusal-fact.ts
+var REFUSAL_VALUE_MAX_CHARS = 160;
+function renderText(value) {
+  return normalizeCealSingleLineText(value);
+}
+var REFUSAL_LIST_HEAD = 5;
+var REFUSAL_FACTS_MAX_CHARS = 360;
+var REFUSAL_SENTENCE_MAX_BYTES = 384;
+var REFUSAL_CLOSING_MAX_BYTES = REFUSAL_SENTENCE_MAX_BYTES / 2;
+function refusalFact(name, value, expected) {
+  const rendered = `${JSON.stringify(name)}=${renderRefusalValue(value)}`;
+  return expected === void 0 ? rendered : `${rendered}; expected ${cut(renderText(expected))}`;
+}
+function refusalFacts(facts) {
+  const joined = facts.map((fact) => refusalFact(fact.name, fact.value, fact.expected)).join("; ");
+  return joined.length <= REFUSAL_FACTS_MAX_CHARS ? joined : `${joined.slice(0, REFUSAL_FACTS_MAX_CHARS)}...(+${joined.length - REFUSAL_FACTS_MAX_CHARS} chars, ${facts.length} facts)`;
+}
+function renderRefusalValue(value) {
+  if (typeof value === "object" && value !== null) return renderStructure(value);
+  if (typeof value === "string") return cut(JSON.stringify(renderText(value)));
+  if (typeof value === "function") return `function ${value.name === "" ? "(anonymous)" : value.name} -- a fact must be a value`;
+  if (typeof value === "symbol") return value.toString();
+  if (typeof value === "bigint") return `${value}n`;
+  return String(value);
+}
+function renderStructure(value) {
+  if (Array.isArray(value)) return cut(renderList(value));
+  if (value instanceof Error) return `${value.name}${"code" in value && typeof value.code === "string" ? `(${value.code})` : ""}`;
+  if (value instanceof Date) return value.toISOString();
+  if (ArrayBuffer.isView(value)) return `<${value.byteLength} bytes>`;
+  return renderRecord(value);
+}
+function renderRecord(value) {
+  if (value instanceof Map) return cut(renderList([...value].map(([key, entry2]) => `${renderRefusalValue(key)}=${renderRefusalValue(entry2)}`), true));
+  if (value instanceof Set) return cut(renderList([...value]));
+  if (isStatRecord(value)) return `{"mode":"0o${Number(value.mode).toString(8)}","size":${Number(value.size)},"kind":"${statKind(value)}"}`;
+  return cut(renderText(JSON.stringify(value, serializable) ?? String(value)));
+}
+function statKind(value) {
+  if (value.isDirectory()) return "directory";
+  return value.isFile() ? "file" : "other";
+}
+function isStatRecord(value) {
+  return "mode" in value && (typeof value.mode === "number" || typeof value.mode === "bigint") && "size" in value && (typeof value.size === "number" || typeof value.size === "bigint") && "isDirectory" in value && typeof value.isDirectory === "function" && "isFile" in value && typeof value.isFile === "function";
+}
+function serializable(_key, entry2) {
+  if (typeof entry2 === "bigint") return `${entry2}n`;
+  return ArrayBuffer.isView(entry2) ? `<${entry2.byteLength} bytes>` : entry2;
+}
+function renderList(value, rendered = false) {
+  const head = value.slice(0, REFUSAL_LIST_HEAD).map((item) => rendered ? String(item) : renderRefusalValue(item));
+  const rest = value.length - head.length;
+  return `[${head.join(", ")}${rest > 0 ? `, ...${rest} more` : ""}] (${value.length} items)`;
+}
+function cut(text) {
+  return text.length <= REFUSAL_VALUE_MAX_CHARS ? text : `${text.slice(0, REFUSAL_VALUE_MAX_CHARS)}...(+${text.length - REFUSAL_VALUE_MAX_CHARS} chars)`;
+}
+
+// packages/ceal-client-protocol/src/safe-json-budget.ts
+var SAFE_JSON_MIN_BYTES_PER_NODE = 4;
+function safeJsonNodeBudgetForBytes(maxBytes) {
+  if (!Number.isSafeInteger(maxBytes) || maxBytes < SAFE_JSON_MIN_BYTES_PER_NODE) {
+    throw new RangeError(`safe-JSON byte cap is invalid: ${refusalFact("maxBytes", maxBytes, `at least ${SAFE_JSON_MIN_BYTES_PER_NODE} bytes`)}`);
+  }
+  return Math.floor(maxBytes / SAFE_JSON_MIN_BYTES_PER_NODE);
+}
+
+// packages/ceal-client-protocol/src/protocol-bounds.ts
+var CEAL_PROTOCOL_RESPONSE_VALUE_MAX_BYTES = 64 * 1024;
+var CEAL_PROTOCOL_RESPONSE_VALUE_MAX_NODES = safeJsonNodeBudgetForBytes(CEAL_PROTOCOL_RESPONSE_VALUE_MAX_BYTES);
+var OPERATION_SCHEMA_LITERAL_MAX_BYTES = CEAL_PROTOCOL_RESPONSE_VALUE_MAX_BYTES / 4;
+var CEAL_OPERATION_JSON_SCHEMA_BUDGET = Object.freeze({
+  max_depth: 8,
+  max_properties: 96,
+  max_string_length: OPERATION_SCHEMA_LITERAL_MAX_BYTES / 4,
+  max_alternatives: 8,
+  max_enum_values: 64,
+  max_literal_bytes: OPERATION_SCHEMA_LITERAL_MAX_BYTES
+});
+
+// packages/ceal-client-protocol/src/operation-validation-primitives.ts
+var ISO_TIMESTAMP = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{3})?Z$/u;
+function isOperationRecord(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function requireOperationRecord(value, message) {
+  if (!isOperationRecord(value)) throw new TypeError(message);
+}
+function requireClosedValue(value, members, message) {
+  if (typeof value !== "string" || !members.includes(value)) throw new TypeError(message);
+}
+function requireIsoTimestamp(value, message) {
+  if (typeof value !== "string" || !ISO_TIMESTAMP.test(value) || !Number.isFinite(Date.parse(value))) throw new TypeError(message);
+}
+
+// packages/ceal-client-protocol/src/operation-contract-validation.ts
+var CEAL_OPERATION_AUTHORITY_POLICY_KEYS = Object.freeze(["profile", "instance_binding", "target", "admission_recheck"]);
+var MAX_OPERATION_INPUT_RESOLVER_BINDINGS = 96;
+var CEAL_OPERATION_RESULT_KEYS = vocabulary(["ok", "operation_id", "operation_receipt", "schema_version", "value"]);
+var CEAL_OPERATION_COMPACT_RESULT_KEYS = vocabulary(["ok", "operation_evidence", "operation_id", "schema_version", "value"]);
+
+// packages/ceal-client-protocol/src/operation-catalog.ts
+var CEAL_OPERATION_CATALOG_SCHEMA_VERSION = "ceal.catalog.v3";
+var CLIENT_AUDIENCES = Object.freeze(["ceal", "cealctl", "agent"]);
+var CLIENT_AUDIENCE_SET = new Set(CLIENT_AUDIENCES);
+
+// packages/ceal-client-protocol/src/schema-literals.ts
+var CEAL_SCHEMA_LITERALS = [
+  "ceal.activation_transport.v1",
+  "ceal.capability_access.v1",
+  CEAL_OPERATION_CATALOG_SCHEMA_VERSION,
+  "ceal.client_refresh_request.v2",
+  "ceal.client_refresh_result.v2",
+  "ceal.client_revoke_request.v1",
+  "ceal.client_revoke_result.v1",
+  CEAL_COMMAND_REQUEST_SCHEMA_VERSION,
+  "ceal.device_enrollment_challenge.v1",
+  "ceal.device_enrollment_challenge_request.v1",
+  "ceal.device_enrollment_hpke_aad.v1",
+  "ceal.device_enrollment_hpke_info.v1",
+  "ceal.device_enrollment_poll.v1",
+  "ceal.device_enrollment_poll_result.v1",
+  "ceal.device_enrollment_proof.v1",
+  "ceal.device_enrollment_start.v1",
+  "ceal.device_enrollment_start_result.v1",
+  "ceal.effect_approval.v1",
+  "ceal.effect_approval_confirmation.v1",
+  "ceal.enrollment_create.v1",
+  "ceal.enrollment_create_result.v1",
+  "ceal.enrollment_exchange.v1",
+  "ceal.enrollment_result.v1",
+  "ceal.first_activation_causal_join.v1",
+  "ceal.gateway_aggregate_authorization_snapshot.v2",
+  "ceal.gateway_announcement_policy.v1",
+  "ceal.gateway_audit_call_detail.v1",
+  "ceal.gateway_audit_event.v1",
+  "ceal.gateway_audit_readback.v1",
+  "ceal.gateway_authorization_snapshot.v1",
+  "ceal.gateway_cache_origin.v1",
+  "ceal.gateway_call_result.v1",
+  "ceal.gateway_command_resolution.v1",
+  "ceal.gateway_connector_route_failure.v1",
+  "ceal.gateway_discovery.v3",
+  "ceal.gateway_handshake.v1",
+  "ceal.gateway_installation_activation_code_issue_request.v1",
+  "ceal.gateway_installation_activation_code_issue_result.v1",
+  "ceal.gateway_installation_activation_code_list_result.v1",
+  "ceal.gateway_installation_activation_code_revoke_request.v1",
+  "ceal.gateway_installation_activation_code_revoke_result.v1",
+  "ceal.gateway_installation_activation_credential.v1",
+  "ceal.gateway_installation_activation_request.v1",
+  "ceal.gateway_installation_active_state.v1",
+  "ceal.gateway_installation_list_result.v1",
+  "ceal.gateway_installation_revoke_request.v1",
+  "ceal.gateway_installation_revoke_result.v1",
+  "ceal.gateway_policy_denial.v1",
+  "ceal.gateway_rate_limit_policy.v1",
+  "ceal.gateway_refresh_audit_detail.v1",
+  "ceal.gateway_scoped_identity_projection.v1",
+  "ceal.gateway_write_receipt_readback.v1",
+  "ceal.gateway_write_request_receipt.v1",
+  "ceal.host_observation.v1",
+  "ceal.host_registration_request.v1",
+  "ceal.host_registration_result.v1",
+  "ceal.leased-resource-stream.v2",
+  "ceal.leased_consumer_attachment_stream_frame.v2",
+  "ceal.leased_consumer_attachment_stream_request.v2",
+  "ceal.leased_consumer_attachment_stream_transport.v2",
+  "ceal.operation_descriptor.v1",
+  "ceal.operation_error.v1",
+  "ceal.operation_failure.v1",
+  "ceal.operation_receipt.v1",
+  "ceal.operation_result.v1",
+  "ceal.operation_result.compact.v1",
+  "ceal.local_result_materialization.v1",
+  "ceal.local_result_root.v1",
+  "ceal.owner_bootstrap_exchange_request.v1",
+  "ceal.owner_bootstrap_exchange_result.v1",
+  "ceal.protocol_negotiation.v1",
+  "ceal.request.v1",
+  "ceal.request_artifact.v1",
+  "ceal.request_cancellation.v1",
+  "ceal.request_graph_revision.v1",
+  "ceal.request_occurrence_correlation.v1",
+  "ceal.request_projection.v1"
+];
+var CEAL_SCHEMA_LITERAL_SET = new Set(CEAL_SCHEMA_LITERALS);
+
+// packages/ceal-client-protocol/src/bounded-series.ts
+import { join } from "node:path";
+var CEAL_BOUNDED_SERIES_CATALOG = Object.freeze({
+  usage_record: (root) => join(root, "run-usage.jsonl"),
+  control_commit: (root) => join(root, "control-auto-commit.jsonl"),
+  engagement_signal: (root) => join(root, "runtime-state", "slack-feedback.jsonl"),
+  runtime_error: (root) => join(root, "runtime-state", "runtime-errors.jsonl"),
+  provider_retry: (root) => join(root, "observability", "provider-retry-queue", "queue.jsonl"),
+  turn_bridge_request: (root) => join(root, ".ceal", "turn-bridge", "requests.jsonl"),
+  channel_log: (root) => join(root, "log.jsonl"),
+  thread_run_events: (root) => join(root, "run-events.jsonl"),
+  bounded_store_sidecar: (root) => `${root}.jsonl`,
+  gateway_audit_archive: (root) => `${root}.jsonl`,
+  gateway_capability_audit: (root) => join(root, "capability-audit.jsonl"),
+  gateway_retrieval_waste_partition: (root) => `${root}.jsonl`,
+  gateway_access_policy_publication: (root) => join(root, "access-policy-publications.jsonl"),
+  gateway_event_lease_journal: (root) => `${root}.journal.jsonl`,
+  gateway_control_audit: (root) => `${root}.control-audits.jsonl`,
+  gateway_profile_connector_control_audit: (root) => `${root}.audit.jsonl`,
+  gateway_profile_connector_scope_audit: (root) => join(root, "profile-connector-scope-audit.jsonl"),
+  gateway_profile_connector_activity_scope_audit: (root) => join(root, "profile-connector-activity-scope-audit.jsonl"),
+  gateway_profile_connector_readiness_audit: (root) => join(root, "profile-connector-readiness.audit.jsonl"),
+  gateway_organization_audit_ledger: (root) => join(root, "organization-ledger.jsonl"),
+  gateway_personal_client_audit: (root) => join(root, "audit.jsonl"),
+  gateway_personal_client_access_audit: (root) => join(root, "access-audit.jsonl"),
+  gateway_admin_enrollment: (root) => join(root, "enrollments.jsonl"),
+  gateway_admin_login: (root) => join(root, "logins.jsonl"),
+  gateway_admin_family: (root) => join(root, "families.jsonl"),
+  gateway_admin_refresh_token: (root) => join(root, "refresh-tokens.jsonl"),
+  gateway_admin_access_token: (root) => join(root, "access-tokens.jsonl")
+});
+
+// packages/ceal-client-protocol/src/host-registration.ts
+var CEAL_HOST_REGISTRATION_RESULT_KEYS = Object.freeze(["credential_generation", "host_access_token", "host_installation_ref", "host_source_ref", "ok", "registration_attempt_ref", "schema_version", "status"]);
+
+// packages/ceal-client-protocol/src/agent-session-handoff.ts
+var CEAL_AGENT_ADMISSION_PHASES = vocabulary([
+  "incumbent_admitted",
+  "incumbent_draining",
+  "drained",
+  "candidate_admitted",
+  "candidate_draining",
+  "rollback_admitted"
+]);
+var CEAL_AGENT_SERVICE_SESSION_RECORD_KEYS = vocabulary([
+  "admission_fence",
+  "admission_state",
+  "admission_state_generation",
+  "bearer",
+  "consumer_ref",
+  "credential_generation",
+  "expires_at",
+  "gateway_instance",
+  "gateway_origin",
+  "gateway_serving_generation",
+  "issued_at",
+  "record_sha256",
+  "renew_after",
+  "renew_by",
+  "schema_version",
+  "session_revision"
+]);
+var CEAL_AGENT_SESSION_COMMIT_KEYS = vocabulary(["attempt_ref", "expected_session_revision", "session_revision"]);
+
+// packages/ceal-client-protocol/src/operation-next-actions.ts
+var CALLER_RECOVERABLE_NEXT_ACTION_VALUES = [
+  "select_did_you_mean",
+  // The graph, not the argument list, is what the caller must change: the
+  // resolver that owns this input has no producing node upstream, and no edit
+  // to the invocation can conjure one. `resolver_dependency_absent` carried no
+  // remedy at all rather than borrow a word that means something else, so the
+  // scorer read a fully-diagnosed, caller-fixable refusal as a failed run.
+  "request.graph.append",
+  "choose_new_output_path",
+  "choose_new_idempotency_key",
+  "restart_search",
+  "repeat_original_arguments",
+  "choose_new_request_identity",
+  // A refusal that names the argument (invalid_argument with `property`) tells the caller exactly what to change.
+  "correct_argument",
+  // A resolver-owned input must move from caller operands into the declared
+  // resolver selection field.
+  "supply_resolver_selections",
+  // The graph names an upstream node whose Operation produces the resolver's
+  // occurrence, and it has not produced one yet. The caller runs that node
+  // first; the refusal used to share a code with a malformed resolver result,
+  // which is not fixable, so neither could carry a remedy.
+  "run_resolver_dependency",
+  // A replay carries the input the occurrence durably admitted, and this one
+  // carries a different one. The caller fixes it by presenting the original
+  // invocation, so it is a remedy; the coordinator minted the word at the
+  // replay guard and never declared it, which read as unguided to the scorer.
+  "use_original_input",
+  // The same mismatch on the Request binding rather than the input: the
+  // occurrence was admitted under one binding and the replay presents another.
+  "use_original_request_binding"
+];
+var CEAL_CALLER_RECOVERABLE_NEXT_ACTIONS = Object.freeze(CALLER_RECOVERABLE_NEXT_ACTION_VALUES);
+var NON_REMEDY_NEXT_ACTION_VALUES = [
+  "await_pending_approval",
+  "check_gateway",
+  "inspect_context_store",
+  "inspect_gateway",
+  "inspect_local_cache",
+  // The thin client prints these on its own behalf, before or after the wire.
+  // They were declared only as `CealClientLocalRemedy` keys and, for two of
+  // them, only as Go string literals -- a second and third vocabulary for one
+  // thing. `CealClientLocalRemedy` derives from this list now, so the client's
+  // remedies cannot drift from the words the protocol knows.
+  "inspect_local_client",
+  "inspect_local_command",
+  "inspect_local_output",
+  "inspect_local_route",
+  "inspect_receipt",
+  "inspect_request",
+  "none",
+  "recover",
+  "reconcile",
+  // Reconciliation of one named occurrence, not of the deployment: a legacy
+  // occurrence with no admitted input commitment cannot be replayed safely and
+  // no edit to the call changes that. `reconcile` is the deployment-wide word.
+  "reconcile_occurrence",
+  "reduce_request_size",
+  "repair_or_adopt_session",
+  "request.effect_approval.read",
+  "request.run",
+  "retry",
+  // The owner -- a correlation hook, an approval hook -- is not serving right
+  // now. The caller changes nothing and the same call succeeds once the owner
+  // is back, so this is not a remedy the scorer may count as guidance.
+  "retry_after_owner_recovery",
+  "retry_same_receipt_read",
+  "run_file_search_again",
+  "select_exact_approval"
+];
+var CEAL_NON_REMEDY_NEXT_ACTIONS = Object.freeze(NON_REMEDY_NEXT_ACTION_VALUES);
+var DECLARED = /* @__PURE__ */ new Set([...CEAL_CALLER_RECOVERABLE_NEXT_ACTIONS, ...CEAL_NON_REMEDY_NEXT_ACTIONS]);
+var RECOVERABLE = new Set(CEAL_CALLER_RECOVERABLE_NEXT_ACTIONS);
+
+// packages/ceal-client-protocol/src/operation-contract-artifact.ts
+var CATALOG_REVISION = new RegExp(CEAL_VERIFIED_ARTIFACT_CATALOG_REVISION_PATTERN, "u");
+var SHA256 = new RegExp(CEAL_VERIFIED_ARTIFACT_DIGEST_PATTERN, "u");
+var CEAL_OPERATION_CONTRACT_REQUIRED_FIELDS = Object.freeze(["input_schema", "result_schema"]);
+var CEAL_OPERATION_CONTRACT_OPTIONAL_FIELDS = Object.freeze(["summary", "input_resolution"]);
+var CEAL_VERIFIED_ARTIFACT_DESCRIPTOR_JSON_SCHEMA = Object.freeze({
+  $schema: CEAL_JSON_SCHEMA_2020_12,
+  $id: "https://ceal.dev/schemas/verified-artifact-descriptor.v1.schema.json",
+  title: "Ceal verified artifact descriptor",
+  type: "object",
+  additionalProperties: false,
+  required: ["schema_version", "kind", "media_type", "byte_count", "sha256", "binding"],
+  properties: {
+    schema_version: { const: CEAL_VERIFIED_ARTIFACT_DESCRIPTOR_SCHEMA_VERSION },
+    kind: { const: CEAL_VERIFIED_ARTIFACT_KIND },
+    media_type: { const: CEAL_VERIFIED_ARTIFACT_MEDIA_TYPE },
+    byte_count: { type: "integer", minimum: 1, maximum: CEAL_VERIFIED_ARTIFACT_MAX_BYTES },
+    sha256: { type: "string", minLength: CEAL_VERIFIED_ARTIFACT_DIGEST_LENGTH, maxLength: CEAL_VERIFIED_ARTIFACT_DIGEST_LENGTH, pattern: CEAL_VERIFIED_ARTIFACT_DIGEST_PATTERN },
+    binding: {
+      type: "object",
+      additionalProperties: false,
+      required: ["schema_version", "kind", "catalog_revision"],
+      properties: {
+        schema_version: { const: CEAL_VERIFIED_ARTIFACT_BINDING_SCHEMA_VERSION },
+        kind: { const: CEAL_VERIFIED_ARTIFACT_BINDING_KIND },
+        catalog_revision: { type: "string", minLength: CEAL_VERIFIED_ARTIFACT_CATALOG_REVISION_LENGTH, maxLength: CEAL_VERIFIED_ARTIFACT_CATALOG_REVISION_LENGTH, pattern: CEAL_VERIFIED_ARTIFACT_CATALOG_REVISION_PATTERN }
+      }
+    }
+  }
+});
+
+// packages/ceal-client-protocol/src/operation-occurrence.ts
+var MAX_RECEIPT_REVISION = Number.MAX_SAFE_INTEGER - 1;
+
+// packages/ceal-client-protocol/src/leased-resource-stream.ts
+var CEAL_LEASED_CONSUMER_ATTACHMENT_STREAM_MAGIC = new Uint8Array([67, 69, 65, 76, 82, 83, 50, 0]);
+var CEAL_LEASED_CONSUMER_ATTACHMENT_STREAM_RECORD_PREFIX_BYTES = 8;
+var CEAL_LEASED_CONSUMER_ATTACHMENT_STREAM_MAX_HEADER_BYTES = 16 * 1024;
+var CEAL_LEASED_CONSUMER_ATTACHMENT_STREAM_CHUNK_BYTES = 64 * 1024;
+var CEAL_LEASED_CONSUMER_ATTACHMENT_STREAM_MAX_RECORD_BYTES = CEAL_LEASED_CONSUMER_ATTACHMENT_STREAM_RECORD_PREFIX_BYTES + CEAL_LEASED_CONSUMER_ATTACHMENT_STREAM_MAX_HEADER_BYTES + CEAL_LEASED_CONSUMER_ATTACHMENT_STREAM_CHUNK_BYTES;
+var CEAL_ATTACHMENT_UNREAD_REASONS = vocabulary(["blocked", "unavailable", "too_large", "unsupported", "download_failed", "digest_mismatch"]);
+
+// packages/ceal-client-protocol/src/request-validation-primitives.ts
+import { createHash } from "node:crypto";
+var DIGEST = /^[a-f0-9]{64}$/u;
+function isCealDigest(value) {
+  return typeof value === "string" && DIGEST.test(value);
+}
+function cealRequestSha256(value) {
+  return createHash("sha256").update(cealCanonicalJson(value), "utf8").digest("hex");
+}
+function operationRecord(value, message) {
+  requireOperationRecord(value, message);
+  return value;
+}
+function invalid(message) {
+  throw new TypeError(message);
+}
+function requirePrefixedRef(value, prefix, message) {
+  if (typeof value !== "string" || !SAFE_REF.test(value) || !value.startsWith(prefix)) invalid(message);
+}
+
+// packages/ceal-client-protocol/src/request-authority.ts
+var CEAL_REQUEST_SCHEMA_VERSION = "ceal.request.v1";
+var CEAL_REQUEST_ARTIFACT_OWNERS = vocabulary(["gateway", "host", "connector"]);
+var CEAL_REQUEST_HOST_BINDING_KEYS = vocabulary(["prompt_ref", "host_session_ref", "host_turn_ref", "host_source_ref"]);
+var CEAL_REQUEST_ARTIFACT_RETENTION_CLASSES = vocabulary(["request", "source", "result"]);
+var CANCELLATION_STATES = vocabulary(["requested", "cancelled"]);
+var CEAL_REQUEST_KEYS = Object.freeze(["schema_version", "ceal_request_ref", "created_at", "authority", "prompt_ref", "host_session_ref", "host_turn_ref", "host_source_ref"]);
+var CEAL_REQUEST_JSON_SCHEMA = {
+  type: "object",
+  maxProperties: 9,
+  additionalProperties: false,
+  properties: {
+    schema_version: { type: "string", const: CEAL_REQUEST_SCHEMA_VERSION, maxLength: 32 },
+    ceal_request_ref: { type: "string", minLength: 1, maxLength: 128, pattern: "^ceal-request:[A-Za-z0-9][A-Za-z0-9._:-]{0,114}$" },
+    created_at: { type: "string", minLength: 1, maxLength: 64 },
+    authority: {
+      type: "object",
+      maxProperties: 5,
+      additionalProperties: false,
+      properties: {
+        instance_ref: { type: "string", minLength: 1, maxLength: 128, pattern: SAFE_REF.source },
+        profile_ref: { type: "string", minLength: 1, maxLength: 128, pattern: SAFE_REF.source },
+        principal_ref: { type: "string", minLength: 1, maxLength: 128, pattern: SAFE_REF.source },
+        execution_subject_ref: { type: "string", minLength: 1, maxLength: 128, pattern: SAFE_REF.source },
+        authority_revision_ref: { type: "string", minLength: 1, maxLength: 128, pattern: SAFE_REF.source }
+      },
+      required: ["instance_ref", "profile_ref", "principal_ref", "execution_subject_ref", "authority_revision_ref"]
+    },
+    prompt_ref: { type: "string", minLength: 1, maxLength: 128, pattern: SAFE_REF.source },
+    host_session_ref: { type: "string", minLength: 1, maxLength: 128, pattern: SAFE_REF.source },
+    host_turn_ref: { type: "string", minLength: 1, maxLength: 128, pattern: SAFE_REF.source },
+    host_input_ref: { type: "string", minLength: 1, maxLength: 128, pattern: SAFE_REF.source },
+    host_source_ref: { type: "string", minLength: 1, maxLength: 128, pattern: SAFE_REF.source }
+  },
+  required: CEAL_REQUEST_KEYS
+};
+
+// packages/ceal-client-protocol/src/request-operands.ts
+var CEAL_REQUEST_MAX_RESOLVER_SELECTIONS = 128;
+var CEAL_REQUEST_MAX_SELECTOR_PROPERTIES = 16;
+var CEAL_REQUEST_MAX_SELECTOR_VALUE_LENGTH = 1024;
+var CEAL_REQUEST_RESOLVER_SELECTION_JSON_SCHEMA = {
+  type: "object",
+  maxProperties: 2,
+  additionalProperties: false,
+  properties: {
+    property: { type: "string", minLength: 1, maxLength: 128 },
+    selectors: {
+      type: "object",
+      maxProperties: CEAL_REQUEST_MAX_SELECTOR_PROPERTIES,
+      properties: {},
+      additionalProperties: { type: "string", minLength: 1, maxLength: CEAL_REQUEST_MAX_SELECTOR_VALUE_LENGTH }
+    }
+  },
+  required: ["property", "selectors"]
+};
+
+// packages/ceal-client-protocol/src/request-graph.ts
+var CEAL_REQUEST_MAX_GRAPH_NODES = 128;
+
+// packages/ceal-client-protocol/src/request-run.ts
+var CEAL_REQUEST_NODE_STANDING_OCCURRENCE_SCHEMA_VERSION = "ceal.request_node_standing_occurrence.v1";
+var CEAL_REQUEST_RUN_BATCH_SCHEMA_VERSION = "ceal.request_run_batch.v3";
+var REQUEST_ACTION_SAFE_REF_SCHEMA = { type: "string", minLength: 1, maxLength: 128, pattern: SAFE_REF.source };
+var REQUEST_ACTION_DIGEST_SCHEMA = { type: "string", minLength: 64, maxLength: 64, pattern: "^[a-f0-9]{64}$" };
+var REQUEST_NODE_STANDING_OCCURRENCE_SCHEMA = {
+  type: "object",
+  maxProperties: 9,
+  additionalProperties: false,
+  properties: {
+    schema_version: { type: "string", const: CEAL_REQUEST_NODE_STANDING_OCCURRENCE_SCHEMA_VERSION, maxLength: 64 },
+    node_ref: REQUEST_ACTION_SAFE_REF_SCHEMA,
+    operation_id: REQUEST_ACTION_SAFE_REF_SCHEMA,
+    correlation_ref: REQUEST_ACTION_SAFE_REF_SCHEMA,
+    occurrence_ref: REQUEST_ACTION_SAFE_REF_SCHEMA,
+    graph_revision: { type: "integer", minimum: 1, maximum: Number.MAX_SAFE_INTEGER },
+    graph_revision_digest: REQUEST_ACTION_DIGEST_SCHEMA,
+    admitted_input_sha256: REQUEST_ACTION_DIGEST_SCHEMA,
+    reason: { type: "string", minLength: 1, maxLength: 1024 }
+  },
+  required: ["schema_version", "node_ref", "operation_id", "correlation_ref", "occurrence_ref", "graph_revision", "graph_revision_digest", "admitted_input_sha256", "reason"]
+};
+var REQUEST_EXECUTION_PREPARE_REFUSAL_SCHEMA = {
+  type: "object",
+  additionalProperties: false,
+  maxProperties: 9,
+  properties: {
+    schema_version: { type: "string", const: CEAL_OPERATION_ERROR_SCHEMA_VERSION, maxLength: 64 },
+    code: REQUEST_ACTION_SAFE_REF_SCHEMA,
+    message: { type: "string", minLength: 1, maxLength: 2048 },
+    property: { type: "string", minLength: 1, maxLength: 256 },
+    next_action: REQUEST_ACTION_SAFE_REF_SCHEMA,
+    retryable: { type: "boolean" },
+    repaired_input: {},
+    unrepaired_pointers: { type: "array", maxItems: 128, items: { type: "string", minLength: 1, maxLength: 256 } },
+    provider_handoff: { type: "string", const: "not_offered", maxLength: 32 }
+  },
+  required: ["schema_version", "code", "message", "next_action", "retryable"]
+};
+var CEAL_REQUEST_EXECUTION_ORDERS = vocabulary(["graph_dependency", "caller"]);
+var CEAL_REQUEST_CALL_BUDGET_JSON_SCHEMA = {
+  type: "object",
+  additionalProperties: false,
+  maxProperties: 2,
+  properties: {
+    gateway_calls_so_far: { type: "integer", minimum: 1, maximum: Number.MAX_SAFE_INTEGER },
+    floor_for_this_graph: { type: "integer", minimum: 1, maximum: Number.MAX_SAFE_INTEGER }
+  },
+  required: ["gateway_calls_so_far", "floor_for_this_graph"]
+};
+var CEAL_REQUEST_RUN_BATCH_JSON_SCHEMA = {
+  type: "object",
+  additionalProperties: false,
+  maxProperties: 5,
+  properties: {
+    schema_version: { type: "string", const: CEAL_REQUEST_RUN_BATCH_SCHEMA_VERSION, maxLength: 64 },
+    order: { enum: [...CEAL_REQUEST_EXECUTION_ORDERS] },
+    nodes: {
+      type: "array",
+      minItems: 1,
+      maxItems: CEAL_REQUEST_MAX_GRAPH_NODES,
+      items: {
+        // The runtime validator owns "exactly one of a result, a refusal
+        // and a standing run". The result envelope already names the
+        // Operation that ran.
+        type: "object",
+        additionalProperties: false,
+        maxProperties: 4,
+        properties: { node_ref: REQUEST_ACTION_SAFE_REF_SCHEMA, result: {}, refusal: REQUEST_EXECUTION_PREPARE_REFUSAL_SCHEMA, standing: REQUEST_ACTION_SAFE_REF_SCHEMA },
+        required: ["node_ref"]
+      }
+    },
+    standing_reading: { type: "string", minLength: 1, maxLength: 512 },
+    call_budget: CEAL_REQUEST_CALL_BUDGET_JSON_SCHEMA
+  },
+  required: ["schema_version", "order", "nodes", "call_budget"]
+};
+
+// packages/ceal-client-protocol/src/host-observation.ts
+var CEAL_HOST_OBSERVATION_REF_PREFIX = "host-observation:";
+function validateCealHostObservationDraft(value) {
+  const record6 = operationRecord(value, "Ceal Host observation draft is invalid.");
+  requirePrefixedRef(record6.observation_ref, CEAL_HOST_OBSERVATION_REF_PREFIX, "Ceal Host observation reference is invalid.");
+  requireClosedValue(record6.observation_kind, CEAL_HOST_OBSERVATION_KINDS, "Ceal Host observation kind is invalid.");
+  requireIsoTimestamp(record6.observed_at, "Ceal Host observation time is invalid.");
+  assertHostObservationValue(record6.value, record6.observation_kind);
+}
+var CEAL_REQUEST_MAX_OBSERVATION_VALUE_BYTES = 64 * 1024;
+var CEAL_HOST_OBSERVATION_KINDS = vocabulary(["prompt", "session", "turn", "model", "token", "cost", "timing"]);
+function isCealHostPromptObservationValue(value) {
+  return isOperationRecord(value) && Object.keys(value).length === 1 && isCealDigest(value.body_sha256);
+}
+var HOST_RESERVED_KEY = /^(?:admission|approval|audit|authorization|cancellation|capability|effect|grant|occurrence|operation|policy|profile|provider_readback|receipt|reconciliation|replay|target|write_request)(?:_|$)/iu;
+function assertHostObservationValue(value, kind) {
+  if (value === void 0) invalid("Ceal Host observation value is invalid.");
+  if (kind === "prompt" && !isCealHostPromptObservationValue(value)) invalid("Ceal Host prompt observation must contain only its body digest.");
+  assertSafeJsonValue(value, { forbidAuthorityKeys: true, maxNodes: 512 });
+  if (byteLength(JSON.stringify(value) ?? "") > CEAL_REQUEST_MAX_OBSERVATION_VALUE_BYTES) invalid("Ceal Host observation value is oversized.");
+  inspectHostKeys(value);
+}
+function inspectHostKeys(value) {
+  if (Array.isArray(value)) {
+    for (const entry2 of value) inspectHostKeys(entry2);
+    return;
+  }
+  if (value === null || typeof value !== "object") return;
+  for (const [key, child] of Object.entries(value)) {
+    if (HOST_RESERVED_KEY.test(key)) invalid("Ceal Host observation cannot restate Gateway-owned facts.");
+    inspectHostKeys(child);
+  }
+}
+
+// packages/ceal-client-protocol/src/request-effect-approval.ts
+var CEAL_EFFECT_APPROVAL_DECISION_CHECK_PHRASES = Object.freeze([
+  "observed after this approval was raised and before it expires",
+  "from this same Host session and Host source",
+  "not the Host input that opened the Request",
+  "an input that has decided no other approval"
+]);
+var CEAL_EFFECT_APPROVAL_DECISION_INSTRUCTION = `Submit exactly one phrase below in a Host input ${CEAL_EFFECT_APPROVAL_DECISION_CHECK_PHRASES.join(", ")}.`;
+
+// packages/ceal-client-protocol/src/request-projection.ts
+var CEAL_REQUEST_STATUSES = vocabulary(["pending", "partial", "completed", "cancelled", "failed", "unknown_effect", "reconciled", "incomplete", "contradiction"]);
+var OWNER_WRITE_STATES = Object.freeze(["attempt_started", "provider_acknowledged", "verified", "outcome_unknown", "reconciled"]);
+var OWNER_EFFECT_STATES = Object.freeze(["none", "applied", "failed", "unknown", "reconciled"]);
+var OWNER_RECEIPT_STATES = Object.freeze(["pending", "available", "failed", "unknown", "reconciled"]);
+
+// packages/ceal-client-protocol/src/request-graph-readiness.ts
+var REQUEST_GRAPH_PRODUCER_TO_APPEND_SCHEMA = {
+  type: "object",
+  maxProperties: 4,
+  additionalProperties: false,
+  properties: {
+    operation_id: { type: "string", minLength: 1, maxLength: 128 },
+    edge_to_node_ref: { type: "string", minLength: 1, maxLength: 128 },
+    edge_from_node_refs: { type: "array", minItems: 1, maxItems: CEAL_REQUEST_MAX_GRAPH_NODES, items: { type: "string", minLength: 1, maxLength: 128 } },
+    remedy: { type: "string", minLength: 1, maxLength: 512 }
+  },
+  required: ["operation_id", "edge_to_node_ref", "remedy"]
+};
+var REQUEST_GRAPH_RESOLVER_CONSUMERS_SCHEMA = {
+  type: "object",
+  maxProperties: 2,
+  additionalProperties: false,
+  properties: {
+    consumer_node_refs: { type: "array", minItems: 1, maxItems: CEAL_REQUEST_MAX_GRAPH_NODES, items: { type: "string", minLength: 1, maxLength: 128 } },
+    remedy: { type: "string", minLength: 1, maxLength: 512 }
+  },
+  required: ["consumer_node_refs", "remedy"]
+};
+var REQUEST_GRAPH_RESOLVER_REUSE_SCHEMA = {
+  type: "object",
+  maxProperties: 3,
+  additionalProperties: false,
+  properties: {
+    reuse_node_ref: { type: "string", minLength: 1, maxLength: 128 },
+    consumer_node_refs: { type: "array", maxItems: CEAL_REQUEST_MAX_GRAPH_NODES, items: { type: "string", minLength: 1, maxLength: 128 } },
+    remedy: { type: "string", minLength: 1, maxLength: 512 }
+  },
+  required: ["reuse_node_ref", "consumer_node_refs", "remedy"]
+};
+var RESOLVER_OWNED_INPUT_SCHEMA = {
+  type: "object",
+  maxProperties: 5,
+  additionalProperties: false,
+  properties: {
+    property: { type: "string", minLength: 1, maxLength: 128 },
+    resolver_operation_id: { type: "string", minLength: 1, maxLength: 128 },
+    resolver_selection_template: CEAL_REQUEST_RESOLVER_SELECTION_JSON_SCHEMA,
+    producing_node_refs: { type: "array", maxItems: CEAL_REQUEST_MAX_RESOLVER_SELECTIONS, items: { type: "string", minLength: 1, maxLength: 128 } },
+    append_producer: REQUEST_GRAPH_PRODUCER_TO_APPEND_SCHEMA
+  },
+  required: ["property", "resolver_operation_id", "producing_node_refs"]
+};
+var USER_OPERANDS_TEMPLATE_SCHEMA = {
+  type: "object",
+  maxProperties: 2,
+  additionalProperties: false,
+  properties: {
+    required_properties: { type: "array", maxItems: MAX_OPERATION_INPUT_RESOLVER_BINDINGS, items: { type: "string", minLength: 1, maxLength: 128 } },
+    operands: { type: "object", properties: {}, maxProperties: MAX_OPERATION_INPUT_RESOLVER_BINDINGS, additionalProperties: {} }
+  },
+  required: ["required_properties", "operands"]
+};
+var CEAL_REQUEST_GRAPH_NODE_PREPARE_READINESS_JSON_SCHEMA = {
+  type: "object",
+  maxProperties: 9,
+  additionalProperties: false,
+  properties: {
+    node_ref: { type: "string", minLength: 1, maxLength: 128 },
+    operation_id: { type: "string", minLength: 1, maxLength: 128 },
+    resolver_owned: { type: "array", maxItems: MAX_OPERATION_INPUT_RESOLVER_BINDINGS, items: RESOLVER_OWNED_INPUT_SCHEMA },
+    gateway_derived: { type: "array", maxItems: MAX_OPERATION_INPUT_RESOLVER_BINDINGS, items: { type: "string", minLength: 1, maxLength: 128 } },
+    result_bound: { type: "array", maxItems: MAX_OPERATION_INPUT_RESOLVER_BINDINGS, items: { type: "string", minLength: 1, maxLength: 128 } },
+    user_operands_template: { type: "array", maxItems: CEAL_OPERATION_JSON_SCHEMA_BUDGET.max_alternatives, items: USER_OPERANDS_TEMPLATE_SCHEMA },
+    unfed_resolver: REQUEST_GRAPH_RESOLVER_CONSUMERS_SCHEMA,
+    redundant_resolver: REQUEST_GRAPH_RESOLVER_REUSE_SCHEMA,
+    standing_occurrence: REQUEST_NODE_STANDING_OCCURRENCE_SCHEMA
+  },
+  required: ["node_ref", "operation_id", "resolver_owned", "gateway_derived"]
+};
+
+// packages/ceal-client-protocol/src/host-invocation-authentication.ts
+var CEAL_HOST_INVOCATION_AUTHENTICATION_RESULT_SCHEMA = "ceal.host_invocation_authentication_result.v1";
+var CEAL_HOST_INVOCATION_CONTEXT_PATH = "/api/ceal/v2/host-invocation-context";
+var CEAL_HOST_CLIENT_NONCE_PATTERN = /^[A-Za-z0-9_-]{43}$/u;
+var CEAL_HOST_CONTEXT_TOKEN_PATTERN = /^ceal_context_[A-Za-z0-9_-]{43}$/u;
+function decodeCealHostInvocationAuthenticationResult(value, now = /* @__PURE__ */ new Date()) {
+  if (!isCealJsonRecord(value) || !exactKeys(value, ["schema_version", "context_token", "expires_at"]) || value.schema_version !== CEAL_HOST_INVOCATION_AUTHENTICATION_RESULT_SCHEMA || typeof value.context_token !== "string" || !CEAL_HOST_CONTEXT_TOKEN_PATTERN.test(value.context_token) || typeof value.expires_at !== "string" || !validFutureTimestamp(value.expires_at, now)) {
+    throw new TypeError("The Host invocation authentication result is invalid.");
+  }
+  return Object.freeze({ schema_version: CEAL_HOST_INVOCATION_AUTHENTICATION_RESULT_SCHEMA, context_token: value.context_token, expires_at: value.expires_at });
+}
+function validFutureTimestamp(value, now) {
+  const timestamp3 = Date.parse(value);
+  return Number.isFinite(timestamp3) && new Date(timestamp3).toISOString() === value && timestamp3 > now.getTime();
+}
+function exactKeys(value, expected) {
+  const keys = Object.keys(value);
+  return keys.length === expected.length && expected.every((key) => Object.hasOwn(value, key));
+}
+
+// packages/ceal-client-protocol/src/client-result-materialization.ts
+var REQUIRED_FIELDS = Object.freeze(["schema_version", "operation_id", "local_path", "content_json_pointer", "size_bytes", "sha256", "read_argv"]);
+var FIELDS = /* @__PURE__ */ new Set([...REQUIRED_FIELDS, "local_result_root", "model_disclosure"]);
+
+// packages/ceal-client-protocol/src/conversation-contracts.ts
+var CEAL_APPROVAL_POLICY_KINDS = vocabulary(["requester_only", "named_users", "role_based"]);
+var CEAL_APPROVAL_TARGET_KINDS = vocabulary([
+  "repo_change",
+  "investigation",
+  "skill_creation",
+  "command_creation",
+  "connector_creation",
+  "generic"
+]);
+var CEAL_PROGRESS_PHASES = vocabulary(["request_review", "information_gathering", "work_execution", "result_check"]);
+
+// packages/ceal-client-protocol/src/gateway-cache-origin-validation.ts
+var CEAL_MAX_CACHE_ORIGIN_AGE_MS = 30 * 24 * 60 * 60 * 1e3;
+
+// packages/ceal-client-protocol/src/gateway-write-contract.ts
+var CEAL_GATEWAY_WRITE_CONTRACT_CLOSED_VOCABULARIES = Object.freeze({
+  idempotency: CEAL_WRITE_IDEMPOTENCY_POSTURES,
+  provider_readback: CEAL_WRITE_PROVIDER_READBACK_POSTURES,
+  dry_run: Object.freeze(["supported", "unsupported"]),
+  attribution: CEAL_WRITE_ATTRIBUTIONS,
+  provenance_binding: Object.freeze(["gateway_attested_requester_event_v1"])
+});
+var REQUIRED_KEYS = Object.freeze(["side_effect_class", "idempotency", "provider_readback"]);
+
+// packages/ceal-client-protocol/src/gateway-proof-claims.ts
+var CEAL_GATEWAY_PROOF_AXES = Object.freeze(["host_decision", "provider_execution", "production_audit"]);
+var CEAL_GATEWAY_PROOF_AXIS_NON_CLAIMS = Object.freeze({
+  host_decision: null,
+  provider_execution: "provider_execution_not_reached",
+  production_audit: "production_audit_not_reached"
+});
+var CEAL_PROOF_LEVELS = vocabulary(["surface", "readiness", "worker_queued", "host_decision", "provider_roundtrip"]);
+var CEAL_GATEWAY_HOST_NON_CLAIM_ORDER = Object.freeze(["provider_execution_not_reached", "target_authorization_not_observed", "production_audit_not_reached"]);
+var CEAL_GATEWAY_ANNOUNCEMENT_POLICY_NON_CLAIMS = vocabulary([
+  "policy_projection_does_not_authorize",
+  "provider_roundtrip_not_established_by_discovery",
+  "target_specific_scope_not_declared"
+]);
+
+// packages/ceal-client-protocol/src/gateway-discovery-response-validation.ts
+var ANNOUNCEMENT_POLICY_CAPABILITY_BINDINGS = Object.freeze({
+  "github.repository.get": [{ effect: "read", scopeStatementKind: "github_app_installation_repositories", providerAuthorityKind: "github_app" }],
+  "collection.search": [{ effect: "read", scopeStatementKind: "github_app_installation_repositories", providerAuthorityKind: "github_app" }],
+  "github.issue.get": [{ effect: "read", scopeStatementKind: "github_app_installation_repositories", providerAuthorityKind: "github_app" }],
+  "github.pull_request.get": [{ effect: "read", scopeStatementKind: "github_app_installation_repositories", providerAuthorityKind: "github_app" }],
+  "github.workflow_run.get": [{ effect: "read", scopeStatementKind: "github_app_installation_repositories", providerAuthorityKind: "github_app" }],
+  "message.search": [{ effect: "read", scopeStatementKind: "slack_public_app_member_channels_only", providerAuthorityKind: "slack_app" }],
+  "message.get": [{ effect: "read", scopeStatementKind: "slack_public_app_member_channels_only", providerAuthorityKind: "slack_app" }],
+  "resource.resolve": [
+    { effect: "read", scopeStatementKind: "slack_public_app_member_channels_only", providerAuthorityKind: "slack_app" },
+    { effect: "read", scopeStatementKind: "notion_connected_logical_area", providerAuthorityKind: "notion_integration" }
+  ],
+  "conversation.thread.get": [{ effect: "read", scopeStatementKind: "slack_public_app_member_channels_only", providerAuthorityKind: "slack_app" }],
+  "notion.search": [{ effect: "read", scopeStatementKind: "notion_connected_logical_area", providerAuthorityKind: "notion_integration" }],
+  "notion.page.get": [{ effect: "read", scopeStatementKind: "notion_connected_logical_area", providerAuthorityKind: "notion_integration" }],
+  "calendar.availability": [{ effect: "read", scopeStatementKind: "google_workspace_calendar_read_only", providerAuthorityKind: "google_service_account" }],
+  "calendar.event.search": [{ effect: "read", scopeStatementKind: "google_workspace_calendar_read_only", providerAuthorityKind: "google_service_account" }],
+  "calendar.event.get": [{ effect: "read", scopeStatementKind: "google_workspace_calendar_read_only", providerAuthorityKind: "google_service_account" }],
+  "file.search": [{ effect: "read", scopeStatementKind: "google_workspace_ceal_drive_or_direct_share_metadata", providerAuthorityKind: "google_service_account" }],
+  "sheets.values.read": [{ effect: "read", scopeStatementKind: "google_workspace_ceal_drive_or_direct_share_sheet_ranges", providerAuthorityKind: "google_service_account" }],
+  "sheets.tabs.list": [{ effect: "read", scopeStatementKind: "google_workspace_ceal_drive_or_direct_share_sheet_tabs", providerAuthorityKind: "google_service_account" }],
+  "sheets.values.update": [{ effect: "write", scopeStatementKind: "google_workspace_ceal_drive_or_direct_share_editable_sheet_ranges", providerAuthorityKind: "google_service_account" }],
+  "sheets.values.clear": [{ effect: "write", scopeStatementKind: "google_workspace_ceal_drive_or_direct_share_editable_sheet_clear_ranges", providerAuthorityKind: "google_service_account" }]
+});
+var ANNOUNCEMENT_SCOPE_STATEMENTS = Object.freeze({
+  github_app_installation_repositories: "Repositories in the installed GitHub App installation.",
+  slack_public_app_member_channels_only: "Public channels where the installed Slack app is a member; private channels, direct messages, multi-person direct messages, and requester membership are not declared by this connector.",
+  notion_connected_logical_area: "Connected Notion logical area under provider-enforced sharing; descendant inventory is not declared.",
+  google_workspace_calendar_read_only: "Approved Calendar availability and event reads only; Calendar mutation is not declared.",
+  google_workspace_ceal_drive_or_direct_share_metadata: "Metadata search for files in the organization shared drive named Ceal Drive and files directly shared with the provider application; file-content read and mutation are not declared.",
+  google_workspace_ceal_drive_or_direct_share_sheet_ranges: "Bounded values reads from governed Google Sheets in the organization shared drive named Ceal Drive and directly shared files; file mutation is not declared.",
+  google_workspace_ceal_drive_or_direct_share_editable_sheet_ranges: "Bounded values updates in governed editable Google Sheets in the organization shared drive named Ceal Drive and directly shared files; Docs, Slides, and other Drive file mutation are not declared.",
+  google_workspace_ceal_drive_or_direct_share_editable_sheet_clear_ranges: "Bounded values clears in governed editable Google Sheets in the organization shared drive named Ceal Drive and directly shared files; Docs, Slides, and other Drive file mutation are not declared."
+});
+
+// packages/ceal-client-protocol/src/gateway-write-identity.ts
+var CEAL_GATEWAY_WRITE_IDENTITY_ROLES = Object.freeze(["replay_identity", "lookup_handle", "collision_evidence"]);
+var CEAL_GATEWAY_WRITE_IDENTITY_FIELDS = Object.freeze({
+  replay_identity: "idempotency_claim_sha256",
+  lookup_handle: "write_request_sha256",
+  collision_evidence: "normalized_mutation_sha256"
+});
+
+// packages/ceal-client-protocol/src/gateway-scoped-identity-projection-validation.ts
+var PROJECTION_REVISION_KEYS = Object.freeze(["graph_revision", "subject_key_revision", "projection_revision"]);
+
+// packages/ceal-client-protocol/src/protocol-negotiation.ts
+var CEAL_SUPPORTED_GATEWAY_PROTOCOL_RANGE = Object.freeze({
+  minimum: CEAL_PROTOCOL_VERSION,
+  maximum: CEAL_PROTOCOL_VERSION
+});
+
+// packages/ceal-client-protocol/src/admin-projection-vocabulary.ts
+var ADMIN_PROJECTION_STATES = vocabulary(["ready", "empty", "partial", "unknown"]);
+var ADMIN_VIEW_KINDS = vocabulary(["request_detail", "resource_access_timeline", "weekly_usage"]);
+var ADMIN_GAP_KINDS = vocabulary(["unknown", "unavailable", "partial"]);
+var ADMIN_UNAVAILABLE_REASONS = vocabulary([
+  "not_recorded",
+  "legacy",
+  "invalid_observation",
+  "redacted",
+  "owner_unavailable",
+  "unit_unknown",
+  "retention_gap",
+  "source_owner_limit"
+]);
+var ADMIN_SOURCE_OWNERS = vocabulary([
+  "request",
+  "operation",
+  "authority",
+  "occurrence",
+  "approval",
+  "audit",
+  "provider_readback",
+  "host_observation",
+  "person",
+  "resource",
+  "prompt",
+  "usage"
+]);
+var ADMIN_COMPLETENESS_STATES = vocabulary(["complete", "partial", "unknown"]);
+var ADMIN_OPERATION_OUTCOMES = vocabulary(["completed", "failed", "denied", "cancelled", "unknown"]);
+var ADMIN_APPROVAL_DISPOSITIONS = CEAL_OPERATION_APPROVAL_DISPOSITIONS;
+var ADMIN_APPROVAL_POSTURES = vocabulary([...ADMIN_APPROVAL_DISPOSITIONS, "not_applicable"]);
+var ADMIN_LINEAGE_NODE_KINDS = vocabulary(["source_read", "synthesis_preview", "approval", "effect", "readback"]);
+
+// packages/ceal-client-protocol/src/actor-kind.ts
+var CEAL_ACTOR_KINDS = vocabulary(["human", "bot", "app", "unknown"]);
+
+// packages/ceal-client-protocol/src/leased-consumer-vocabulary.ts
+var CEAL_TERMINAL_DISPOSITIONS = vocabulary(["completed", "failed", "cancelled"]);
+var CEAL_LEASE_DISPOSITIONS = vocabulary([...CEAL_TERMINAL_DISPOSITIONS, "deferred"]);
+var CEAL_AUTOMATIC_FEEDBACK_INTENTS = vocabulary(["reaction", "progress_start", "progress_finish"]);
+var CEAL_LEASED_MESSAGE_DELIVERY_CAPABILITY_IDS = vocabulary(["message.create", "message.update", "message.delete"]);
+var CEAL_REPOSITORY_VISIBILITIES = vocabulary(["public", "private", "internal"]);
+var CEAL_RESULT_DELIVERY_OFFERS = vocabulary(["pending", "offered", "transport_lost"]);
+var CEAL_RESULT_DELIVERY_STATES = vocabulary(["unavailable", ...CEAL_RESULT_DELIVERY_OFFERS]);
+var CEAL_PROVIDER_OUTCOMES = vocabulary(["not_attempted", "outcome_unknown", "verified"]);
+var CEAL_ACTIVITY_GAP_CODES = vocabulary([
+  "provider_page_budget",
+  "related_item_budget",
+  "provider_cursor_unavailable",
+  "malformed_provider_page",
+  "visibility_incomplete",
+  "unsupported_event_kind"
+]);
+var CEAL_ACTIVITY_COVERAGE_STATUSES = vocabulary(["complete_for_target", "continuation_required", "blocked"]);
+var CEAL_ACTIVITY_EVENT_KINDS = vocabulary([
+  "slack.message",
+  "slack.reply",
+  "github.commit.authored",
+  "github.issue.opened",
+  "github.pull_request.opened",
+  "github.review.submitted",
+  "github.issue_comment.created",
+  "github.review_comment.created",
+  "calendar.organized",
+  "calendar.accepted_invite",
+  "calendar.recorded"
+]);
+var CEAL_ACTIVITY_TIMESTAMP_BASES = vocabulary([
+  "message_created",
+  "commit_authored",
+  "resource_created",
+  "review_submitted",
+  "comment_created",
+  "event_start",
+  "all_day_start"
+]);
+var CEAL_ARTIFACT_STAGE_TERMINALS = vocabulary(["chunk_accepted", "artifact_ready", "idempotency_replayed"]);
+var CEAL_READ_ITEM_KINDS = vocabulary(["conversation", "identity", "usergroup", "message", "file", "document"]);
+var CEAL_RESOURCE_RESOLVE_KINDS = vocabulary(["conversation", "identity", "usergroup", "permalink"]);
+var CEAL_OPAQUE_HANDLE_KINDS = vocabulary(["target", "message", "thread", "artifact", "document", "object"]);
+var CEAL_WRITE_OBJECT_KINDS = vocabulary(["document", "comment", "cell_range"]);
+var CEAL_CONVERSATION_KINDS = vocabulary(["channel", "dm", "group"]);
+var CEAL_FILE_TYPE_FAMILIES = vocabulary(["all", "image", "pdf"]);
+var CEAL_GITHUB_ISSUE_STATES = vocabulary(["open", "closed", "all"]);
+var CEAL_NOTION_UPDATABLE_BLOCK_TYPES = vocabulary([
+  "paragraph",
+  "heading_1",
+  "heading_2",
+  "heading_3",
+  "bulleted_list_item",
+  "numbered_list_item",
+  "to_do",
+  "code"
+]);
+var CEAL_NOTION_NEUTRAL_TYPES = vocabulary([
+  "text",
+  "number",
+  "boolean",
+  "date",
+  "select",
+  "multi_select",
+  "people",
+  "url",
+  "email",
+  "phone",
+  "unsupported"
+]);
+var CEAL_NOTION_IDENTITY_GAP_REASONS = vocabulary([
+  "identity_unavailable",
+  "identity_stale",
+  "identity_ambiguous",
+  "identity_revoked",
+  "identity_unlinked"
+]);
+var CEAL_NOTION_STRING_VALUE_TYPES = vocabulary(["text", "select", "url", "email", "phone"]);
+var CEAL_UNREAD_REASONS = vocabulary(["blocked", "unavailable", "too_large", "unsupported", "download_failed", "permission_denied"]);
+var CEAL_PLAN_ITEM_STATUSES = vocabulary(["pending", "active", "completed"]);
+var CEAL_FINAL_PRESENTATION_INTENTS = vocabulary(["final", "stop", "transient_notice"]);
+var CEAL_PRESENTATION_INTENTS = vocabulary(["progress", ...CEAL_FINAL_PRESENTATION_INTENTS]);
+
+// packages/ceal-client-protocol/src/personal-client-vocabulary.ts
+var CEAL_PERSONAL_CLIENT_BINDING_KEYS = vocabulary([
+  "profile_ref",
+  "membership_ref",
+  "registration_ref",
+  "client_ref",
+  "subject_ref",
+  "instance_ref"
+]);
+var CEAL_ENROLLMENT_FAILURE_CODES = vocabulary(["enrollment_invalid", "enrollment_expired", "enrollment_used"]);
+var CEAL_REFRESH_FAILURE_CODES = vocabulary([
+  "refresh_invalid",
+  "refresh_expired",
+  "refresh_inactive",
+  "refresh_replayed",
+  "refresh_revoked",
+  "authority_replaced",
+  "refresh_recovery_unavailable"
+]);
+
+// packages/ceal-client-protocol/src/device-enrollment.ts
+var CEAL_DEVICE_ENROLLMENT_POLL_FAILURE_CODES = Object.freeze(["unsupported_feature", "recovery_required", "expired"]);
+var POLL_RESULT_KEYS = Object.freeze(["retry_after_ms", "schema_version", "status"]);
+
+// packages/ceal-client-protocol/src/personal-client-session.ts
+var REFRESH_FAILURE_CODES = new Set(CEAL_REFRESH_FAILURE_CODES);
+
+// packages/ceal-client-protocol/src/index.ts
+var MAX_REQUEST_BYTES = 32 * 1024;
+var MAX_ARGUMENT_BYTES = 16 * 1024;
+var HANDSHAKE_IDENTITY_KEYS = Object.freeze(["membership_ref", "registration_ref", "client_ref", "subject_ref", "instance_ref"]);
+var AUDIT_IDENTITY_KEYS = Object.freeze(["event_ref", "membership_ref", "registration_ref", "client_ref", "subject_ref", "instance_ref"]);
+var FAILURE_RESPONSE_KEYS = Object.freeze(["error", "ok", "proof_ref_or_unavailable", "protocol_version", "request_id"]);
+var MAX_RECOVERY_RETRY_AFTER_MS = 60 * 60 * 1e3;
+
+// host/invocation-authentication-client-command.ts
+var MAX_DETAIL_CHARACTERS = 240;
+var HOST_OWNED_CODE = /^[a-z][a-z0-9]*(?:_[a-z0-9]+){0,7}$/u;
+function hostTerminalFailure(error, component) {
+  const code = errorCode(error);
+  const detail = failureDetail(error);
+  if (code === "ENOENT") return { code: "host_dependency_unavailable", message: `A command or file the ${component} Host needs is unavailable: ${detail}`, next_action: "Install the missing dependency or restore the missing file, then rerun this command." };
+  if (code === "EACCES" || code === "EPERM") return { code: "host_permission_denied", message: `The ${component} Host was refused access to a local path: ${detail}`, next_action: "Repair the ownership or mode of the named path, then rerun this command." };
+  if (code === "ENOSPC") return { code: "host_storage_unavailable", message: `The ${component} Host could not write local state: ${detail}`, next_action: "Free local disk space, then rerun this command." };
+  if (code !== null && HOST_OWNED_CODE.test(code)) return { code, message: `The ${component} Host command failed: ${detail}`, next_action: `Resolve the named failure above; run \`ceal-host doctor --json\` only if it reports installed ${component} Host drift.` };
+  return { code: "host_failure_unclassified", message: `The ${component} Host command failed for a cause it cannot classify: ${detail}`, next_action: `Run \`ceal-host doctor --json\`; if it reports no drift then the ${component} Host configuration is not the cause, and the message above is the only evidence of what is.` };
+}
+var DOCTOR_FLAGS = Object.freeze({
+  "--expected-sha256": "expected_sha256",
+  "--expected-source-commit": "expected_source_commit",
+  "--expected-instance-ref": "expected_instance_ref"
+});
+function failureDetail(error) {
+  const text = error instanceof Error ? `${error.name}: ${error.message}` : typeof error === "string" ? error : "";
+  const safe = normalizeCealSingleLineText(text).slice(0, MAX_DETAIL_CHARACTERS);
+  return safe === "" ? "the command threw no readable error text" : safe;
+}
+function errorCode(error) {
+  return typeof error === "object" && error !== null && "code" in error && typeof error.code === "string" ? error.code : null;
+}
+
+// host/relay/src/host-relay-runtime.ts
+import { O_NOFOLLOW as O_NOFOLLOW3, O_RDONLY as O_RDONLY4 } from "node:constants";
+import { lstat as lstat4, open as open4 } from "node:fs/promises";
+import { dirname as dirname3, join as join6 } from "node:path";
+
+// host/absolute-path.ts
+import { posix, win32 } from "node:path";
+function isAbsoluteNormalizedNonRootPath(value, flavor = process.platform, allowRoot = false) {
+  const pathApi = flavor === "win32" || flavor === "windows" ? win32 : posix;
+  return typeof value === "string" && value.length <= 4096 && !value.includes("\0") && pathApi.isAbsolute(value) && pathApi.normalize(value) === value && (allowRoot || pathApi.parse(value).root !== value);
+}
+
+// host/abortable-wait.ts
+function waitForAbort(signal, milliseconds) {
+  if (signal.aborted) return Promise.resolve();
+  return new Promise((resolve) => {
+    const timer = setTimeout(finish, milliseconds);
+    function finish() {
+      clearTimeout(timer);
+      signal.removeEventListener("abort", finish);
+      resolve();
+    }
+    signal.addEventListener("abort", finish, { once: true });
+  });
+}
+
+// host/json-duplicate-guard.ts
+function rejectDuplicateJsonKeys(text, errors) {
+  const end = scanJsonValue(text, skipWhitespace(text, 0), errors);
+  if (skipWhitespace(text, end) !== text.length) throw errors.invalid();
+}
+function scanJsonValue(text, start, errors) {
+  const marker = text[start];
+  if (marker === "{") return scanJsonObject(text, start, errors);
+  if (marker === "[") return scanJsonArray(text, start, errors);
+  if (marker === '"') return scanJsonString(text, start, errors);
+  return scanJsonPrimitive(text, start, errors);
+}
+function scanJsonObject(text, start, errors) {
+  let index = skipWhitespace(text, start + 1);
+  const keys = /* @__PURE__ */ new Set();
+  if (text[index] === "}") return index + 1;
+  while (index < text.length) {
+    if (text[index] !== '"') throw errors.invalid();
+    const end = scanJsonString(text, index, errors);
+    let key;
+    try {
+      key = JSON.parse(text.slice(index, end));
+    } catch {
+      throw errors.invalid();
+    }
+    if (typeof key !== "string" || keys.has(key)) throw errors.duplicate();
+    keys.add(key);
+    index = skipWhitespace(text, end);
+    if (text[index] !== ":") throw errors.invalid();
+    index = skipWhitespace(text, scanJsonValue(text, skipWhitespace(text, index + 1), errors));
+    if (text[index] === "}") return index + 1;
+    if (text[index] !== ",") throw errors.invalid();
+    index = skipWhitespace(text, index + 1);
+  }
+  throw errors.invalid();
+}
+function scanJsonArray(text, start, errors) {
+  let index = skipWhitespace(text, start + 1);
+  if (text[index] === "]") return index + 1;
+  while (index < text.length) {
+    index = skipWhitespace(text, scanJsonValue(text, index, errors));
+    if (text[index] === "]") return index + 1;
+    if (text[index] !== ",") throw errors.invalid();
+    index = skipWhitespace(text, index + 1);
+  }
+  throw errors.invalid();
+}
+function scanJsonString(text, start, errors) {
+  for (let index = start + 1; index < text.length; index += 1) {
+    if (text[index] === "\\") {
+      index += 1;
+      continue;
+    }
+    if (text[index] === '"') return index + 1;
+  }
+  throw errors.invalid();
+}
+function scanJsonPrimitive(text, start, errors) {
+  let index = start;
+  while (index < text.length && !/[\s,\]}]/u.test(text[index] ?? "")) index += 1;
+  if (index === start) throw errors.invalid();
+  return index;
+}
+function skipWhitespace(text, start) {
+  let index = start;
+  while (index < text.length && /\s/u.test(text[index] ?? "")) index += 1;
+  return index;
+}
+
+// host/relay/src/producer-frame.ts
+import { createHash as createHash2 } from "node:crypto";
+var HOST_PRODUCER_FRAME_SCHEMA = "ceal.host_producer_frame.v1";
+var HOST_PRODUCER_MAX_JSON_BYTES = 262144;
+var SAFE_REF2 = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u;
+var DIGEST2 = /^[a-f0-9]{64}$/u;
+var PRODUCERS = /* @__PURE__ */ new Set(["codex", "claude"]);
+var HOST_PRODUCER_FRAME_KINDS = ["session_started", "turn_started", "user_input", "turn_terminal", "producer_status"];
+var FRAME_KINDS = new Set(HOST_PRODUCER_FRAME_KINDS);
+function isHostProducerFrameKind(value) {
+  return typeof value === "string" && FRAME_KINDS.has(value);
+}
+var HostProducerFrameError = class extends Error {
+  code;
+  constructor(code, message = code) {
+    super(message);
+    this.code = code;
+  }
+};
+function encodeHostProducerFrame(frame) {
+  validateFrame(frame);
+  const json = Buffer.from(JSON.stringify(frame), "utf8");
+  if (json.byteLength > HOST_PRODUCER_MAX_JSON_BYTES) throw new HostProducerFrameError("frame_too_large", `frame_too_large: ${refusalFact("frame_bytes", json.byteLength, `at most ${HOST_PRODUCER_MAX_JSON_BYTES}`)}`);
+  const result2 = Buffer.allocUnsafe(json.byteLength + 4);
+  result2.writeUInt32BE(json.byteLength, 0);
+  json.copy(result2, 4);
+  return result2;
+}
+function decodeHostProducerFrame(input) {
+  if (input.byteLength < 4) throw new HostProducerFrameError("frame_truncated", `frame_truncated: ${refusalFact("frame_bytes", input.byteLength, "at least 4")}`);
+  const length = input.readUInt32BE(0);
+  if (length > HOST_PRODUCER_MAX_JSON_BYTES) throw new HostProducerFrameError("frame_too_large", `frame_too_large: ${refusalFact("declared_bytes", length, `at most ${HOST_PRODUCER_MAX_JSON_BYTES}`)}`);
+  if (length === 0) throw new HostProducerFrameError("invalid_frame_length");
+  if (input.byteLength !== length + 4) throw new HostProducerFrameError(input.byteLength < length + 4 ? "frame_truncated" : "invalid_frame_length");
+  const bytes2 = input.subarray(4);
+  const text = new TextDecoder("utf-8", { fatal: true });
+  let value;
+  try {
+    value = JSON.parse(text.decode(bytes2));
+  } catch (error) {
+    if (error instanceof TypeError) throw new HostProducerFrameError("invalid_frame_encoding");
+    throw new HostProducerFrameError("frame_truncated");
+  }
+  validateFrame(value);
+  return value;
+}
+function hostProducerFrameHash(frame) {
+  return createHash2("sha256").update(JSON.stringify(frame), "utf8").digest("hex");
+}
+function hostProducerIdentityRefs(hostSourceRef, frame, localSessionRef, localTurnRef, localInputRef) {
+  if (!opaqueHostSourceRef(hostSourceRef)) throw new TypeError("Gateway host source reference is invalid.");
+  const host_session_ref = localSessionRef === void 0 ? void 0 : `ceal-host-session:${cealRequestSha256({ host_source_ref: hostSourceRef, producer_id: frame.producer_id, producer_installation_ref: frame.producer_installation_ref, local_session_ref: localSessionRef })}`;
+  const host_turn_ref = host_session_ref === void 0 || localTurnRef === void 0 ? void 0 : `ceal-host-turn:${cealRequestSha256({ host_session_ref, local_turn_ref: localTurnRef })}`;
+  const host_input_ref = host_turn_ref === void 0 || localInputRef === void 0 ? void 0 : `ceal-host-input:${cealRequestSha256({ host_turn_ref, local_input_ref: localInputRef })}`;
+  const submission_ref = `ceal-host-frame:${cealRequestSha256({ host_source_ref: hostSourceRef, producer_id: frame.producer_id, producer_installation_ref: frame.producer_installation_ref, sequence: frame.sequence })}`;
+  return { host_session_ref: host_session_ref ?? "", ...host_turn_ref === void 0 ? {} : { host_turn_ref }, ...host_input_ref === void 0 ? {} : { host_input_ref }, submission_ref };
+}
+function hostProducerSessionRef(hostSourceRef, frame, localSessionRef) {
+  return requiredIdentity(hostProducerIdentityRefs(hostSourceRef, frame, localSessionRef).host_session_ref);
+}
+function hostProducerTurnRef(hostSourceRef, frame, localSessionRef, localTurnRef) {
+  return requiredIdentity(hostProducerIdentityRefs(hostSourceRef, frame, localSessionRef, localTurnRef).host_turn_ref);
+}
+function hostProducerInputRef(hostSourceRef, frame, localSessionRef, localTurnRef, localInputRef) {
+  return requiredIdentity(hostProducerIdentityRefs(hostSourceRef, frame, localSessionRef, localTurnRef, localInputRef).host_input_ref);
+}
+function hostProducerSubmissionRef(hostSourceRef, frame) {
+  return requiredIdentity(hostProducerIdentityRefs(hostSourceRef, frame).submission_ref);
+}
+function hostProducerPromptRef(promptSha256) {
+  if (!DIGEST2.test(promptSha256)) throw new TypeError("Canonical Host prompt digest is invalid.");
+  return `ceal-host-prompt:${promptSha256}`;
+}
+function opaqueHostSourceRef(value) {
+  return typeof value === "string" && SAFE_REF2.test(value) && !value.startsWith("ceal-host-source:");
+}
+function requiredIdentity(value) {
+  if (value === void 0) throw new TypeError("Canonical Host identity is incomplete.");
+  return value;
+}
+function validateFrame(value) {
+  if (!record(value)) throw new HostProducerFrameError("invalid_frame_shape");
+  if (value.schema_version !== HOST_PRODUCER_FRAME_SCHEMA) throw new HostProducerFrameError("unsupported_frame_schema", `unsupported_frame_schema: ${refusalFact("schema_version", value.schema_version, HOST_PRODUCER_FRAME_SCHEMA)}`);
+  if (!exactKeys2(value, ["schema_version", "producer_id", "producer_installation_ref", "producer_epoch", "sequence", "frame_kind", "occurred_at", "payload"])) throw new HostProducerFrameError("invalid_frame_shape");
+  if (!PRODUCERS.has(String(value.producer_id)) || !safeRef(value.producer_installation_ref)) throw new HostProducerFrameError("invalid_producer_identity");
+  if (!positive(value.producer_epoch) || !positive(value.sequence) || !hostProducerFrameKind(value.frame_kind) || !timestamp(value.occurred_at) || !record(value.payload)) throw new HostProducerFrameError("invalid_frame_shape");
+  validatePayload(value.frame_kind, value.payload);
+}
+function validatePayload(kind, value) {
+  const valid = kind === "session_started" ? validSession(value) : kind === "turn_started" ? validTurn(value) : kind === "user_input" ? validInput(value) : kind === "turn_terminal" ? validTerminal(value) : validStatus(value);
+  if (!valid) throw new HostProducerFrameError("invalid_frame_shape");
+}
+function validSession(value) {
+  return exactOptional(value, ["local_session_ref", "working_directory_ref"], ["model", "host_version", "observations"]) && safeRef(value.local_session_ref) && safeRef(value.working_directory_ref) && optionalText(value.model, 256) && optionalText(value.host_version, 256) && validObservations(value.observations);
+}
+function validTurn(value) {
+  return exactOptional(value, ["local_session_ref", "local_turn_ref"], ["model", "observations"]) && safeRef(value.local_session_ref) && safeRef(value.local_turn_ref) && optionalText(value.model, 256) && validObservations(value.observations);
+}
+function validInput(value) {
+  return exactOptional(value, ["local_session_ref", "local_turn_ref", "local_input_ref", "origin_input", "observations"], ["decision", "local_turn_aliases", "context_expires_at"]) && safeRef(value.local_session_ref) && safeRef(value.local_turn_ref) && safeRef(value.local_input_ref) && validInputObservations(value.observations) && typeof value.origin_input === "boolean" && validInputOptionals(value);
+}
+function validInputObservations(value) {
+  return validObservations(value) && Array.isArray(value) && value.filter((item) => record(item) && item.observation_kind === "prompt").length === 1;
+}
+function validInputOptionals(value) {
+  return validDecision(value.decision) && optionalRefs(value.local_turn_aliases) && (value.context_expires_at === void 0 || timestamp(value.context_expires_at));
+}
+function validTerminal(value) {
+  return exactOptional(value, ["local_session_ref", "local_turn_ref", "terminal_state"], ["abort_reason", "duration_ms", "time_to_first_token_ms", "usage", "observations"]) && safeRef(value.local_session_ref) && safeRef(value.local_turn_ref) && validTerminalDisposition(value.terminal_state, value.abort_reason) && optionalNonNegative(value.duration_ms) && optionalNonNegative(value.time_to_first_token_ms) && (value.usage === void 0 || jsonValue(value.usage)) && validObservations(value.observations);
+}
+function validTerminalDisposition(state, reason) {
+  return (state === "completed" || state === "aborted") && (reason === void 0 || state === "aborted" && safeRef(reason));
+}
+function validStatus(value) {
+  return exactOptional(value, ["status", "reason_code"], ["detail"]) && ["ready", "degraded", "stopping"].includes(String(value.status)) && safeRef(value.reason_code) && optionalText(value.detail, 4096);
+}
+function validDecision(value) {
+  return value === void 0 || record(value) && exactKeys2(value, ["decision", "approval_ref"]) && (value.decision === "approved" || value.decision === "denied") && safeRef(value.approval_ref);
+}
+function optionalText(value, maxLength) {
+  return value === void 0 || typeof value === "string" && value.length > 0 && value.length <= maxLength;
+}
+function optionalNonNegative(value) {
+  return value === void 0 || typeof value === "number" && Number.isFinite(value) && value >= 0;
+}
+function optionalRefs(value) {
+  return value === void 0 || Array.isArray(value) && value.length <= 16 && value.every(safeRef);
+}
+function validObservations(value) {
+  if (value === void 0) return true;
+  if (!Array.isArray(value) || value.length > 32) return false;
+  return value.every((item) => {
+    try {
+      validateCealHostObservationDraft(item);
+      return true;
+    } catch {
+      return false;
+    }
+  });
+}
+function jsonValue(value, depth = 0) {
+  if (depth > 16) return false;
+  if (value === null || typeof value === "string" || typeof value === "boolean") return true;
+  if (typeof value === "number") return Number.isFinite(value);
+  if (Array.isArray(value)) return value.length <= 256 && value.every((item) => jsonValue(item, depth + 1));
+  return record(value) && Object.keys(value).length <= 256 && Object.entries(value).every(([key, item]) => key.length > 0 && key.length <= 128 && jsonValue(item, depth + 1));
+}
+function record(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function safeRef(value) {
+  return typeof value === "string" && SAFE_REF2.test(value);
+}
+function positive(value) {
+  return Number.isSafeInteger(value) && Number(value) > 0;
+}
+function timestamp(value) {
+  return typeof value === "string" && Number.isFinite(Date.parse(value));
+}
+function hostProducerFrameKind(value) {
+  return isHostProducerFrameKind(value);
+}
+function exactKeys2(value, keys) {
+  return JSON.stringify(Object.keys(value).sort()) === JSON.stringify([...keys].sort());
+}
+function exactOptional(value, required, optional) {
+  const keys = Object.keys(value);
+  return required.every((key) => keys.includes(key)) && keys.every((key) => required.includes(key) || optional.includes(key));
+}
+
+// host/relay/src/relay-admission-store.ts
+import { readFile as readFile2 } from "node:fs/promises";
+import { join as join3 } from "node:path";
+
+// host/relay/src/durable-atomic-replacement.ts
+import { O_RDONLY } from "node:constants";
+import { lstat, mkdir, open, rename, unlink } from "node:fs/promises";
+import { dirname } from "node:path";
+var DEFAULT_PORT = {
+  platform: process.platform,
+  mkdir: (path, options) => mkdir(path, options),
+  lstat: (path) => lstat(path),
+  open_file: (path) => open(path, "wx", 384),
+  rename,
+  unlink,
+  open_directory: (path) => open(path, O_RDONLY),
+  unique_ref: () => `${process.pid}.${crypto.randomUUID()}`
+};
+async function durableAtomicReplace(target, data, port = DEFAULT_PORT) {
+  const parent = dirname(target);
+  await port.mkdir(parent, { recursive: true, mode: 448 });
+  const parentStats = await port.lstat(parent);
+  if (!parentStats.isDirectory() || parentStats.isSymbolicLink() || !ownerPrivate(parentStats, port.platform)) throw new TypeError(`Host Relay durable-state directory is unsafe: ${refusalFacts([{ name: "parent_stats", value: parentStats, expected: "an owner-private directory" }, { name: "platform", value: port.platform }])}.`);
+  const temporary = `${target}.${port.unique_ref()}.new`;
+  let staged;
+  const failures = [];
+  try {
+    staged = await port.open_file(temporary);
+    await staged.writeFile(data, typeof data === "string" ? { encoding: "utf8" } : void 0);
+    await staged.sync();
+    const closing = staged;
+    staged = void 0;
+    await closing.close();
+    await port.rename(temporary, target);
+    await syncParentDirectory(parent, port);
+  } catch (error) {
+    failures.push(error);
+  }
+  await closeStaged(staged, failures);
+  await removeTemporary(temporary, port, failures);
+  throwFailures(failures);
+}
+async function syncParentDirectory(path, port) {
+  if (port.platform === "win32") return;
+  const handle = await port.open_directory(path);
+  let failure;
+  try {
+    await handle.sync();
+  } catch (error) {
+    if (!directorySyncUnsupported(error)) failure = error;
+  }
+  try {
+    await handle.close();
+  } catch (error) {
+    if (failure === void 0) failure = error;
+    else failure = new AggregateError([failure, error], "Host Relay directory sync and close failed.");
+  }
+  if (failure !== void 0) throw failure;
+}
+function ownerPrivate(stats, platform) {
+  if (platform === "win32") return true;
+  const uid = typeof process.geteuid === "function" ? process.geteuid() : stats.uid;
+  return stats.uid === uid && (stats.mode & 63) === 0;
+}
+async function closeStaged(staged, failures) {
+  if (staged !== void 0) try {
+    await staged.close();
+  } catch (error) {
+    failures.push(error);
+  }
+}
+async function removeTemporary(path, port, failures) {
+  try {
+    await port.unlink(path);
+  } catch (error) {
+    if (errorCode2(error) !== "ENOENT") failures.push(error);
+  }
+}
+function throwFailures(failures) {
+  if (failures.length === 1) throw failures[0];
+  if (failures.length > 1) throw new AggregateError(failures, "Host Relay durable replacement and cleanup failed.");
+}
+function directorySyncUnsupported(error) {
+  return ["EINVAL", "ENOSYS", "ENOTSUP"].includes(errorCode2(error) ?? "");
+}
+function errorCode2(error) {
+  return typeof error === "object" && error !== null && "code" in error ? String(error.code) : null;
+}
+
+// host/relay/src/relay-quarantine-store.ts
+import { createHash as createHash3 } from "node:crypto";
+import { readFile } from "node:fs/promises";
+import { join as join2 } from "node:path";
+var RELAY_QUARANTINE_SCHEMA = "ceal.host_relay_quarantine_state.v1";
+var RELAY_QUARANTINE_MAX_RECORDS = 512;
+var RELAY_QUARANTINE_MAX_BYTES = 16 * 1024 * 1024;
+var MAX_CAPTURE_BYTES = 262148;
+var PRODUCERS2 = ["codex", "claude", "unknown"];
+var RelayQuarantineStore = class {
+  root;
+  maxRecords;
+  maxBytes;
+  tail = Promise.resolve();
+  constructor(root, limits = {}) {
+    this.root = root;
+    this.maxRecords = limits.max_records ?? RELAY_QUARANTINE_MAX_RECORDS;
+    this.maxBytes = limits.max_bytes ?? RELAY_QUARANTINE_MAX_BYTES;
+    if (!Number.isSafeInteger(this.maxRecords) || this.maxRecords < 1 || this.maxRecords > RELAY_QUARANTINE_MAX_RECORDS) throw new TypeError(`Relay quarantine record cap is invalid: ${refusalFact("max_records", this.maxRecords, `between 1 and ${RELAY_QUARANTINE_MAX_RECORDS}`)}.`);
+    if (!Number.isSafeInteger(this.maxBytes) || this.maxBytes < 1 || this.maxBytes > RELAY_QUARANTINE_MAX_BYTES) throw new TypeError(`Relay quarantine byte cap is invalid: ${refusalFact("max_bytes", this.maxBytes, `between 1 and ${RELAY_QUARANTINE_MAX_BYTES}`)}.`);
+  }
+  async retainFrame(frame, reason, capturedAt = (/* @__PURE__ */ new Date()).toISOString()) {
+    await this.retain(encodeHostProducerFrame(frame), frame.producer_id, reason, capturedAt);
+  }
+  async retainMalformed(rawFrame, reason, capturedAt = (/* @__PURE__ */ new Date()).toISOString()) {
+    await this.retain(rawFrame, inferProducer(rawFrame), reason, capturedAt);
+  }
+  async read(producerId, limit = this.maxRecords) {
+    if (!PRODUCERS2.includes(producerId) || !Number.isSafeInteger(limit) || limit < 0) throw new TypeError("Relay quarantine read arguments are invalid.");
+    await this.tail;
+    const state = await this.readState();
+    const records = state.producers[producerId].slice(-Math.min(limit, this.maxRecords)).map((record6) => structuredClone(record6));
+    return { producer_id: producerId, records, total_bytes: records.reduce((total, record6) => total + record6.charged_bytes, 0) };
+  }
+  async snapshot() {
+    await this.tail;
+    return this.readState();
+  }
+  async retain(rawFrame, producerId, reason, capturedAt) {
+    const run = this.tail.then(async () => {
+      if (!PRODUCERS2.includes(producerId) || !Number.isFinite(Date.parse(capturedAt))) throw new TypeError("Relay quarantine record identity is invalid.");
+      const raw = Buffer.from(rawFrame).subarray(0, MAX_CAPTURE_BYTES);
+      const state = await this.readState();
+      const record6 = {
+        quarantine_ref: `quarantine:${createHash3("sha256").update(`${producerId}\0${reason}\0${capturedAt}\0`).update(raw).digest("hex")}`,
+        producer_id: producerId,
+        reason,
+        captured_at: capturedAt,
+        frame_sha256: createHash3("sha256").update(raw).digest("hex"),
+        charged_bytes: raw.byteLength,
+        raw_frame_base64: raw.toString("base64")
+      };
+      const records = state.producers[producerId];
+      records.push(record6);
+      while (records.length > this.maxRecords || totalBytes(records) > this.maxBytes) records.shift();
+      await durableAtomicReplace(join2(this.root, "quarantine.json"), JSON.stringify(state));
+    });
+    this.tail = run.then(() => void 0, () => void 0);
+    await run;
+  }
+  async readState() {
+    try {
+      return decodeState(JSON.parse(await readFile(join2(this.root, "quarantine.json"), "utf8")));
+    } catch (error) {
+      if (errorCode3(error) === "ENOENT") return emptyState();
+      throw error;
+    }
+  }
+};
+function emptyState() {
+  return { schema_version: RELAY_QUARANTINE_SCHEMA, producers: { codex: [], claude: [], unknown: [] } };
+}
+function totalBytes(records) {
+  return records.reduce((total, record6) => total + record6.charged_bytes, 0);
+}
+function decodeState(value) {
+  if (!record2(value) || value.schema_version !== RELAY_QUARANTINE_SCHEMA) throw new TypeError(`Host Relay quarantine state is invalid: ${refusalFact("schema_version", record2(value) ? value.schema_version : void 0, RELAY_QUARANTINE_SCHEMA)}.`);
+  if (!record2(value.producers)) throw new TypeError(`Host Relay quarantine state is invalid: ${refusalFact("producer_ids", record2(value.producers) ? Object.keys(value.producers) : [], `the ${PRODUCERS2.length} quarantine producer buckets`)}.`);
+  const state = emptyState();
+  for (const producerId of PRODUCERS2) {
+    const records = value.producers[producerId];
+    if (!Array.isArray(records) || !records.every(validRecord)) throw new TypeError("Host Relay quarantine records are invalid.");
+    state.producers[producerId] = records.map((item) => structuredClone(item));
+  }
+  return state;
+}
+function validRecord(value) {
+  if (!record2(value) || typeof value.quarantine_ref !== "string" || !quarantineProducer(value.producer_id) || typeof value.reason !== "string" || !Number.isFinite(Date.parse(String(value.captured_at))) || typeof value.frame_sha256 !== "string" || typeof value.charged_bytes !== "number" || !Number.isSafeInteger(value.charged_bytes) || value.charged_bytes < 0 || typeof value.raw_frame_base64 !== "string") return false;
+  return true;
+}
+function quarantineProducer(value) {
+  return value === "codex" || value === "claude" || value === "unknown";
+}
+function inferProducer(rawFrame) {
+  try {
+    const value = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(Buffer.from(rawFrame).subarray(4)));
+    return record2(value) && (value.producer_id === "codex" || value.producer_id === "claude") ? value.producer_id : "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+function record2(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function errorCode3(error) {
+  return record2(error) && typeof error.code === "string" ? error.code : null;
+}
+
+// host/relay/src/relay-admission-store.ts
+var DEFAULT_LIMITS = { global_count: 8192, global_bytes: 64 * 1024 * 1024, producer_count: 4096, producer_bytes: 32 * 1024 * 1024 };
+var PRODUCER_ORDER = ["codex", "claude"];
+var RETRY_SECONDS = [1, 2, 4, 8, 16, 32, 60];
+var RelayAdmissionStore = class {
+  tail = Promise.resolve();
+  root;
+  quarantine;
+  limits;
+  faultHooks;
+  constructor(root, limits = DEFAULT_LIMITS, faultHooks = {}, quarantine = new RelayQuarantineStore(join3(root, "quarantine"))) {
+    this.root = root;
+    this.quarantine = quarantine;
+    this.limits = limits;
+    this.faultHooks = faultHooks;
+  }
+  async admit(frame) {
+    const run = this.tail.then(() => this.admitLocked(frame));
+    this.tail = run.then(() => void 0, () => void 0);
+    return run;
+  }
+  async snapshot() {
+    await this.tail;
+    return this.read();
+  }
+  async drainRound(deliver, options) {
+    const run = this.tail.then(() => this.drainLocked(deliver, options));
+    this.tail = run.then(() => void 0, () => void 0);
+    return run;
+  }
+  async admitLocked(frame) {
+    const state = await this.read();
+    const key = installationKey(frame);
+    const installation2 = state.installations[key] ?? { epoch: frame.producer_epoch, admitted_through_sequence: 0, delivered_through_sequence: 0 };
+    if (frame.producer_epoch < installation2.epoch) return result("producer_epoch_stale", installation2);
+    if (frame.producer_epoch > installation2.epoch) installation2.epoch = frame.producer_epoch;
+    const existing = state.entries.find((entry2) => entry2.producer_id === frame.producer_id && entry2.producer_installation_ref === frame.producer_installation_ref && entry2.sequence === frame.sequence);
+    const hash = hostProducerFrameHash(frame);
+    const replay = replayCode(existing, hash, frame.sequence, installation2);
+    if (replay !== null) {
+      if (replay === "frame_identity_conflict") await this.quarantine.retainFrame(frame, replay);
+      return result(replay, installation2);
+    }
+    if (frame.sequence !== installation2.admitted_through_sequence + 1) {
+      await this.quarantine.retainFrame(frame, "sequence_gap");
+      return result("sequence_gap", installation2);
+    }
+    const chargedBytes = 4 + Buffer.byteLength(JSON.stringify(frame), "utf8");
+    const queueFull = this.queueFullCode(state.entries, frame.producer_id, chargedBytes);
+    if (queueFull !== null) return result(queueFull, installation2);
+    installation2.admitted_through_sequence = frame.sequence;
+    state.installations[key] = installation2;
+    state.entries.push({ producer_id: frame.producer_id, producer_installation_ref: frame.producer_installation_ref, sequence: frame.sequence, hash, charged_bytes: chargedBytes, frame: structuredClone(frame), retry_attempts: 0, retry_at_ms: 0 });
+    await this.write(state);
+    await this.faultHooks.after_admission_fsync?.({ fault_point: "after_admission_fsync", frame: structuredClone(frame), frame_sha256: hash });
+    return result("admitted", installation2);
+  }
+  queueFullCode(entries, producerId, chargedBytes) {
+    const producerEntries = entries.filter((entry2) => entry2.producer_id === producerId);
+    if (producerEntries.length >= this.limits.producer_count || bytes(producerEntries) + chargedBytes > this.limits.producer_bytes) return "producer_queue_full";
+    if (entries.length >= this.limits.global_count || bytes(entries) + chargedBytes > this.limits.global_bytes) return "relay_queue_full";
+    return null;
+  }
+  async drainLocked(deliver, options) {
+    if (!opaqueHostSourceRef(options.host_source_ref)) throw new TypeError("Gateway host source reference is invalid.");
+    const state = await this.read();
+    const delivered = [];
+    const retained = [];
+    const refused = [];
+    for (const producerId of PRODUCER_ORDER) {
+      const head = state.entries.find((entry2) => entry2.producer_id === producerId);
+      if (!head || head.retry_at_ms > options.now_ms) continue;
+      const input = { frame: structuredClone(head.frame), host_source_ref: options.host_source_ref, submission_ref: hostProducerSubmissionRef(options.host_source_ref, head.frame) };
+      const outcome = await deliver(input);
+      if (outcome.status === "retryable") {
+        scheduleRetry(head, options.now_ms, outcome.reason);
+        retained.push(input.submission_ref);
+        await this.write(state);
+        continue;
+      }
+      const installation2 = state.installations[installationKey(head.frame)];
+      if (!installation2) throw new TypeError("Host Relay delivery installation is unavailable.");
+      if (outcome.status === "refused") {
+        await this.quarantine.retainFrame(head.frame, "gateway_refused");
+        installation2.last_refusal = { sequence: head.sequence, submission_ref: input.submission_ref, code: outcome.code, message: outcome.message, refused_at_ms: options.now_ms };
+        refused.push(input.submission_ref);
+      } else {
+        await options.after_gateway_accept_before_delivery_fsync?.({ fault_point: "after_gateway_accept_before_delivery_fsync", delivery: structuredClone(input) });
+        delivered.push(input.submission_ref);
+      }
+      state.entries.splice(state.entries.indexOf(head), 1);
+      installation2.delivered_through_sequence = Math.max(installation2.delivered_through_sequence, head.sequence);
+      await this.write(state);
+    }
+    return { delivered, retained, refused };
+  }
+  async read() {
+    try {
+      return decodeState2(JSON.parse(await readFile2(join3(this.root, "admission.json"), "utf8")));
+    } catch (error) {
+      if (errorCode4(error) === "ENOENT") return { schema_version: "ceal.host_relay_admission_state.v1", installations: {}, entries: [] };
+      throw error;
+    }
+  }
+  async write(state) {
+    await durableAtomicReplace(join3(this.root, "admission.json"), JSON.stringify(state));
+  }
+};
+function installationKey(frame) {
+  return `${frame.producer_id}\0${frame.producer_installation_ref}`;
+}
+function replayCode(existing, hash, sequence, installation2) {
+  if (existing !== void 0) return existing.hash === hash ? "already_admitted" : "frame_identity_conflict";
+  return sequence <= installation2.delivered_through_sequence ? "already_admitted" : null;
+}
+function bytes(entries) {
+  return entries.reduce((total, entry2) => total + entry2.charged_bytes, 0);
+}
+function scheduleRetry(entry2, nowMs, reason) {
+  if (reason === void 0) delete entry2.retry_reason;
+  else entry2.retry_reason = reason;
+  entry2.retry_attempts += 1;
+  entry2.retry_at_ms = nowMs + 1e3 * (RETRY_SECONDS[Math.min(entry2.retry_attempts - 1, RETRY_SECONDS.length - 1)] ?? 60);
+}
+function result(code, state) {
+  return { code, admitted_through_sequence: state.admitted_through_sequence, delivered_through_sequence: state.delivered_through_sequence };
+}
+function errorCode4(error) {
+  return typeof error === "object" && error !== null && "code" in error ? String(error.code) : null;
+}
+function decodeState2(value) {
+  if (!stateRecord(value)) throw new TypeError("Host Relay admission state is invalid.");
+  const installations = {};
+  for (const [key, item] of Object.entries(value.installations)) {
+    if (!installation(item)) throw new TypeError("Host Relay installation state is invalid.");
+    installations[key] = item;
+  }
+  const entries = [];
+  for (const item of value.entries) {
+    if (!entry(item)) throw new TypeError("Host Relay entry state is invalid.");
+    entries.push(item);
+  }
+  return { schema_version: "ceal.host_relay_admission_state.v1", installations, entries };
+}
+function stateRecord(value) {
+  return object(value) && value.schema_version === "ceal.host_relay_admission_state.v1" && object(value.installations) && Array.isArray(value.entries);
+}
+function installation(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && "epoch" in value && "admitted_through_sequence" in value && "delivered_through_sequence" in value && [value.epoch, value.admitted_through_sequence, value.delivered_through_sequence].every(Number.isSafeInteger) && (!("last_refusal" in value) || refusalRecord(value.last_refusal));
+}
+function refusalRecord(value) {
+  return object(value) && Number.isSafeInteger(value.sequence) && typeof value.submission_ref === "string" && typeof value.code === "string" && typeof value.message === "string" && Number.isSafeInteger(value.refused_at_ms);
+}
+function entry(value) {
+  return object(value) && producer(value.producer_id) && typeof value.producer_installation_ref === "string" && Number.isSafeInteger(value.sequence) && typeof value.hash === "string" && Number.isSafeInteger(value.charged_bytes) && object(value.frame) && Number.isSafeInteger(value.retry_attempts) && Number.isSafeInteger(value.retry_at_ms);
+}
+function producer(value) {
+  return value === "codex" || value === "claude";
+}
+function object(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// host/relay/src/relay-gateway-bridge.ts
+import { readFile as readFile3 } from "node:fs/promises";
+import { join as join5 } from "node:path";
+
+// host/relay/src/relay-request-binding-store.ts
+import { O_NOFOLLOW, O_RDONLY as O_RDONLY2 } from "node:constants";
+import { open as open2 } from "node:fs/promises";
+import { join as join4 } from "node:path";
+var HOST_RELAY_REQUEST_BINDING_SCHEMA = "ceal.host_relay_request_binding.v1";
+var STATE_SCHEMA = "ceal.host_relay_request_binding_state.v1";
+var SAFE_REF3 = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u;
+var MAX_BINDINGS = 8192;
+var MAX_STATE_BYTES = 8 * 1024 * 1024;
+var HostRelayBindingError = class extends TypeError {
+  name = "HostRelayBindingError";
+  code;
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+  }
+};
+var RelayRequestBindingStore = class {
+  tail = Promise.resolve();
+  root;
+  constructor(root) {
+    if (typeof root !== "string" || root.length === 0) throw new TypeError("Host Relay binding root is invalid.");
+    this.root = root;
+  }
+  bind(input, now = /* @__PURE__ */ new Date()) {
+    const run = this.tail.then(() => this.bindLocked(input, now));
+    this.tail = run.then(() => void 0, () => void 0);
+    return run;
+  }
+  query(input) {
+    const run = this.tail.then(() => this.queryLocked(input));
+    this.tail = run.then(() => void 0, () => void 0);
+    return run;
+  }
+  async bindLocked(input, now) {
+    const candidate = bindingFromGateway(input, now);
+    const state = await this.read();
+    const existing = state.bindings.find((item) => sameCanonicalIdentity(item, candidate));
+    if (existing !== void 0) {
+      if (!sameBinding(existing, candidate)) throw new HostRelayBindingError("canonical_turn_rebound", `Host Relay canonical turn is already bound to another Request: ${refusalFacts([{ name: "candidate_request_ref", value: candidate.request_ref, expected: existing.request_ref }, { name: "candidate_prompt_ref", value: candidate.prompt_ref, expected: existing.prompt_ref }, { name: "candidate_context_expires_at", value: candidate.context_expires_at, expected: String(existing.context_expires_at) }, { name: "candidate_local_turn_aliases", value: candidate.local_turn_aliases, expected: JSON.stringify(existing.local_turn_aliases) }])}.`);
+      return existing;
+    }
+    if (state.bindings.length >= MAX_BINDINGS) throw new HostRelayBindingError("binding_capacity_exhausted", `Host Relay request binding capacity is exhausted: ${refusalFact("binding_count", state.bindings.length, `below ${MAX_BINDINGS}`)}.`);
+    const next = { schema_version: STATE_SCHEMA, bindings: [...state.bindings, candidate] };
+    await this.write(next);
+    return structuredClone(candidate);
+  }
+  async queryLocked(input) {
+    validateQuery(input);
+    const state = await this.read();
+    const matches = state.bindings.filter((binding2) => queryMatches(input, binding2));
+    if (matches.length === 0) return { status: "no_binding" };
+    const binding = matches[0];
+    if (binding === void 0) throw new TypeError("Host Relay binding query result is invalid.");
+    return { status: "ready", binding: structuredClone(binding) };
+  }
+  async read() {
+    let handle;
+    try {
+      handle = await open2(join4(this.root, "request-bindings.json"), O_RDONLY2 | O_NOFOLLOW);
+      const stats = await handle.stat();
+      if (!stats.isFile() || !ownerPrivate2(stats)) throw new TypeError(`Host Relay binding state is unsafe: ${refusalFacts([{ name: "state_is_file", value: stats.isFile(), expected: "true" }, { name: "state_uid", value: stats.uid, expected: String(process.geteuid?.() ?? stats.uid) }, { name: "state_mode", value: (stats.mode & 511).toString(8), expected: "no group or other permission bits" }])}.`);
+      if (stats.size > MAX_STATE_BYTES) throw new TypeError(`Host Relay binding state is unsafe: ${refusalFact("state_bytes", stats.size, `at most ${MAX_STATE_BYTES}`)}.`);
+      return decodeState3(JSON.parse(await handle.readFile("utf8")));
+    } catch (error) {
+      if (errorCode5(error) === "ENOENT") return { schema_version: STATE_SCHEMA, bindings: [] };
+      throw error;
+    } finally {
+      await handle?.close();
+    }
+  }
+  async write(state) {
+    const encoded = JSON.stringify(state);
+    if (Buffer.byteLength(encoded, "utf8") > MAX_STATE_BYTES) throw new TypeError(`Host Relay binding state is too large: ${refusalFact("state_bytes", Buffer.byteLength(encoded, "utf8"), `at most ${MAX_STATE_BYTES}`)}.`);
+    await durableAtomicReplace(join4(this.root, "request-bindings.json"), encoded);
+  }
+};
+function relayRequestWorkContextFromBinding(binding) {
+  return createRelayRequestWorkContext({ request_ref: binding.request_ref, host_binding: {
+    host_source_ref: binding.host_source_ref,
+    host_session_ref: binding.host_session_ref,
+    host_turn_ref: binding.host_turn_ref,
+    host_input_ref: binding.host_input_ref,
+    prompt_ref: binding.prompt_ref
+  } });
+}
+function createRelayRequestWorkContext(input) {
+  if (!record3(input) || !exactKeys3(input, ["request_ref", "host_binding"]) || !safeRef2(input.request_ref) || !record3(input.host_binding)) {
+    throw new HostRelayBindingError("context_identity_missing", "Host Relay work context does not contain the complete acknowledged Host tuple.");
+  }
+  const hostBinding = input.host_binding;
+  if (!exactKeys3(hostBinding, ["host_source_ref", "host_session_ref", "host_turn_ref", "host_input_ref", "prompt_ref"]) || ![hostBinding.host_source_ref, hostBinding.host_session_ref, hostBinding.host_turn_ref, hostBinding.host_input_ref, hostBinding.prompt_ref].every(safeRef2)) {
+    throw new HostRelayBindingError("context_identity_missing", "Host Relay work context does not contain the complete acknowledged Host tuple.");
+  }
+  const hostSourceRef = requiredRef(hostBinding.host_source_ref);
+  const hostSessionRef = requiredRef(hostBinding.host_session_ref);
+  const hostTurnRef = requiredRef(hostBinding.host_turn_ref);
+  const hostInputRef = requiredRef(hostBinding.host_input_ref);
+  const promptRef = requiredRef(hostBinding.prompt_ref);
+  return Object.freeze({ request_ref: input.request_ref, host_binding: Object.freeze({
+    host_source_ref: hostSourceRef,
+    host_session_ref: hostSessionRef,
+    host_turn_ref: hostTurnRef,
+    host_input_ref: hostInputRef,
+    prompt_ref: promptRef
+  }) });
+}
+function bindingFromGateway(input, now) {
+  const payload = input.frame.payload;
+  const candidate = {
+    schema_version: HOST_RELAY_REQUEST_BINDING_SCHEMA,
+    producer_id: input.frame.producer_id,
+    producer_installation_ref: input.frame.producer_installation_ref,
+    local_session_ref: requiredRef(payload.local_session_ref),
+    local_turn_ref: requiredRef(payload.local_turn_ref),
+    local_turn_aliases: optionalRefs2(payload.local_turn_aliases),
+    prompt_ref: requiredRef(input.prompt_ref),
+    request_ref: requiredRef(input.request_ref),
+    bound_at: timestamp2(now.toISOString()),
+    ...payload.context_expires_at === void 0 ? {} : { context_expires_at: timestamp2(payload.context_expires_at) },
+    host_source_ref: requiredRef(input.host_binding.host_source_ref),
+    host_session_ref: requiredRef(input.host_binding.host_session_ref),
+    host_turn_ref: requiredRef(input.host_binding.host_turn_ref),
+    host_input_ref: requiredRef(input.host_binding.host_input_ref)
+  };
+  if (input.host_binding.prompt_ref !== input.prompt_ref) throw new HostRelayBindingError("context_identity_mismatch", "Host Relay binding prompt reference does not match the acknowledged submission.");
+  validateBinding(candidate);
+  return candidate;
+}
+function decodeState3(value) {
+  if (!record3(value) || !exactKeys3(value, ["schema_version", "bindings"])) throw new TypeError(`Host Relay binding state is invalid: ${refusalFact("state_keys", record3(value) ? Object.keys(value) : [], "exactly schema_version and bindings")}.`);
+  if (value.schema_version !== STATE_SCHEMA) throw new TypeError(`Host Relay binding state is invalid: ${refusalFact("schema_version", value.schema_version, STATE_SCHEMA)}.`);
+  if (!Array.isArray(value.bindings)) throw new TypeError(`Host Relay binding state is invalid: ${refusalFact("bindings", value.bindings, "an array")}.`);
+  const bindings = value.bindings.map((item) => {
+    validateBinding(item);
+    return item;
+  });
+  const keys = bindings.map(bindingKey);
+  if (new Set(keys).size !== keys.length) throw new TypeError("Host Relay binding state contains duplicate canonical turns.");
+  return { schema_version: STATE_SCHEMA, bindings };
+}
+function validateBinding(value) {
+  if (!record3(value) || !exactOptionalKeys(value, ["schema_version", "producer_id", "producer_installation_ref", "local_session_ref", "local_turn_ref", "local_turn_aliases", "prompt_ref", "request_ref", "bound_at", "host_source_ref", "host_session_ref", "host_turn_ref", "host_input_ref"], ["context_expires_at"]) || !validBindingIdentity(value) || !validBindingRequest(value)) throw new TypeError("Host Relay request binding is invalid.");
+}
+function validBindingIdentity(value) {
+  return value.schema_version === HOST_RELAY_REQUEST_BINDING_SCHEMA && producer2(value.producer_id) && [value.producer_installation_ref, value.local_session_ref, value.local_turn_ref].every(safeRef2) && refList(value.local_turn_aliases);
+}
+function validBindingRequest(value) {
+  const tuple = [value.host_source_ref, value.host_session_ref, value.host_turn_ref, value.host_input_ref];
+  return safeRef2(value.prompt_ref) && safeRef2(value.request_ref) && validTimestamp(value.bound_at) && (value.context_expires_at === void 0 || validTimestamp(value.context_expires_at)) && tuple.every(safeRef2);
+}
+function validateQuery(value) {
+  if (!record3(value) || !exactKeys3(value, ["producer_id", "producer_installation_ref", "local_session_ref", "local_turn_ref"]) || !producer2(value.producer_id) || !safeRef2(value.producer_installation_ref) || !safeRef2(value.local_session_ref) || !safeRef2(value.local_turn_ref)) throw new TypeError("Host Relay binding query is invalid.");
+}
+function queryMatches(query, binding) {
+  return query.producer_id === binding.producer_id && query.local_session_ref === binding.local_session_ref && (query.local_turn_ref === binding.local_turn_ref || binding.local_turn_aliases.includes(query.local_turn_ref)) && query.producer_installation_ref === binding.producer_installation_ref;
+}
+function sameCanonicalIdentity(left, right) {
+  return bindingKey(left) === bindingKey(right);
+}
+function sameBinding(left, right) {
+  return left.request_ref === right.request_ref && left.prompt_ref === right.prompt_ref && left.context_expires_at === right.context_expires_at && left.host_source_ref === right.host_source_ref && left.host_session_ref === right.host_session_ref && left.host_turn_ref === right.host_turn_ref && left.host_input_ref === right.host_input_ref && JSON.stringify(left.local_turn_aliases) === JSON.stringify(right.local_turn_aliases);
+}
+function bindingKey(value) {
+  return `${value.producer_id}\0${value.producer_installation_ref}\0${value.local_session_ref}\0${value.local_turn_ref}`;
+}
+function requiredRef(value) {
+  if (!safeRef2(value)) throw new TypeError("Host Relay binding reference is invalid.");
+  return value;
+}
+function optionalRefs2(value) {
+  if (value === void 0) return [];
+  if (!refList(value)) throw new TypeError("Host Relay binding aliases are invalid.");
+  return [...value];
+}
+function timestamp2(value) {
+  if (!validTimestamp(value)) throw new TypeError("Host Relay binding timestamp is invalid.");
+  return value;
+}
+function producer2(value) {
+  return value === "codex" || value === "claude";
+}
+function safeRef2(value) {
+  return typeof value === "string" && SAFE_REF3.test(value);
+}
+function refList(value) {
+  return Array.isArray(value) && value.length <= 16 && value.every(safeRef2) && new Set(value).size === value.length;
+}
+function validTimestamp(value) {
+  return typeof value === "string" && Number.isFinite(Date.parse(value));
+}
+function record3(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function exactKeys3(value, keys) {
+  return Object.keys(value).length === keys.length && keys.every((key) => Object.hasOwn(value, key));
+}
+function exactOptionalKeys(value, required, optional) {
+  const keys = Object.keys(value);
+  return required.every((key) => Object.hasOwn(value, key)) && keys.every((key) => required.includes(key) || optional.includes(key));
+}
+function errorCode5(error) {
+  return record3(error) && typeof error.code === "string" ? error.code : null;
+}
+function ownerPrivate2(stats) {
+  if (process.platform === "win32") return true;
+  const uid = typeof process.geteuid === "function" ? process.geteuid() : stats.uid;
+  return stats.uid === uid && (stats.mode & 63) === 0;
+}
+
+// host/relay/src/relay-gateway-bridge.ts
+var STATE_SCHEMA2 = "ceal.host_relay_gateway_state.v1";
+var SAFE_REF4 = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u;
+var HOST_GATEWAY_ACKNOWLEDGEMENT_DISPOSITIONS = ["created", "adopted", "replayed", "approval_approved", "approval_denied", "approval_replayed"];
+function isHostGatewayAcknowledgementDisposition(value) {
+  return typeof value === "string" && HOST_GATEWAY_ACKNOWLEDGEMENT_DISPOSITIONS.some((disposition) => disposition === value);
+}
+var RelayGatewayBridge = class {
+  statePath;
+  hostSourceRef;
+  gateway;
+  timeoutMs;
+  onRequestBound;
+  tail = Promise.resolve();
+  constructor(options) {
+    if (typeof options.state_root !== "string" || options.state_root.length === 0 || !opaqueHostSourceRef(options.host_source_ref) || typeof options.gateway?.submitHostTurn !== "function") throw new TypeError("Host Relay Gateway bridge configuration is invalid.");
+    if (!validOptionalTimeout(options.timeout_ms)) throw new TypeError("Host Relay Gateway timeout is invalid.");
+    this.statePath = join5(options.state_root, "gateway-state.json");
+    this.hostSourceRef = options.host_source_ref;
+    this.gateway = options.gateway;
+    this.timeoutMs = options.timeout_ms ?? 5e3;
+    this.onRequestBound = options.on_request_bound ?? (() => void 0);
+  }
+  deliver(input) {
+    const run = this.tail.then(() => this.deliverLocked(input));
+    this.tail = run.then(() => void 0, () => void 0);
+    return run;
+  }
+  async deliverLocked(input) {
+    if (input.host_source_ref !== this.hostSourceRef) throw new TypeError(`Host Relay source binding does not match the Gateway source: ${refusalFacts([{ name: "input_host_source_ref", value: input.host_source_ref }, { name: "configured_host_source_ref", value: this.hostSourceRef }])}.`);
+    if (input.frame.frame_kind === "producer_status") return { status: "created" };
+    const state = await this.readState();
+    if (input.frame.frame_kind === "session_started") return this.stageSession(state, input);
+    if (input.frame.frame_kind === "turn_started") return this.stageTurn(state, input);
+    return input.frame.frame_kind === "user_input" ? this.deliverInput(state, input) : this.deliverTerminal(state, input);
+  }
+  async stageSession(state, input) {
+    const localSessionRef = payloadRef(input.frame, "local_session_ref");
+    const hostSessionRef = hostProducerSessionRef(this.hostSourceRef, input.frame, localSessionRef);
+    const next = { ...state, sessions: { ...state.sessions, [hostSessionRef]: { observations: payloadObservations(input.frame), submission_ref: input.submission_ref } } };
+    await this.writeState(next);
+    return { status: "created" };
+  }
+  async stageTurn(state, input) {
+    const refs = frameRefs(input.frame, this.hostSourceRef);
+    const existing = state.turns[refs.host_turn_ref];
+    const nextTurn = {
+      host_session_ref: refs.host_session_ref,
+      observations: payloadObservations(input.frame),
+      submission_ref: input.submission_ref,
+      ...existing?.request_ref === void 0 ? {} : { request_ref: existing.request_ref },
+      ...existing?.prompt_ref === void 0 ? {} : { prompt_ref: existing.prompt_ref },
+      ...existing?.origin_host_input_ref === void 0 ? {} : { origin_host_input_ref: existing.origin_host_input_ref },
+      ...existing?.input_refused === void 0 ? {} : { input_refused: existing.input_refused }
+    };
+    await this.writeState({ ...state, turns: { ...state.turns, [refs.host_turn_ref]: nextTurn } });
+    return { status: "created" };
+  }
+  async deliverInput(state, input) {
+    const prepared = prepareInput(state, input, this.hostSourceRef);
+    const outcome = await this.submit(prepared.submission);
+    if ("refusal" in outcome) {
+      if (outcome.refusal.definitive && prepared.turn !== void 0) await this.writeState({ ...state, turns: { ...state.turns, [prepared.refs.host_turn_ref]: { ...prepared.turn, input_refused: { code: outcome.refusal.code, message: outcome.refusal.message } } } });
+      return deliveryRefusal(outcome.refusal);
+    }
+    const acknowledgement2 = outcome.acknowledgement;
+    const nextTurn = bindInput(prepared, acknowledgement2.request_ref, input.submission_ref);
+    await this.writeState({ ...state, turns: { ...state.turns, [prepared.refs.host_turn_ref]: nextTurn } });
+    const binding = { frame: structuredClone(input.frame), request_ref: acknowledgement2.request_ref, prompt_ref: prepared.promptRef, host_binding: {
+      host_source_ref: prepared.submission.identity.host_source_ref,
+      host_session_ref: prepared.submission.identity.host_session_ref,
+      host_turn_ref: prepared.submission.identity.host_turn_ref,
+      host_input_ref: prepared.hostInputRef,
+      prompt_ref: prepared.promptRef
+    } };
+    const context = createRelayRequestWorkContext({ request_ref: acknowledgement2.request_ref, host_binding: binding.host_binding });
+    try {
+      await this.onRequestBound(binding, context);
+    } catch (error) {
+      if (error instanceof HostRelayBindingError) return { status: "refused", code: error.code, message: error.message };
+      return { status: "retryable", reason: `binding_store: ${errorMessage(error)}` };
+    }
+    return { status: "created" };
+  }
+  async deliverTerminal(state, input) {
+    const refs = frameRefs(input.frame, this.hostSourceRef);
+    const turn = state.turns[refs.host_turn_ref];
+    if (turn === void 0) return { status: "refused", code: "origin_turn_unknown", message: "The terminal frame names a turn whose start was never admitted." };
+    if (turn.request_ref === void 0 || turn.prompt_ref === void 0 || turn.origin_host_input_ref === void 0) {
+      if (turn.input_refused !== void 0) return { status: "refused", code: "origin_input_refused", message: `The terminal frame names a turn whose input was refused (${turn.input_refused.code}: ${turn.input_refused.message}).` };
+      return { status: "retryable", reason: "origin_turn_unbound" };
+    }
+    const outcome = await this.submit({
+      identity: { host_source_ref: this.hostSourceRef, host_session_ref: refs.host_session_ref, host_turn_ref: refs.host_turn_ref },
+      host_input_ref: turn.origin_host_input_ref,
+      prompt_ref: turn.prompt_ref,
+      observations: payloadObservations(input.frame),
+      request_ref: turn.request_ref,
+      submission_ref: input.submission_ref
+    });
+    return "refusal" in outcome ? deliveryRefusal(outcome.refusal) : { status: "created" };
+  }
+  async submit(input) {
+    const controller2 = new AbortController();
+    const timeout = setTimeout(() => controller2.abort(), this.timeoutMs);
+    try {
+      const acknowledgement2 = await this.gateway.submitHostTurn(input, controller2.signal);
+      return SAFE_REF4.test(acknowledgement2.request_ref) && isHostGatewayAcknowledgementDisposition(acknowledgement2.disposition) ? { acknowledgement: acknowledgement2 } : { refusal: { code: "invalid_response", message: "Gateway acknowledgement identity is invalid.", definitive: false } };
+    } catch (error) {
+      return { refusal: submissionRefusal(error) };
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+  async readState() {
+    try {
+      const state = decodeState4(JSON.parse(await readFile3(this.statePath, "utf8")));
+      if (state.host_source_ref !== this.hostSourceRef) throw new TypeError(`Host Relay Gateway source binding changed: ${refusalFacts([{ name: "stored_host_source_ref", value: state.host_source_ref }, { name: "configured_host_source_ref", value: this.hostSourceRef }])}.`);
+      return state;
+    } catch (error) {
+      if (errorCode6(error) === "ENOENT") return { schema_version: STATE_SCHEMA2, host_source_ref: this.hostSourceRef, sessions: {}, turns: {} };
+      throw error;
+    }
+  }
+  async writeState(state) {
+    await durableAtomicReplace(this.statePath, JSON.stringify(state));
+  }
+};
+var RETRYABLE_HTTP_STATUSES = /* @__PURE__ */ new Set([401, 403, 408, 429]);
+function submissionRefusal(error) {
+  const status = isRecord(error) && typeof error.status === "number" ? error.status : void 0;
+  const code = errorCode6(error) ?? "gateway_unavailable";
+  const definitive = code === "payload_rejected" || status !== void 0 && status >= 400 && status < 500 && !RETRYABLE_HTTP_STATUSES.has(status);
+  return { code, message: errorMessage(error), definitive };
+}
+function deliveryRefusal(refusal) {
+  return refusal.definitive ? { status: "refused", code: refusal.code, message: refusal.message } : { status: "retryable", reason: `${refusal.code}: ${refusal.message}` };
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function frameRefs(frame, hostSourceRef) {
+  const localSessionRef = payloadRef(frame, "local_session_ref");
+  const localTurnRef = payloadRef(frame, "local_turn_ref");
+  const hostSessionRef = hostProducerSessionRef(hostSourceRef, frame, localSessionRef);
+  return { local_session_ref: localSessionRef, local_turn_ref: localTurnRef, host_session_ref: hostSessionRef, host_turn_ref: hostProducerTurnRef(hostSourceRef, frame, localSessionRef, localTurnRef) };
+}
+function prepareInput(state, input, hostSourceRef) {
+  const refs = frameRefs(input.frame, hostSourceRef);
+  const turn = state.turns[refs.host_turn_ref];
+  const promptRef = turn?.prompt_ref ?? hostProducerPromptRef(payloadPromptDigest(input.frame));
+  const hostInputRef = hostProducerInputRef(hostSourceRef, input.frame, refs.local_session_ref, refs.local_turn_ref, payloadRef(input.frame, "local_input_ref"));
+  const observations = uniqueObservations([...state.sessions[refs.host_session_ref]?.observations ?? [], ...turn?.observations ?? [], ...payloadObservations(input.frame)]);
+  const submission = compactSubmission({
+    identity: { host_source_ref: hostSourceRef, host_session_ref: refs.host_session_ref, host_turn_ref: refs.host_turn_ref },
+    host_input_ref: hostInputRef,
+    prompt_ref: promptRef,
+    observations,
+    decision: payloadDecision(input.frame),
+    request_ref: turn?.request_ref,
+    submission_ref: input.submission_ref
+  });
+  return { refs, turn, promptRef, hostInputRef, submission };
+}
+function bindInput(prepared, requestRef, submissionRef) {
+  return {
+    host_session_ref: prepared.refs.host_session_ref,
+    observations: prepared.turn?.observations ?? [],
+    submission_ref: prepared.turn?.submission_ref ?? submissionRef,
+    request_ref: requestRef,
+    prompt_ref: prepared.promptRef,
+    origin_host_input_ref: prepared.turn?.origin_host_input_ref ?? prepared.hostInputRef
+  };
+}
+function payloadRef(frame, key) {
+  const value = frame.payload[key];
+  if (typeof value !== "string" || !SAFE_REF4.test(value)) throw new TypeError("Host Relay frame reference is invalid.");
+  return value;
+}
+function payloadPromptDigest(frame) {
+  const prompt = payloadObservations(frame).find((observation) => observation.observation_kind === "prompt");
+  if (prompt === void 0 || !isCealHostPromptObservationValue(prompt.value)) throw new TypeError("Host Relay prompt observation is invalid.");
+  return prompt.value.body_sha256;
+}
+function payloadObservations(frame) {
+  return Array.isArray(frame.payload.observations) ? frame.payload.observations.filter(isObservation) : [];
+}
+function payloadDecision(frame) {
+  const value = frame.payload.decision;
+  return isRecord(value) && (value.decision === "approved" || value.decision === "denied") && typeof value.approval_ref === "string" ? { decision: value.decision, approval_ref: value.approval_ref } : void 0;
+}
+function uniqueObservations(values) {
+  const seen = /* @__PURE__ */ new Set();
+  return values.filter((value) => !seen.has(value.observation_ref) && Boolean(seen.add(value.observation_ref)));
+}
+function compactSubmission(value) {
+  return { identity: value.identity, host_input_ref: value.host_input_ref, prompt_ref: value.prompt_ref, observations: value.observations, submission_ref: value.submission_ref, ...value.decision === void 0 ? {} : { decision: value.decision }, ...value.request_ref === void 0 ? {} : { request_ref: value.request_ref } };
+}
+function isObservation(value) {
+  try {
+    validateCealHostObservationDraft(value);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function validOptionalTimeout(value) {
+  return value === void 0 || Number.isSafeInteger(value) && Number(value) >= 1 && Number(value) <= 6e4;
+}
+function errorCode6(error) {
+  return isRecord(error) && typeof error.code === "string" ? error.code : null;
+}
+function decodeState4(value) {
+  if (!isRecord(value) || value.schema_version !== STATE_SCHEMA2) throw new TypeError(`Host Relay Gateway state is invalid: ${refusalFact("schema_version", isRecord(value) ? value.schema_version : void 0, STATE_SCHEMA2)}.`);
+  if (!opaqueHostSourceRef(value.host_source_ref)) throw new TypeError(`Host Relay Gateway state is invalid: ${refusalFact("host_source_ref", value.host_source_ref, "an opaque Host source reference")}.`);
+  if (!isRecord(value.sessions) || !isRecord(value.turns)) throw new TypeError(`Host Relay Gateway state is invalid: ${refusalFacts([{ name: "sessions_is_object", value: isRecord(value.sessions), expected: "true" }, { name: "turns_is_object", value: isRecord(value.turns), expected: "true" }])}.`);
+  return { schema_version: STATE_SCHEMA2, host_source_ref: value.host_source_ref, sessions: decodeSessions(value.sessions), turns: decodeTurns(value.turns) };
+}
+function decodeSessions(value) {
+  const result2 = {};
+  for (const [key, item] of Object.entries(value)) {
+    if (!SAFE_REF4.test(key) || !isRecord(item) || !Array.isArray(item.observations) || !item.observations.every(isObservation) || typeof item.submission_ref !== "string") throw new TypeError("Host Relay staged Session is invalid.");
+    result2[key] = { observations: item.observations, submission_ref: item.submission_ref };
+  }
+  return result2;
+}
+function decodeTurns(value) {
+  const result2 = {};
+  for (const [key, item] of Object.entries(value)) {
+    if (!SAFE_REF4.test(key)) throw new TypeError("Host Relay staged turn is invalid.");
+    result2[key] = decodeTurn(item);
+  }
+  return result2;
+}
+function decodeTurn(item) {
+  if (!isRecord(item) || typeof item.host_session_ref !== "string" || !Array.isArray(item.observations) || !item.observations.every(isObservation) || typeof item.submission_ref !== "string") throw new TypeError("Host Relay staged turn is invalid.");
+  return {
+    host_session_ref: item.host_session_ref,
+    observations: item.observations,
+    submission_ref: item.submission_ref,
+    ...decodeTurnBinding(item),
+    ...isInputRefusal(item.input_refused) ? { input_refused: { code: item.input_refused.code, message: item.input_refused.message } } : {}
+  };
+}
+function decodeTurnBinding(item) {
+  return { ...typeof item.request_ref === "string" ? { request_ref: item.request_ref } : {}, ...typeof item.prompt_ref === "string" ? { prompt_ref: item.prompt_ref } : {}, ...typeof item.origin_host_input_ref === "string" ? { origin_host_input_ref: item.origin_host_input_ref } : {} };
+}
+function isInputRefusal(value) {
+  return isRecord(value) && typeof value.code === "string" && typeof value.message === "string";
+}
+
+// host/relay/src/relay-gateway-http.ts
+import { O_NOFOLLOW as O_NOFOLLOW2, O_RDONLY as O_RDONLY3 } from "node:constants";
+import { lstat as lstat2, open as open3 } from "node:fs/promises";
+import { dirname as dirname2 } from "node:path";
+
+// host/gateway-http.ts
+var SAFE_HOST_REF = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u;
+function hostIngressBody(input, invalidEventTime) {
+  const prompt = input.observations.find((observation) => observation.observation_kind === "prompt");
+  const observedAt = prompt?.observed_at ?? input.observations[0]?.observed_at;
+  if (observedAt === void 0 || !Number.isFinite(Date.parse(observedAt))) throw invalidEventTime();
+  return {
+    submission_ref: input.submission_ref,
+    host_source_ref: input.identity.host_source_ref,
+    host_session_ref: input.identity.host_session_ref,
+    host_turn_ref: input.identity.host_turn_ref,
+    host_input_ref: input.host_input_ref,
+    prompt_ref: input.prompt_ref,
+    observed_at: observedAt,
+    observations: input.observations,
+    ...input.request_ref === void 0 ? {} : { request_ref: input.request_ref },
+    ...input.decision === void 0 ? {} : { decision: input.decision.decision, approval_ref: input.decision.approval_ref }
+  };
+}
+async function responseJson(response2, invalidResponse2) {
+  try {
+    return await response2.json();
+  } catch {
+    throw invalidResponse2();
+  }
+}
+async function submitHostIngress(options) {
+  if (options.input.identity.host_source_ref !== options.expected_host_source_ref) throw options.sourceMismatch();
+  const body = JSON.stringify(hostIngressBody(options.input, options.invalidEventTime));
+  let response2;
+  try {
+    response2 = await options.fetcher(options.endpoint, {
+      method: "POST",
+      ...options.redirect === void 0 ? {} : { redirect: options.redirect },
+      headers: { authorization: `Bearer ${options.credential}`, "content-type": "application/json" },
+      body,
+      signal: options.signal
+    });
+  } catch {
+    throw options.unavailable();
+  }
+  const responseBody = await responseJson(response2, options.invalidResponse);
+  if (!response2.ok) throw options.refused(response2.status, responseBody);
+  return options.acknowledgement(responseBody);
+}
+
+// host/relay/src/relay-gateway-http.ts
+var HOST_REGISTRATION_STATE_KEYS = Object.freeze([
+  "credential_generation",
+  "gateway_request_origin",
+  "host_access_token",
+  "host_installation_ref",
+  "host_source_ref",
+  "registration_attempt_ref",
+  "schema_version",
+  "status"
+]);
+var HOST_INGRESS_PATH = "/api/ceal/v2/host-ingress";
+var HostRelayGatewayError = class extends Error {
+  name = "HostRelayGatewayError";
+  code;
+  /** HTTP status of a Gateway refusal, when one answered. */
+  status;
+  constructor(code, message, status) {
+    super(message);
+    this.code = code;
+    if (status !== void 0) this.status = status;
+  }
+};
+function refusalMessage(status, body) {
+  const record6 = isCealJsonRecord(body) ? body : {};
+  const code = typeof record6.error_code === "string" ? record6.error_code : "unknown";
+  const message = typeof record6.message === "string" ? `: ${record6.message}` : "";
+  return `Gateway Host ingress refused the submission (${status} ${code}${message}).`;
+}
+function createHostRelayGatewayHttpPort(options) {
+  if (!SAFE_HOST_REF.test(options.host_source_ref) || options.host_source_ref.startsWith("ceal-host-source:") || typeof options.registration_state_file !== "string" || options.registration_state_file.length === 0) {
+    throw new HostRelayGatewayError("configuration", "Host Relay Gateway binding is invalid.");
+  }
+  return Object.freeze({
+    async submitHostTurn(input, signal) {
+      if (input.identity.host_source_ref !== options.host_source_ref) throw new HostRelayGatewayError("payload_rejected", `Host Relay source binding changed: ${refusalFacts([{ name: "input_host_source_ref", value: input.identity.host_source_ref }, { name: "configured_host_source_ref", value: options.host_source_ref }])}.`);
+      const registration = await readHostRegistrationAuthority(options.registration_state_file, options.host_source_ref);
+      const endpoint = hostRelayGatewayEndpoint(registration.gateway_request_origin);
+      return await submitHostIngress({
+        input,
+        expected_host_source_ref: options.host_source_ref,
+        endpoint,
+        credential: registration.host_access_token,
+        fetcher: options.fetch ?? fetch,
+        signal,
+        redirect: "error",
+        sourceMismatch: () => new HostRelayGatewayError("payload_rejected", "Host Relay source binding changed."),
+        invalidEventTime: () => new HostRelayGatewayError("payload_rejected", "Host Relay submission has no event time."),
+        unavailable: () => new HostRelayGatewayError("gateway_unavailable", "Gateway Host ingress is unavailable."),
+        invalidResponse: () => new HostRelayGatewayError("invalid_response", "Gateway Host ingress response is not JSON."),
+        refused: (status, body) => new HostRelayGatewayError("gateway_refused", refusalMessage(status, body), status),
+        acknowledgement
+      });
+    },
+    async mintInvocationContext(input, signal) {
+      const registration = await readHostRegistrationAuthority(options.registration_state_file, options.host_source_ref);
+      let response2;
+      try {
+        response2 = await (options.fetch ?? fetch)(hostRelayGatewayRoute(registration.gateway_request_origin, CEAL_HOST_INVOCATION_CONTEXT_PATH), {
+          method: "POST",
+          redirect: "error",
+          signal,
+          headers: { authorization: `Bearer ${registration.host_access_token}`, "content-type": "application/json" },
+          body: JSON.stringify({ schema_version: "ceal.gateway_host_invocation_context_request.v1", ...input })
+        });
+      } catch {
+        throw new HostRelayGatewayError("gateway_unavailable", "Gateway Host invocation context is unavailable.");
+      }
+      if (!response2.ok) throw new HostRelayGatewayError(response2.status === 401 ? "credential" : "gateway_refused", `Gateway Host invocation context was refused (${response2.status}).`, response2.status);
+      let value;
+      try {
+        value = await response2.json();
+      } catch {
+        throw new HostRelayGatewayError("invalid_response", "Gateway Host invocation context response is not JSON.");
+      }
+      try {
+        return decodeCealHostInvocationAuthenticationResult(value);
+      } catch {
+        throw new HostRelayGatewayError("invalid_response", "Gateway Host invocation context response is invalid.");
+      }
+    }
+  });
+}
+function hostRelayGatewayEndpoint(value) {
+  return hostRelayGatewayRoute(value, HOST_INGRESS_PATH);
+}
+function hostRelayGatewayRoute(value, path) {
+  let parsed;
+  try {
+    parsed = new URL(value);
+  } catch {
+    throw new HostRelayGatewayError("configuration", "Host Relay Gateway origin is invalid.");
+  }
+  const hostname = parsed.hostname.toLowerCase().replace(/\.+$/u, "");
+  if (/\s|\0/u.test(value) || hostname === "" || !validPort(parsed) || !isExplicitLoopbackHttp(parsed, hostname) && !isSecureHttps(parsed)) {
+    throw new HostRelayGatewayError("configuration", `Host Relay Gateway origin is invalid: ${refusalFacts([{ name: "protocol", value: parsed.protocol, expected: "https:, or http: with an explicit loopback port" }, { name: "hostname", value: hostname }, { name: "port", value: parsed.port }])}.`);
+  }
+  if (hasOriginDecoration(value, parsed)) {
+    throw new HostRelayGatewayError("configuration", `Host Relay Gateway origin is invalid: ${refusalFacts([{ name: "origin", value: parsed.origin }, { name: "has_userinfo", value: parsed.username !== "" || parsed.password !== "", expected: "false" }, { name: "pathname", value: parsed.pathname, expected: "/" }, { name: "search", value: parsed.search, expected: "an empty query" }, { name: "hash", value: parsed.hash, expected: "an empty fragment" }])}.`);
+  }
+  return `${parsed.origin}${path}`;
+}
+function isExplicitLoopbackHttp(parsed, hostname) {
+  return parsed.protocol === "http:" && parsed.port !== "" && (hostname === "127.0.0.1" || hostname === "[::1]");
+}
+function isSecureHttps(parsed) {
+  return parsed.protocol === "https:";
+}
+function validPort(parsed) {
+  if (parsed.port === "") return true;
+  const port = Number(parsed.port);
+  return Number.isInteger(port) && port >= 1 && port <= 65535;
+}
+function hasOriginDecoration(value, parsed) {
+  const schemeEnd = value.indexOf("://");
+  const authority = schemeEnd < 0 ? "" : value.slice(schemeEnd + 3);
+  const suffixOffset = authority.search(/[\\/?#]/u);
+  const rawSuffix = suffixOffset < 0 ? "" : authority.slice(suffixOffset);
+  return parsed.username !== "" || parsed.password !== "" || parsed.pathname !== "/" || parsed.search !== "" || parsed.hash !== "" || rawSuffix !== "" && rawSuffix !== "/";
+}
+async function readHostRegistrationAuthority(path, expectedHostSourceRef) {
+  let handle;
+  try {
+    await assertOwnerPrivateDirectory(dirname2(path));
+    handle = await open3(path, O_RDONLY3 | O_NOFOLLOW2);
+    const stats = await handle.stat();
+    if (!stats.isFile() || !ownerPrivate3(stats)) throw new HostRelayGatewayError("credential", "Host Relay credential file is not owner-private.");
+    const raw = await handle.readFile("utf8");
+    if (raw.length > 65536) throw new HostRelayGatewayError("credential", `Host registration state is invalid: ${refusalFact("registration_state_bytes", Buffer.byteLength(raw, "utf8"), "at most 65536")}.`);
+    let value;
+    try {
+      value = JSON.parse(raw);
+    } catch {
+      throw new HostRelayGatewayError("credential", "Host registration state is invalid.");
+    }
+    return decodeHostRegistrationAuthority(value, expectedHostSourceRef);
+  } catch (error) {
+    if (error instanceof HostRelayGatewayError) throw error;
+    throw new HostRelayGatewayError("credential", "Host Relay credential file is unavailable.");
+  } finally {
+    await handle?.close();
+  }
+}
+function decodeHostRegistrationAuthority(value, expectedHostSourceRef) {
+  const keys = HOST_REGISTRATION_STATE_KEYS;
+  const fieldCount = isCealJsonRecord(value) ? Object.keys(value).length : 0;
+  const missing = isCealJsonRecord(value) ? keys.filter((key) => !Object.hasOwn(value, key)).length : keys.length;
+  if (!isCealJsonRecord(value) || fieldCount !== keys.length || missing !== 0) throw new HostRelayGatewayError("credential", `Host registration state is invalid or does not match this Relay: ${refusalFacts([{ name: "registration_field_count", value: fieldCount, expected: `exactly ${keys.length}` }, { name: "missing_registration_field_count", value: missing, expected: "0" }])}.`);
+  if (!validRegistrationIdentity(value, expectedHostSourceRef)) throw new HostRelayGatewayError("credential", `Host registration state is invalid or does not match this Relay: ${refusalFacts([{ name: "schema_version", value: value.schema_version, expected: "ceal.host_registration_state.v1" }, { name: "status", value: value.status, expected: "active" }, { name: "host_source_ref", value: value.host_source_ref, expected: expectedHostSourceRef }, { name: "registration_attempt_ref", value: value.registration_attempt_ref, expected: "host-registration-attempt:<uuid>" }, { name: "host_installation_ref", value: value.host_installation_ref, expected: "host-installation:<uuid>" }])}.`);
+  if (!validRegistrationCredential(value)) throw new HostRelayGatewayError("credential", `Host registration state is invalid or does not match this Relay: ${refusalFacts([{ name: "credential_generation", value: value.credential_generation, expected: "a positive safe integer" }, { name: "host_access_token_matches_registered_shape", value: validHostAccessToken(value.host_access_token), expected: "true" }])}.`);
+  if (!validGatewayOrigin(value.gateway_request_origin)) throw new HostRelayGatewayError("credential", `Host registration state is invalid or does not match this Relay: ${refusalFact("gateway_request_origin", value.gateway_request_origin, "an HTTPS origin or explicit-port loopback HTTP origin")}.`);
+  return { gateway_request_origin: value.gateway_request_origin, host_access_token: value.host_access_token };
+}
+function validRegistrationIdentity(value, expectedHostSourceRef) {
+  return value.schema_version === "ceal.host_registration_state.v1" && value.status === "active" && value.host_source_ref === expectedHostSourceRef && typeof value.registration_attempt_ref === "string" && /^host-registration-attempt:[0-9a-f]{8}-(?:[0-9a-f]{4}-){3}[0-9a-f]{12}$/u.test(value.registration_attempt_ref) && typeof value.host_installation_ref === "string" && /^host-installation:[0-9a-f]{8}-(?:[0-9a-f]{4}-){3}[0-9a-f]{12}$/u.test(value.host_installation_ref) && typeof value.host_source_ref === "string" && /^host-source:[0-9a-f]{8}-(?:[0-9a-f]{4}-){3}[0-9a-f]{12}$/u.test(value.host_source_ref);
+}
+function validRegistrationCredential(value) {
+  return Number.isSafeInteger(value.credential_generation) && Number(value.credential_generation) > 0 && validHostAccessToken(value.host_access_token);
+}
+function validHostAccessToken(value) {
+  return typeof value === "string" && /^ceal_host_[A-Za-z0-9_-]{43}$/u.test(value);
+}
+function validGatewayOrigin(value) {
+  try {
+    if (typeof value !== "string") return false;
+    hostRelayGatewayEndpoint(value);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function assertOwnerPrivateDirectory(path) {
+  const stats = await lstat2(path);
+  if (!stats.isDirectory() || stats.isSymbolicLink() || !ownerPrivate3(stats)) throw new HostRelayGatewayError("credential", "Host Relay credential directory is not owner-private.");
+}
+function ownerPrivate3(stats) {
+  if (process.platform === "win32") return true;
+  const uid = typeof process.geteuid === "function" ? process.geteuid() : stats.uid;
+  return stats.uid === uid && (stats.mode & 63) === 0;
+}
+function acknowledgement(value) {
+  const fields = isCealJsonRecord(value) ? value : {};
+  if (!isCealJsonRecord(value) || value.ok !== true || value.status !== "accepted" || typeof value.request_ref !== "string" || !SAFE_HOST_REF.test(value.request_ref) || !isHostGatewayAcknowledgementDisposition(value.disposition)) {
+    throw new HostRelayGatewayError("invalid_response", `Gateway Host ingress acknowledgement is invalid: ${refusalFacts([{ name: "ok", value: fields.ok, expected: "true" }, { name: "status", value: fields.status, expected: "accepted" }, { name: "request_ref", value: fields.request_ref, expected: "a safe Host reference" }, { name: "disposition", value: fields.disposition, expected: "a Gateway acknowledgement disposition" }])}.`);
+  }
+  return { request_ref: value.request_ref, disposition: value.disposition };
+}
+
+// host/relay/src/relay-ipc.ts
+import { chmod, lstat as lstat3, unlink as unlink2 } from "node:fs/promises";
+import { createConnection, createServer } from "node:net";
+var HOST_RELAY_REQUEST_BINDING_KEYS = Object.freeze([
+  "schema_version",
+  "producer_id",
+  "producer_installation_ref",
+  "local_session_ref",
+  "local_turn_ref",
+  "local_turn_aliases",
+  "prompt_ref",
+  "request_ref",
+  "bound_at",
+  "host_source_ref",
+  "host_session_ref",
+  "host_turn_ref",
+  "host_input_ref"
+]);
+var HOST_RELAY_IPC_RESPONSE_SCHEMA = "ceal.host_relay_admission.v1";
+var HOST_RELAY_BINDING_QUERY_SCHEMA = "ceal.host_relay_binding_query.v1";
+var HOST_RELAY_BINDING_RESULT_SCHEMA = "ceal.host_relay_binding_result.v1";
+var HOST_RELAY_INVOCATION_CONTEXT_QUERY_SCHEMA = "ceal.host_relay_invocation_context_query.v1";
+var HOST_RELAY_INVOCATION_CONTEXT_RESULT_SCHEMA = "ceal.host_relay_invocation_context_result.v1";
+var HostRelayIpcError = class extends Error {
+  code;
+  constructor(code, message = code) {
+    super(message);
+    this.code = code;
+  }
+};
+async function startHostRelayIpcServer(options) {
+  await assertEndpointVacant(options.endpoint);
+  const active = /* @__PURE__ */ new Map();
+  const sockets = /* @__PURE__ */ new Set();
+  const quarantine = options.quarantine ?? options.admission.quarantine;
+  const server = createServer((socket) => serveSocket(socket, options.admission, options.bindings, options.mintInvocationContext, quarantine, active, sockets));
+  await listen(server, options.endpoint);
+  if (process.platform !== "win32") await chmod(options.endpoint, 384);
+  return { endpoint: options.endpoint, close: () => closeServer(server, sockets, options.endpoint) };
+}
+function encodeHostRelayIpcResponse(response2) {
+  const body = Buffer.from(JSON.stringify(response2), "utf8");
+  const result2 = Buffer.allocUnsafe(body.length + 4);
+  result2.writeUInt32BE(body.length, 0);
+  body.copy(result2, 4);
+  return result2;
+}
+function serveSocket(socket, admission, bindings, mintInvocationContext, quarantine, active, sockets) {
+  const state = { buffer: Buffer.alloc(0), closed: false, tail: Promise.resolve() };
+  sockets.add(socket);
+  socket.on("data", (chunk) => {
+    state.buffer = Buffer.concat([state.buffer, Buffer.from(chunk)]);
+    state.tail = state.tail.then(() => drainFrames(socket, state, admission, bindings, mintInvocationContext, quarantine, active)).catch(() => {
+      writeResponse(socket, errorResponse("relay_unavailable"));
+      socket.end();
+    });
+  });
+  socket.once("error", () => closeConnection(socket, state, active, sockets));
+  socket.once("close", () => closeConnection(socket, state, active, sockets));
+  socket.once("end", () => {
+    if (state.buffer.length > 0) void quarantine.retainMalformed(state.buffer, "frame_truncated").finally(() => {
+      writeResponse(socket, errorResponse("frame_truncated"));
+      socket.end();
+    });
+    else socket.end();
+  });
+}
+async function drainFrames(socket, state, admission, bindings, mintInvocationContext, quarantine, active) {
+  while (!state.closed && state.buffer.length >= 4 && await processBufferedRequest(socket, state, admission, bindings, mintInvocationContext, quarantine, active)) {
+  }
+}
+async function processBufferedRequest(socket, state, admission, bindings, mintInvocationContext, quarantine, active) {
+  const length = state.buffer.readUInt32BE(0);
+  if (length === 0 || length > HOST_PRODUCER_MAX_JSON_BYTES) {
+    const code = length === 0 ? "invalid_frame_length" : "frame_too_large";
+    const raw = state.buffer.subarray(0, Math.min(state.buffer.length, length + 4));
+    await quarantine.retainMalformed(raw, code);
+    writeResponse(socket, errorResponse(code));
+    state.buffer = Buffer.alloc(0);
+    socket.end();
+    return false;
+  }
+  if (state.buffer.length < length + 4) return false;
+  const encoded = state.buffer.subarray(0, length + 4);
+  state.buffer = state.buffer.subarray(length + 4);
+  let request2;
+  try {
+    request2 = decodeIpcRequest(encoded);
+  } catch (error) {
+    const code = error instanceof HostProducerFrameError ? error.code : "invalid_frame_shape";
+    await quarantine.retainMalformed(encoded, code);
+    writeResponse(socket, errorResponse(code));
+    return true;
+  }
+  if (await processHostQuery(socket, request2, bindings, mintInvocationContext)) return true;
+  await processProducerRequest(socket, state, request2, encoded, admission, quarantine, active);
+  return true;
+}
+async function processProducerRequest(socket, state, request2, encoded, admission, quarantine, active) {
+  if (!("producer_epoch" in request2)) throw new HostRelayIpcError("relay_unavailable");
+  const ownership = claimProducer(socket, state, request2, active);
+  if (ownership !== null) {
+    if (ownership === "invalid_producer_identity") await quarantine.retainMalformed(encoded, ownership);
+    writeResponse(socket, errorResponse(ownership));
+    if (ownership === "invalid_producer_identity") socket.end();
+    return;
+  }
+  writeResponse(socket, admissionResponse(await admission.admit(request2)));
+}
+async function processHostQuery(socket, request2, bindings, mint) {
+  if (request2.schema_version === HOST_RELAY_BINDING_QUERY_SCHEMA) {
+    writeBindingResponse(socket, await bindings.query(bindingQueryFromRequest(request2)));
+    return true;
+  }
+  if (request2.schema_version === HOST_RELAY_INVOCATION_CONTEXT_QUERY_SCHEMA) {
+    writeInvocationContextResponse(socket, await resolveInvocationContext(request2, bindings, mint));
+    return true;
+  }
+  return false;
+}
+function claimProducer(socket, state, frame, active) {
+  const key = producerKey(frame);
+  if (state.producer_key !== void 0) return state.producer_key === key && state.producer_epoch === frame.producer_epoch ? null : "invalid_producer_identity";
+  const incumbent = active.get(key);
+  if (incumbent !== void 0 && incumbent.socket !== socket) {
+    if (frame.producer_epoch <= incumbent.epoch) return "producer_already_connected";
+    incumbent.socket.destroy();
+  }
+  state.producer_key = key;
+  state.producer_epoch = frame.producer_epoch;
+  active.set(key, { socket, epoch: frame.producer_epoch });
+  return null;
+}
+function closeConnection(socket, state, active, sockets) {
+  state.closed = true;
+  sockets.delete(socket);
+  if (state.producer_key !== void 0 && active.get(state.producer_key)?.socket === socket) active.delete(state.producer_key);
+}
+function writeResponse(socket, response2) {
+  if (!socket.destroyed) socket.write(encodeHostRelayIpcResponse(response2));
+}
+function writeBindingResponse(socket, result2) {
+  const response2 = { schema_version: HOST_RELAY_BINDING_RESULT_SCHEMA, ...result2 };
+  if (!socket.destroyed) socket.write(encodeLengthPrefixed(response2));
+}
+function writeInvocationContextResponse(socket, response2) {
+  if (!socket.destroyed) socket.write(encodeLengthPrefixed(response2));
+}
+async function resolveInvocationContext(request2, bindings, mint) {
+  if (mint === void 0) throw new HostRelayIpcError("relay_unavailable");
+  const binding = await bindings.query(bindingQueryFromRequest(request2));
+  if (binding.status !== "ready") return { schema_version: HOST_RELAY_INVOCATION_CONTEXT_RESULT_SCHEMA, ...binding };
+  const result2 = await mint({ client_nonce: request2.client_nonce, context_expires_at: binding.binding.context_expires_at ?? binding.binding.bound_at, request_work_context: relayRequestWorkContextFromBinding(binding.binding) }, new AbortController().signal);
+  return { schema_version: HOST_RELAY_INVOCATION_CONTEXT_RESULT_SCHEMA, status: "ready", result: result2 };
+}
+function admissionResponse(result2) {
+  return { schema_version: HOST_RELAY_IPC_RESPONSE_SCHEMA, ...result2 };
+}
+function errorResponse(code) {
+  return { schema_version: HOST_RELAY_IPC_RESPONSE_SCHEMA, code, admitted_through_sequence: 0, delivered_through_sequence: 0 };
+}
+function producerKey(frame) {
+  return `${frame.producer_id}\0${frame.producer_installation_ref}`;
+}
+function record4(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function decodeIpcRequest(input) {
+  const value = decodeLengthPrefixedJson(input, HOST_PRODUCER_MAX_JSON_BYTES);
+  if (value !== null && record4(value) && value.schema_version === HOST_RELAY_BINDING_QUERY_SCHEMA) {
+    if (!validBindingQueryRequest(value)) throw new HostProducerFrameError("invalid_frame_shape");
+    return value;
+  }
+  if (value !== null && record4(value) && value.schema_version === HOST_RELAY_INVOCATION_CONTEXT_QUERY_SCHEMA) {
+    if (!validInvocationContextQueryRequest(value)) throw new HostProducerFrameError("invalid_frame_shape");
+    return value;
+  }
+  return decodeHostProducerFrame(input);
+}
+function validBindingQueryRequest(value) {
+  return validQueryIdentity(value, HOST_RELAY_BINDING_QUERY_SCHEMA) && exactKeys4(value, ["schema_version", "producer_id", "producer_installation_ref", "local_session_ref", "local_turn_ref"]);
+}
+function bindingQueryFromRequest(value) {
+  return { producer_id: value.producer_id, producer_installation_ref: value.producer_installation_ref, local_session_ref: value.local_session_ref, local_turn_ref: value.local_turn_ref };
+}
+function validInvocationContextQueryRequest(value) {
+  return validQueryIdentity(value, HOST_RELAY_INVOCATION_CONTEXT_QUERY_SCHEMA) && exactKeys4(value, ["schema_version", "producer_id", "producer_installation_ref", "local_session_ref", "local_turn_ref", "client_nonce"]) && typeof value.client_nonce === "string" && CEAL_HOST_CLIENT_NONCE_PATTERN.test(value.client_nonce);
+}
+function validQueryIdentity(value, schema) {
+  return record4(value) && value.schema_version === schema && (value.producer_id === "codex" || value.producer_id === "claude") && safeRef3(value.producer_installation_ref) && safeRef3(value.local_session_ref) && safeRef3(value.local_turn_ref);
+}
+function decodeLengthPrefixedJson(input, maximum) {
+  if (input.length < 4) return null;
+  const length = input.readUInt32BE(0);
+  if (length === 0 || length > maximum) throw new HostRelayIpcError("relay_unavailable", `Host Relay IPC message length is invalid: ${refusalFact("declared_bytes", length, `between 1 and ${maximum}`)}.`);
+  if (input.length < length + 4) return null;
+  if (input.length !== length + 4) throw new HostRelayIpcError("relay_unavailable", `Host Relay IPC message has trailing bytes: ${refusalFacts([{ name: "declared_bytes", value: length, expected: "the received message length minus 4" }, { name: "received_bytes", value: input.byteLength, expected: `exactly ${length + 4}` }])}.`);
+  try {
+    return JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(input.subarray(4)));
+  } catch {
+    throw new HostRelayIpcError("relay_unavailable", "Host Relay IPC message is invalid.");
+  }
+}
+function encodeLengthPrefixed(value) {
+  const body = Buffer.from(JSON.stringify(value), "utf8");
+  const output = Buffer.allocUnsafe(body.length + 4);
+  output.writeUInt32BE(body.length, 0);
+  body.copy(output, 4);
+  return output;
+}
+function exactKeys4(value, keys) {
+  return Object.keys(value).length === keys.length && keys.every((key) => Object.hasOwn(value, key));
+}
+function safeRef3(value) {
+  return typeof value === "string" && /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u.test(value);
+}
+async function assertEndpointVacant(endpoint) {
+  try {
+    await lstat3(endpoint);
+    throw new HostRelayIpcError("relay_unavailable", "Host Relay IPC endpoint is already present.");
+  } catch (error) {
+    if (errorCode7(error) !== "ENOENT") throw error;
+  }
+}
+function listen(server, endpoint) {
+  return new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(endpoint, () => {
+      server.removeListener("error", reject);
+      resolve();
+    });
+  });
+}
+async function closeServer(server, sockets, endpoint) {
+  for (const socket of sockets) socket.destroy();
+  await new Promise((resolve) => server.close(() => resolve()));
+  if (process.platform !== "win32") await unlink2(endpoint).catch(() => void 0);
+}
+function errorCode7(error) {
+  return record4(error) && typeof error.code === "string" ? error.code : null;
+}
+
+// host/relay/src/host-relay-runtime.ts
+var HOST_RELAY_CONFIG_SCHEMA = "ceal.host_relay_config.v1";
+var HostRelayConfigError = class extends Error {
+  name = "HostRelayConfigError";
+  code;
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+  }
+};
+async function readHostRelayConfig(path) {
+  if (!isAbsoluteNormalizedNonRootPath(path, process.platform, true)) throw new HostRelayConfigError("invalid_config_path", `invalid_config_path: Host Relay config path is invalid: ${refusalFact("config_path", path, "absolute, normalized, and non-root")}.`);
+  let handle;
+  try {
+    await assertOwnerPrivateDirectory2(dirname3(path));
+    handle = await open4(path, O_RDONLY4 | O_NOFOLLOW3);
+    const stats = await handle.stat();
+    if (!stats.isFile() || !ownerPrivate4(stats)) throw new HostRelayConfigError("config_not_private", "Host Relay config file is not owner-private.");
+    if (stats.size < 2 || stats.size > 65536) throw new HostRelayConfigError("invalid_config", `invalid_config: Host Relay config size is invalid: ${refusalFact("config_bytes", stats.size, "between 2 and 65536")}.`);
+    const text = await handle.readFile("utf8");
+    assertNoDuplicateJsonKeys(text);
+    let value;
+    try {
+      value = JSON.parse(text);
+    } catch {
+      throw new HostRelayConfigError("invalid_json", "Host Relay config is not JSON.");
+    }
+    return decodeHostRelayConfig(value);
+  } catch (error) {
+    if (error instanceof HostRelayConfigError) throw error;
+    throw new HostRelayConfigError("config_unavailable", "Host Relay config is unavailable.");
+  } finally {
+    await handle?.close();
+  }
+}
+function decodeHostRelayConfig(value) {
+  const required = ["schema_version", "registration_state_file", "host_source_ref", "state_root", "ipc_endpoint"];
+  const optional = ["drain_interval_ms", "gateway_timeout_ms"];
+  if (!record5(value) || !exactOptionalKeys2(value, required, optional) || !validConfigIdentity(value) || !validConfigRuntime(value)) {
+    throw new HostRelayConfigError("invalid_config", "Host Relay config shape is invalid.");
+  }
+  return {
+    schema_version: HOST_RELAY_CONFIG_SCHEMA,
+    registration_state_file: value.registration_state_file,
+    host_source_ref: value.host_source_ref,
+    state_root: value.state_root,
+    ipc_endpoint: value.ipc_endpoint,
+    drain_interval_ms: value.drain_interval_ms ?? 250,
+    gateway_timeout_ms: value.gateway_timeout_ms ?? 5e3
+  };
+}
+function validConfigIdentity(value) {
+  return value.schema_version === HOST_RELAY_CONFIG_SCHEMA && isAbsoluteNormalizedNonRootPath(value.registration_state_file, process.platform, true) && opaqueHostSourceRef(value.host_source_ref);
+}
+function validConfigRuntime(value) {
+  return isAbsoluteNormalizedNonRootPath(value.state_root, process.platform, true) && isAbsoluteNormalizedNonRootPath(value.ipc_endpoint, process.platform, true) && boundedInteger(value.drain_interval_ms, 50, 3e4, true) && boundedInteger(value.gateway_timeout_ms, 100, 6e4, true);
+}
+async function serveHostRelay(config, signal, dependencies = {}) {
+  const admission = new RelayAdmissionStore(join6(config.state_root, "admission"));
+  const bindings = new RelayRequestBindingStore(join6(config.state_root, "bindings"));
+  const gateway = (dependencies.createGateway ?? createHostRelayGatewayHttpPort)({ registration_state_file: config.registration_state_file, host_source_ref: config.host_source_ref });
+  const bridge = new RelayGatewayBridge({ state_root: join6(config.state_root, "gateway"), host_source_ref: config.host_source_ref, gateway, timeout_ms: config.gateway_timeout_ms, on_request_bound: async (binding) => {
+    await bindings.bind(binding);
+  } });
+  let server;
+  try {
+    server = await (dependencies.startIpc ?? startHostRelayIpcServer)({ endpoint: config.ipc_endpoint, admission, bindings, mintInvocationContext: (input, invocationSignal) => gateway.mintInvocationContext(input, invocationSignal) });
+    while (!signal.aborted) {
+      const round = await admission.drainRound((input) => bridge.deliver(input), { now_ms: (dependencies.now ?? Date.now)(), host_source_ref: config.host_source_ref });
+      if (round.delivered.length === 0 && round.refused.length === 0) await (dependencies.wait ?? ((milliseconds, waitSignal) => waitForAbort(waitSignal, milliseconds)))(config.drain_interval_ms, signal);
+    }
+  } finally {
+    await server?.close();
+  }
+}
+async function runHostRelayCli(args, signal, dependencies = {}) {
+  try {
+    const configPath = parseServeArgs(args);
+    const config = await (dependencies.readConfig ?? readHostRelayConfig)(configPath);
+    await serveHostRelay(config, signal, dependencies);
+    return { ok: true, status: "stopped" };
+  } catch (error) {
+    if (error instanceof HostRelayConfigError) return { ok: false, code: error.code };
+    return { ok: false, ...hostTerminalFailure(error, "Relay") };
+  }
+}
+function parseServeArgs(args) {
+  if (args.length !== 3 || args[0] !== "serve" || args[1] !== "--config" || !isAbsoluteNormalizedNonRootPath(args[2], process.platform, true)) {
+    throw new HostRelayConfigError("invalid_config_path", `invalid_config_path: Use: relay.mjs serve --config <absolute-owner-private-json>: ${refusalFact("args", args, "serve --config <absolute normalized non-root path>")}.`);
+  }
+  return args[2];
+}
+async function assertOwnerPrivateDirectory2(path) {
+  try {
+    const stats = await lstat4(path);
+    if (!stats.isDirectory() || stats.isSymbolicLink() || !ownerPrivate4(stats)) throw new HostRelayConfigError("config_not_private", "Host Relay config directory is not owner-private.");
+  } catch (error) {
+    if (error instanceof HostRelayConfigError) throw error;
+    throw new HostRelayConfigError("config_unavailable", "Host Relay config directory is unavailable.");
+  }
+}
+function ownerPrivate4(stats) {
+  if (process.platform === "win32") return true;
+  const uid = typeof process.geteuid === "function" ? process.geteuid() : stats.uid;
+  return stats.uid === uid && (stats.mode & 63) === 0;
+}
+function assertNoDuplicateJsonKeys(text) {
+  rejectDuplicateJsonKeys(text, {
+    invalid: () => new HostRelayConfigError("invalid_json", "Host Relay config is not JSON."),
+    duplicate: () => new HostRelayConfigError("duplicate_config_field", "Host Relay config contains a duplicate field.")
+  });
+}
+function boundedInteger(value, minimum, maximum, optional) {
+  return optional && value === void 0 || Number.isSafeInteger(value) && Number(value) >= minimum && Number(value) <= maximum;
+}
+function record5(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function exactOptionalKeys2(value, required, optional) {
+  const keys = Object.keys(value);
+  return required.every((key) => Object.hasOwn(value, key)) && keys.every((key) => required.includes(key) || optional.includes(key));
+}
+
+// host/relay/bin/ceal-host-relay.ts
+var controller = new AbortController();
+var stop = () => controller.abort();
+process.once("SIGINT", stop);
+process.once("SIGTERM", stop);
+void runHostRelayCli(process.argv.slice(2), controller.signal).then((result2) => {
+  process.stdout.write(`${JSON.stringify({ schema_version: "ceal.host_relay_command.v1", ...result2 })}
+`);
+  process.exitCode = result2.ok ? 0 : 1;
+}).catch((error) => {
+  process.stdout.write(`${JSON.stringify({ schema_version: "ceal.host_relay_command.v1", ok: false, ...hostTerminalFailure(error, "Relay") })}
+`);
+  process.exitCode = 1;
+}).finally(() => {
+  process.removeListener("SIGINT", stop);
+  process.removeListener("SIGTERM", stop);
+});