@corca-org/ceal-host-linux-arm64 1.0.17 → 1.0.18

package/libexec/ceal-host/relay.mjs

@@ -200,6 +200,9 @@ var CEAL_COMMAND_RESPONSE_DISCOVERY_MANIFEST_DOCUMENT_FIELDS = Object.freeze([..
 function vocabulary(words) {
   return Object.freeze(words);
 }
+function isVocabularyWord(words, value) {
+  return words.some((word) => word === value);
+}
 
 // packages/ceal-client-protocol/src/gateway-response-types.ts
 var CEAL_OPERATION_READINESS_VALUES = vocabulary(["ready", "degraded", "unavailable", "unknown"]);
@@ -950,7 +953,7 @@ var OPTIONAL_FIELDS = CEAL_CLIENT_WIRE_CONTRACT.command_response.bare_document_o
 // packages/ceal-client-protocol/src/resource-row.ts
 var CEAL_RESOURCE_SEARCH_ORDERS = vocabulary(["relevance", "modified", "viewed", "created"]);
 var CEAL_RESOURCE_SEARCH_DIRECTIONS = vocabulary(["ascending", "descending"]);
-var CEAL_RESOURCE_SEARCH_FILTERS = vocabulary(["query", "modified_since", "since", "until", "authored_by_me", "include_replies", "kinds", "container_ref", "container_refs", "container_names", "addressed_to_me", "unread"]);
+var CEAL_RESOURCE_SEARCH_FILTERS = vocabulary(["query", "modified_since", "since", "until", "authored_by_me", "authored_by", "include_replies", "kinds", "container_ref", "container_refs", "container_names", "addressed_to_me", "unread"]);
 var CEAL_RESOURCE_TIME_BASES = vocabulary(["created", "modified", "viewed"]);
 var CEAL_REPOSITORY_VISIBILITIES = vocabulary(["public", "private", "internal"]);
 var CEAL_ACTIVITY_V3_KINDS = vocabulary(["authored", "edited", "messaged", "responded"]);
@@ -1029,6 +1032,7 @@ var RESOURCE_ROW_KEY_RULES = Object.freeze({
   ref: { required: true, timestamp: false },
   next: { required: true, timestamp: false },
   kind: { required: true, timestamp: false },
+  matched_kinds: { required: false, timestamp: false },
   title: { required: true, timestamp: false },
   container_label: { required: true, timestamp: false },
   container_ref: { required: false, timestamp: false },
@@ -1419,6 +1423,16 @@ var CEAL_HOST_INVOCATION_AUTHENTICATION_RESULT_MAX_BYTES = new TextEncoder().enc
   expires_at: (/* @__PURE__ */ new Date("+010000-01-01T00:00:00.000Z")).toISOString()
 })}
 `).byteLength;
+var CEAL_HOST_MINT_REQUEST_CONTEXT_REFUSAL_REASONS = vocabulary([
+  "request_authority_unavailable",
+  "request_missing",
+  "authority_mismatch",
+  "host_source_mismatch",
+  "host_session_mismatch",
+  "host_turn_mismatch",
+  "host_input_mismatch",
+  "host_prompt_mismatch"
+]);
 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.");
@@ -1437,8 +1451,8 @@ function exactKeys(value, expected) {
 // packages/ceal-client-protocol/src/client-result-materialization.ts
 var CEAL_UNREAD_REASONS = vocabulary(["blocked", "unavailable", "too_large", "unsupported", "download_failed", "permission_denied"]);
 var CEAL_MODEL_VISIBLE_COMMAND_OUTPUT_MAX_BYTES = 32 * 1024;
-var REQUIRED_FIELDS2 = Object.freeze(["schema_version", "operation_id"]);
-var FIELDS = /* @__PURE__ */ new Set([...REQUIRED_FIELDS2, "read_argv", "local_result_root", "continue_argv", "model_disclosure", "item_read_argv"]);
+var REQUIRED_FIELDS2 = Object.freeze(["schema_version", "operation_id", "read_argv"]);
+var FIELDS = /* @__PURE__ */ new Set([...REQUIRED_FIELDS2, "local_result_root", "continue_argv", "model_disclosure"]);
 
 // packages/ceal-client-protocol/src/gateway-cache-origin-validation.ts
 var CEAL_MAX_CACHE_ORIGIN_AGE_MS = 30 * 24 * 60 * 60 * 1e3;
@@ -1649,7 +1663,7 @@ function assertHostRelaySourcePaths(stateRoot, config, platform = process.platfo
 // 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 open5 } from "node:fs/promises";
-import { dirname as dirname3, join as join6 } from "node:path";
+import { dirname as dirname4, join as join7 } from "node:path";
 
 // host/abortable-wait.ts
 function waitForAbort(signal, milliseconds) {
@@ -1753,6 +1767,9 @@ var HostProducerFrameError = class extends Error {
     this.code = code;
   }
 };
+function assertHostProducerFrame(value) {
+  validateFrame(value);
+}
 function encodeHostProducerFrame(frame) {
   validateFrame(frame);
   const json = Buffer.from(JSON.stringify(frame), "utf8");
@@ -2433,31 +2450,53 @@ var RelayAdmissionStore = class {
     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);
-      const exhausted = retryExhausted(outcome, head);
-      if (outcome.status === "retryable" && !exhausted) {
-        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" || exhausted) {
-        await this.quarantine.retainFrame(head.frame, "gateway_refused");
-        installation2.last_refusal = { sequence: head.sequence, submission_ref: input.submission_ref, ...refusalCause(outcome, head), 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);
+      if (await this.refusePoisonHead(state, head, options, refused)) continue;
+      await this.deliverHead(state, head, deliver, options, delivered, retained, refused);
     }
     return { delivered, retained, refused };
   }
+  async deliverHead(state, head, deliver, options, delivered, retained, refused) {
+    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);
+    const exhausted = retryExhausted(outcome, head);
+    if (outcome.status === "retryable" && !exhausted) {
+      scheduleRetry(head, options.now_ms, outcome.reason);
+      retained.push(input.submission_ref);
+      await this.write(state);
+      return;
+    }
+    const installation2 = state.installations[installationKey(head.frame)];
+    if (!installation2) throw new TypeError("Host Relay delivery installation is unavailable.");
+    if (outcome.status === "refused" || exhausted) {
+      await this.quarantine.retainFrame(head.frame, "gateway_refused");
+      installation2.last_refusal = { sequence: head.sequence, submission_ref: input.submission_ref, ...refusalCause(outcome, head), 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);
+  }
+  async refusePoisonHead(state, head, options, refused) {
+    const poison = poisonFrameError(head.frame);
+    if (poison === null) return false;
+    const installation2 = state.installations[installationKey(head)];
+    if (!hasIntactAdmissionEnvelope(head, installation2)) throw new TypeError("Host Relay admission state is invalid.");
+    const json = Buffer.from(JSON.stringify(head.frame), "utf8");
+    const raw = Buffer.allocUnsafe(json.byteLength + 4);
+    raw.writeUInt32BE(json.byteLength, 0);
+    json.copy(raw, 4);
+    await this.quarantine.retainMalformed(raw, poison.code);
+    const submissionRef = hostProducerSubmissionRef(options.host_source_ref, { producer_id: head.producer_id, producer_installation_ref: head.producer_installation_ref, sequence: head.sequence });
+    installation2.last_refusal = { sequence: head.sequence, submission_ref: submissionRef, code: poison.code, message: `Host Relay persisted frame is invalid: ${poison.code}.`, refused_at_ms: options.now_ms };
+    refused.push(submissionRef);
+    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 true;
+  }
   async read() {
     try {
       return decodeState3(JSON.parse(await readFile2(join4(this.root, "admission.json"), "utf8")));
@@ -2523,6 +2562,8 @@ function decodeState3(value) {
   const entries = [];
   for (const item of value.entries) {
     if (!entry(item)) throw new TypeError("Host Relay entry state is invalid.");
+    poisonFrameError(item.frame);
+    if (!hasIntactAdmissionEnvelope(item, installations[installationKey(item)])) throw new TypeError("Host Relay admission state is invalid.");
     entries.push(item);
   }
   return { schema_version: "ceal.host_relay_admission_state.v1", installations, entries };
@@ -2545,6 +2586,60 @@ function producer2(value) {
 function object(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+function poisonFrameError(frame) {
+  try {
+    assertHostProducerFrame(frame);
+    return null;
+  } catch (error) {
+    if (error instanceof HostProducerFrameError) return error;
+    throw error;
+  }
+}
+function hasIntactAdmissionEnvelope(entryValue, installation2) {
+  if (installation2 === void 0) return false;
+  return poisonIdentityValid(entryValue) && poisonEnvelopeMatches(entryValue, installation2) && poisonIntegrityMatches(entryValue) && poisonSequenceInRange(entryValue, installation2);
+}
+function poisonIdentityValid(entryValue) {
+  if (entryValue.producer_id !== "codex" && entryValue.producer_id !== "claude") return false;
+  if (!opaqueHostSourceRef(entryValue.producer_installation_ref)) return false;
+  return Number.isSafeInteger(entryValue.sequence) && entryValue.sequence > 0;
+}
+function poisonEnvelopeMatches(entryValue, installation2) {
+  const frame = entryValue.frame;
+  if (!object(frame)) return false;
+  return poisonEnvelopeSchema(frame) && poisonEnvelopeProducer(frame, entryValue) && poisonEnvelopeInstallation(frame, entryValue) && poisonEnvelopeEpoch(frame, installation2) && poisonEnvelopeSequence(frame, entryValue) && poisonEnvelopeKind(frame) && poisonEnvelopeTimestamp(frame);
+}
+function poisonEnvelopeSchema(frame) {
+  return frame.schema_version === "ceal.host_producer_frame.v1";
+}
+function poisonEnvelopeProducer(frame, entryValue) {
+  return producer2(frame.producer_id) && frame.producer_id === entryValue.producer_id;
+}
+function poisonEnvelopeInstallation(frame, entryValue) {
+  return opaqueHostSourceRef(frame.producer_installation_ref) && frame.producer_installation_ref === entryValue.producer_installation_ref;
+}
+function poisonEnvelopeEpoch(frame, installation2) {
+  return Number.isSafeInteger(frame.producer_epoch) && typeof frame.producer_epoch === "number" && frame.producer_epoch > 0 && frame.producer_epoch <= installation2.epoch;
+}
+function poisonEnvelopeSequence(frame, entryValue) {
+  return Number.isSafeInteger(frame.sequence) && frame.sequence === entryValue.sequence;
+}
+function poisonEnvelopeKind(frame) {
+  return isHostProducerFrameKind(frame.frame_kind);
+}
+function poisonEnvelopeTimestamp(frame) {
+  return typeof frame.occurred_at === "string" && Number.isFinite(Date.parse(frame.occurred_at));
+}
+function poisonIntegrityMatches(entryValue) {
+  const frame = entryValue.frame;
+  if (!object(frame)) return false;
+  const json = JSON.stringify(frame);
+  return entryValue.charged_bytes === 4 + Buffer.byteLength(json, "utf8") && entryValue.hash === hostProducerFrameHash(entryValue.frame);
+}
+function poisonSequenceInRange(entryValue, installation2) {
+  if (entryValue.sequence <= installation2.delivered_through_sequence) return false;
+  return entryValue.sequence <= installation2.admitted_through_sequence;
+}
 
 // host/relay/src/relay-gateway-bridge.ts
 import { readFile as readFile3 } from "node:fs/promises";
@@ -2889,20 +2984,29 @@ var HostRelayGatewayError = class extends Error {
   status;
   /** The Gateway's own refusal word, when it named one; a bounded token, never its message. */
   error_code;
-  constructor(code, message, status, errorCode9) {
+  /** The Gateway mint refusal's bounded continuity reason, when it named one; a fixed token, never its message. */
+  refusal_reason;
+  constructor(code, message, status, errorCode9, refusalReason) {
     super(message);
     this.code = code;
     if (status !== void 0) this.status = status;
     if (errorCode9 !== void 0) this.error_code = errorCode9;
+    if (refusalReason !== void 0) this.refusal_reason = refusalReason;
   }
 };
 var GATEWAY_REFUSAL_CODE_PATTERN = /^[a-z][a-z0-9_]{0,63}$/u;
-async function gatewayRefusalCode(response2) {
+async function gatewayRefusal(response2) {
   try {
     const body = await response2.json();
-    return isCealJsonRecord(body) && typeof body.error_code === "string" && GATEWAY_REFUSAL_CODE_PATTERN.test(body.error_code) ? body.error_code : void 0;
+    if (!isCealJsonRecord(body)) return {};
+    const code = typeof body.error_code === "string" && GATEWAY_REFUSAL_CODE_PATTERN.test(body.error_code) ? body.error_code : void 0;
+    const reason = code === "request_context_refused" && typeof body.reason === "string" && GATEWAY_REFUSAL_CODE_PATTERN.test(body.reason) && isVocabularyWord(CEAL_HOST_MINT_REQUEST_CONTEXT_REFUSAL_REASONS, body.reason) ? body.reason : void 0;
+    return {
+      ...code === void 0 ? {} : { code },
+      ...reason === void 0 ? {} : { reason }
+    };
   } catch {
-    return void 0;
+    return {};
   }
 }
 function refusalMessage(status, body) {
@@ -2950,7 +3054,10 @@ function createHostRelayGatewayHttpPort(options) {
       } 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, await gatewayRefusalCode(response2));
+      if (!response2.ok) {
+        const refusal = await gatewayRefusal(response2);
+        throw new HostRelayGatewayError(response2.status === 401 ? "credential" : "gateway_refused", `Gateway Host invocation context was refused (${response2.status}).`, response2.status, refusal.code, refusal.reason);
+      }
       let value;
       try {
         value = await response2.json();
@@ -3071,8 +3178,9 @@ function acknowledgement(value) {
 }
 
 // host/relay/src/relay-ipc.ts
-import { chmod, lstat as lstat3, unlink as unlink2 } from "node:fs/promises";
+import { chmod, lstat as lstat3, rename as rename2, unlink as unlink2 } from "node:fs/promises";
 import { createConnection, createServer } from "node:net";
+import { dirname as dirname3, join as join6 } from "node:path";
 
 // host/relay/src/current-prompt-custody.ts
 import { createHash as createHash5 } from "node:crypto";
@@ -3153,7 +3261,15 @@ var HOST_RELAY_INVOCATION_MINT_REFUSAL_REASONS = vocabulary([
   "deadline",
   "cancelled",
   "mint_failed",
-  "relay_failed"
+  "relay_failed",
+  "request_authority_unavailable",
+  "request_missing",
+  "authority_mismatch",
+  "host_source_mismatch",
+  "host_session_mismatch",
+  "host_turn_mismatch",
+  "host_input_mismatch",
+  "host_prompt_mismatch"
 ]);
 var HostRelayInvocationMintRefusal = class extends Error {
   reason;
@@ -3185,15 +3301,42 @@ var HostRelayIpcError = class extends Error {
   }
 };
 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 currentPrompts = options.currentPrompts ?? new HostCurrentPromptCustody();
-  const server = createServer((socket) => serveSocket(socket, options, currentPrompts, 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) };
+  return withRelayEndpointLock(options.endpoint, async () => {
+    if (process.platform === "win32") {
+      await assertEndpointVacant(options.endpoint);
+    } else {
+      await assertTrustedEndpointParent(options.endpoint);
+      await removeStaleRelayEndpoint(options.endpoint, options.testHooks);
+    }
+    const active = /* @__PURE__ */ new Map();
+    const sockets = /* @__PURE__ */ new Set();
+    const quarantine = options.quarantine ?? options.admission.quarantine;
+    const currentPrompts = options.currentPrompts ?? new HostCurrentPromptCustody();
+    const server = createServer((socket) => serveSocket(socket, options, currentPrompts, quarantine, active, sockets));
+    if (process.platform === "win32") {
+      try {
+        await listen(server, options.endpoint);
+      } catch (error) {
+        await abandonRelayServer(server, sockets);
+        throw error;
+      }
+      return { endpoint: options.endpoint, close: () => closeServer(server, sockets, options.endpoint) };
+    }
+    const staging = stagingRelayEndpoint(options.endpoint);
+    await listenStagingRelayEndpoint(server, sockets, staging);
+    let owned;
+    try {
+      await options.testHooks?.beforeCaptureOwnedEndpoint?.(options.endpoint);
+      owned = await readStagingRelayEndpointIdentity(staging);
+      await chmod(staging, 384);
+      const identity = await publishStagingRelayEndpoint(staging, owned, options.endpoint);
+      return { endpoint: options.endpoint, close: () => closeRelayServer(server, sockets, options.endpoint, identity, options.testHooks) };
+    } catch (error) {
+      if (owned !== void 0) await releaseOwnedRelayEndpoint(server, sockets, options.endpoint, owned);
+      else await abandonRelayServer(server, sockets);
+      throw error;
+    }
+  });
 }
 function encodeHostRelayIpcResponse(response2) {
   const body = Buffer.from(JSON.stringify(response2), "utf8");
@@ -3355,8 +3498,9 @@ function writeCurrentPromptResponse(socket, status) {
 async function resolveInvocationContext(request2, admission, bindings, currentPrompts, mint, signal) {
   if (mint === void 0) throw new HostRelayIpcError("relay_unavailable");
   const query = bindingQueryFromRequest(request2);
+  const expectedSequences = pendingAdmissionSequences(await admission.snapshot(), query);
   const binding = await waitForRequestBinding(query, admission, bindings, signal);
-  if (binding.status !== "ready") return { schema_version: HOST_RELAY_INVOCATION_CONTEXT_RESULT_SCHEMA, status: "no_binding" };
+  if (binding.status !== "ready") return unboundInvocationContextRefusal(await admission.snapshot(), query, expectedSequences) ?? { schema_version: HOST_RELAY_INVOCATION_CONTEXT_RESULT_SCHEMA, status: "no_binding" };
   const currentPrompt = currentPrompts.take({ producer_id: request2.producer_id, producer_installation_ref: request2.producer_installation_ref, local_session_ref: request2.local_session_ref, local_turn_ref: request2.local_turn_ref, prompt_ref: binding.binding.prompt_ref });
   let result2;
   try {
@@ -3366,6 +3510,24 @@ async function resolveInvocationContext(request2, admission, bindings, currentPr
   }
   return { schema_version: HOST_RELAY_INVOCATION_CONTEXT_RESULT_SCHEMA, status: "ready", result: result2 };
 }
+function unboundInvocationContextRefusal(snapshot, query, expectedSequences) {
+  if (expectedSequences.length === 0) return null;
+  const refusal = snapshot.installations[`${query.producer_id}\0${query.producer_installation_ref}`]?.last_refusal;
+  if (refusal === void 0 || !expectedSequences.includes(refusal.sequence) || refusal.code !== "gateway_refused") return null;
+  return { schema_version: HOST_RELAY_INVOCATION_CONTEXT_RESULT_SCHEMA, status: "refused", reason: "gateway_refused" };
+}
+function pendingAdmissionSequences(snapshot, query) {
+  const sequences = [];
+  for (const entry2 of snapshot.entries) {
+    if (entry2.frame.frame_kind !== "user_input") continue;
+    const payload = entry2.frame.payload;
+    if (typeof payload.local_session_ref !== "string" || typeof payload.local_turn_ref !== "string") continue;
+    const aliases = Array.isArray(payload.local_turn_aliases) ? payload.local_turn_aliases.filter((value) => typeof value === "string") : [];
+    if (!relayRequestBindingMatchesQuery(query, { producer_id: entry2.frame.producer_id, producer_installation_ref: entry2.frame.producer_installation_ref, local_session_ref: payload.local_session_ref, local_turn_ref: payload.local_turn_ref, local_turn_aliases: aliases })) continue;
+    sequences.push(entry2.sequence);
+  }
+  return sequences;
+}
 async function waitForRequestBinding(query, admission, bindings, signal) {
   let binding = await bindings.query(query);
   if (binding.status === "ready") return binding;
@@ -3541,6 +3703,160 @@ async function closeServer(server, sockets, endpoint) {
   await new Promise((resolve) => server.close(() => resolve()));
   if (process.platform !== "win32") await unlink2(endpoint).catch(() => void 0);
 }
+var relayEndpointLocks = /* @__PURE__ */ new Map();
+function withRelayEndpointLock(endpoint, run) {
+  const prior = relayEndpointLocks.get(endpoint) ?? Promise.resolve();
+  let release;
+  const gate = new Promise((resolve) => {
+    release = resolve;
+  });
+  const tail = prior.then(() => gate);
+  relayEndpointLocks.set(endpoint, tail);
+  return prior.then(run).finally(() => {
+    release?.();
+    if (relayEndpointLocks.get(endpoint) === tail) relayEndpointLocks.delete(endpoint);
+  });
+}
+function currentUid(fallback) {
+  return typeof process.geteuid === "function" ? process.geteuid() : fallback;
+}
+async function assertTrustedEndpointParent(endpoint) {
+  const parent = dirname3(endpoint);
+  let stats;
+  try {
+    stats = await lstat3(parent);
+  } catch {
+    throw new HostRelayIpcError("relay_unavailable", "Host Relay IPC endpoint parent is unavailable; leaving it untouched.");
+  }
+  if (!stats.isDirectory() || stats.uid !== currentUid(stats.uid) || (stats.mode & 63) !== 0) throw new HostRelayIpcError("relay_unavailable", "Host Relay IPC endpoint parent is not an owner-private directory; leaving it untouched.");
+}
+var HOST_RELAY_ENDPOINT_PROBE_TIMEOUT_MS = 1e3;
+function probeRelayEndpoint(endpoint) {
+  return new Promise((resolve) => {
+    let settled = false;
+    const socket = createConnection(endpoint);
+    const finish = (outcome) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      socket.destroy();
+      resolve(outcome);
+    };
+    const timer = setTimeout(() => finish("ambiguous"), HOST_RELAY_ENDPOINT_PROBE_TIMEOUT_MS);
+    timer.unref?.();
+    socket.once("connect", () => finish("live"));
+    socket.once("error", (error) => {
+      const code = errorCode8(error);
+      if (code === "ECONNREFUSED") finish("stale");
+      else if (code === "ENOENT") finish("missing");
+      else finish("ambiguous");
+    });
+  });
+}
+async function removeStaleRelayEndpoint(endpoint, testHooks) {
+  const observed = await readEndpointStats(endpoint);
+  if (observed === null) return;
+  if (!observed.isSocket()) throw new HostRelayIpcError("relay_unavailable", "Host Relay IPC endpoint is already present and is not a socket; leaving it untouched.");
+  if (observed.uid !== currentUid(observed.uid)) throw new HostRelayIpcError("relay_unavailable", "Host Relay IPC endpoint is not owned by the current uid; leaving it untouched.");
+  const captured = { uid: observed.uid, dev: observed.dev, ino: observed.ino };
+  await requireStaleEndpoint(endpoint);
+  await testHooks?.beforeRemoveStaleEndpoint?.(endpoint);
+  const current = await readEndpointStats(endpoint);
+  if (current === null) return;
+  requireSameEndpointIdentity(current, captured, "Host Relay IPC endpoint changed before cleanup; leaving it untouched.");
+  await unlinkRelayEndpoint(endpoint);
+}
+async function requireStaleEndpoint(endpoint) {
+  switch (await probeRelayEndpoint(endpoint)) {
+    case "missing":
+    case "stale":
+      return;
+    case "live":
+      throw new HostRelayIpcError("relay_unavailable", "Host Relay IPC endpoint is already served by a live Relay; leaving it untouched.");
+    case "ambiguous":
+      throw new HostRelayIpcError("relay_unavailable", "Host Relay IPC endpoint liveness is ambiguous; leaving it untouched.");
+  }
+}
+async function readEndpointStats(endpoint) {
+  try {
+    return await lstat3(endpoint);
+  } catch (error) {
+    if (errorCode8(error) === "ENOENT") return null;
+    throw new HostRelayIpcError("relay_unavailable", "Host Relay IPC endpoint identity is ambiguous; leaving it untouched.");
+  }
+}
+function requireSameEndpointIdentity(current, owned, message) {
+  if (!current.isSocket() || current.uid !== owned.uid || current.dev !== owned.dev || current.ino !== owned.ino) throw new HostRelayIpcError("relay_unavailable", message);
+}
+async function unlinkRelayEndpoint(endpoint) {
+  try {
+    await unlink2(endpoint);
+  } catch (error) {
+    if (errorCode8(error) !== "ENOENT") throw error;
+  }
+}
+var relayStagingSequence = 0;
+function stagingRelayEndpoint(canonical) {
+  const parent = dirname3(canonical);
+  const pid = process.pid.toString(36);
+  const sequence = (relayStagingSequence++ % (36 * 36)).toString(36);
+  return join6(parent, `.r${pid}${sequence}`);
+}
+async function readStagingRelayEndpointIdentity(staging) {
+  let created;
+  try {
+    created = await lstat3(staging);
+  } catch {
+    throw new HostRelayIpcError("relay_unavailable", "Host Relay IPC endpoint is unavailable after listen; leaving it untouched.");
+  }
+  if (!created.isSocket()) throw new HostRelayIpcError("relay_unavailable", "Host Relay IPC endpoint was replaced before this server listened; leaving it untouched.");
+  if (created.uid !== currentUid(created.uid)) throw new HostRelayIpcError("relay_unavailable", "Host Relay IPC endpoint is not owned by the current uid after listen; leaving it untouched.");
+  return { uid: created.uid, dev: created.dev, ino: created.ino };
+}
+async function listenStagingRelayEndpoint(server, sockets, staging) {
+  try {
+    await listen(server, staging);
+  } catch (error) {
+    await abandonRelayServer(server, sockets);
+    throw error;
+  }
+}
+async function publishStagingRelayEndpoint(staging, owned, canonical) {
+  const incumbent = await readEndpointStats(canonical);
+  if (incumbent !== null) throw new HostRelayIpcError("relay_unavailable", "Host Relay IPC endpoint was replaced before this server listened; leaving it untouched.");
+  await rename2(staging, canonical);
+  const published = await readEndpointStats(canonical);
+  if (published === null) throw new HostRelayIpcError("relay_unavailable", "Host Relay IPC endpoint is unavailable after listen; leaving it untouched.");
+  requireSameEndpointIdentity(published, owned, "Host Relay IPC endpoint was replaced before this server listened; leaving it untouched.");
+  return { uid: published.uid, dev: published.dev, ino: published.ino };
+}
+async function releaseOwnedRelayEndpoint(server, sockets, endpoint, owned) {
+  await abandonRelayServer(server, sockets);
+  try {
+    const current = await readEndpointStats(endpoint);
+    if (current === null) return;
+    requireSameEndpointIdentity(current, owned, "Host Relay IPC endpoint changed while releasing a failed startup; leaving it untouched.");
+    await unlinkRelayEndpoint(endpoint);
+  } catch {
+  }
+}
+async function closeRelayServer(server, sockets, endpoint, owned, testHooks) {
+  await withRelayEndpointLock(endpoint, async () => {
+    for (const socket of sockets) socket.destroy();
+    await new Promise((resolve) => server.close(() => resolve()));
+    await testHooks?.beforeRemoveOwnedEndpoint?.(endpoint);
+    const current = await readEndpointStats(endpoint);
+    if (current === null) return;
+    requireSameEndpointIdentity(current, owned, "Host Relay IPC endpoint was replaced after this server listened; leaving it untouched.");
+    await unlinkRelayEndpoint(endpoint);
+  });
+}
+async function abandonRelayServer(server, sockets) {
+  for (const socket of sockets) socket.destroy();
+  await new Promise((resolve) => {
+    server.close(() => resolve());
+  });
+}
 function errorCode8(error) {
   return record4(error) && typeof error.code === "string" ? error.code : null;
 }
@@ -3562,7 +3878,7 @@ 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));
+    await assertOwnerPrivateDirectory2(dirname4(path));
     handle = await open5(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.");
@@ -3587,7 +3903,7 @@ async function readHostRelayConfig(path) {
 }
 function validateHostRelaySourcePaths(config) {
   try {
-    assertHostRelaySourcePaths(dirname3(config.registration_state_file), config);
+    assertHostRelaySourcePaths(dirname4(config.registration_state_file), config);
   } catch (error) {
     throw new HostRelayConfigError("invalid_config", error instanceof Error ? error.message : "Host Relay source tuple is invalid.");
   }
@@ -3617,10 +3933,10 @@ function validConfigRuntime(value) {
 var HOST_RELAY_INVOCATION_MINT_LOG_TAG = "[host-relay-invocation-mint]";
 var HOST_RELAY_INVOCATION_MINT_LINE = new RegExp(`^${HOST_RELAY_INVOCATION_MINT_LOG_TAG.replace(/[[\]]/gu, "\\$&")} outcome=([a-z_]+)(?: reason=([a-z][a-z0-9_]{0,63}))? elapsed_ms=[0-9]+$`, "u");
 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 admission = new RelayAdmissionStore(join7(config.state_root, "admission"));
+  const bindings = new RelayRequestBindingStore(join7(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) => {
+  const bridge = new RelayGatewayBridge({ state_root: join7(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;
@@ -3661,7 +3977,11 @@ function invocationMintRefusalReason(error, cancellation) {
   if (error.code === "gateway_unavailable") return "gateway_unavailable";
   if (error.code === "invalid_response") return "gateway_response_invalid";
   if (error.code !== "gateway_refused") return "mint_failed";
-  return (error.error_code === void 0 ? void 0 : GATEWAY_MINT_REFUSAL_REASONS.get(error.error_code)) ?? "gateway_refused";
+  return gatewayMintRefusalReason(error);
+}
+function gatewayMintRefusalReason(error) {
+  if (error.error_code === "request_context_refused" && isVocabularyWord(CEAL_HOST_MINT_REQUEST_CONTEXT_REFUSAL_REASONS, error.refusal_reason)) return error.refusal_reason;
+  return GATEWAY_MINT_REFUSAL_REASONS.get(error.error_code ?? "") ?? "gateway_refused";
 }
 var GATEWAY_MINT_REFUSAL_REASONS = /* @__PURE__ */ new Map([
   ["request_context_refused", "context_stale"],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@corca-org/ceal-host-linux-arm64",
-  "version": "1.0.17",
+  "version": "1.0.18",
   "license": "MIT",
   "repository": {
     "type": "git",