@forgeax/engine-tool-runtime 0.1.29 → 0.1.30

package/dist/index.mjs

@@ -233,494 +233,186 @@ function validateArtifactRefs(value) {
   );
 }
 
-// src/capability.ts
-var capabilityIdPattern = /^[a-z][a-z0-9]*(?:[._-][a-z0-9]+)*$/;
-function defineToolCapability(id) {
-  if (!capabilityIdPattern.test(id)) {
-    throw new TypeError(`Tool capability id must use a stable lower-case path: ${id}`);
-  }
-  return Object.freeze({ id });
-}
-function createCapabilityResolver(resolve) {
-  return (capability) => {
-    const value = resolve(capability);
-    return value === void 0 ? void 0 : { ok: true, value };
+// src/lease.ts
+function createLexicalLease(runId) {
+  const cleanups = [];
+  let state = "active";
+  let terminalId;
+  let termination;
+  const terminate = (reason) => {
+    if (termination !== void 0) return termination;
+    terminalId = `${runId}:terminal:${crypto.randomUUID()}`;
+    state = "terminating";
+    termination = (async () => {
+      const failures = [];
+      for (let index = cleanups.length - 1; index >= 0; index -= 1) {
+        const entry = cleanups[index];
+        if (entry === void 0) continue;
+        try {
+          await entry.cleanup();
+        } catch (cause) {
+          failures.push({
+            owner: entry.owner,
+            message: cause instanceof Error ? cause.message : String(cause)
+          });
+        }
+      }
+      state = "terminated";
+      return { terminalId, reason, failures };
+    })();
+    return termination;
   };
-}
-function admissionFailure(admission, expected) {
-  if (admission === void 0) return "no workload-scoped admission report was supplied";
-  if (admission.schema !== "forgeax.tool-service-admission-ref.v1" || !/^sha256:[0-9a-f]{64}$/.test(admission.reportDigest)) {
-    return "admission report identity is invalid";
-  }
-  for (const key of [
-    "toolId",
-    "descriptorDigest",
-    "recipeDigest",
-    "workloadClass",
-    "codeDigest",
-    "browserVersion",
-    "backend"
-  ]) {
-    if (admission[key] !== expected[key]) return `admission ${key} does not match this run`;
-  }
-  if (admission.frameCount < 300) return "admission workload ran fewer than 300 frames";
-  if (Object.values(admission.samples).some((count) => count < 30)) {
-    return "admission sample set is incomplete";
-  }
-  if (!admission.correctness.terminalEquivalent || !admission.correctness.artifactIntegrity || !admission.correctness.freshReplay || !admission.correctness.hiddenParity || admission.correctness.drawCalls <= 0 || admission.correctness.nonBlackPixels <= 0) {
-    return "admission correctness gate failed";
-  }
-  const performance2 = admission.performance;
-  if (Object.values(performance2).some((value) => !Number.isFinite(value) || value <= 0) || performance2.serviceMedianMs > performance2.privateMedianMs * 0.8 || performance2.serviceP95Ms > performance2.privateP95Ms * 0.9 || performance2.serviceMaxMs > performance2.privateMaxMs * 1.1 || performance2.serviceRssBytes > performance2.privateRssBytes * 1.25) {
-    return "admission performance threshold failed";
-  }
-  if (!admission.cleanupPassed) return "admission cleanup gate failed";
-  if (!admission.evictionPassed) return "admission eviction gate failed";
-  return void 0;
-}
-function createServiceCapability(admission, expected) {
-  const reason = admissionFailure(admission, expected);
-  if (reason === void 0 && admission !== void 0) {
-    return { available: true, reportDigest: admission.reportDigest };
-  }
   return {
-    available: false,
-    code: "tool-service-capability-absent",
-    expected: "an admitted acceleration service",
-    hint: "Use the private executor and rerun benchmark admission before enabling service.",
-    detail: { reason: reason ?? "benchmark admission did not pass" }
+    get state() {
+      return state;
+    },
+    register(owner, cleanup) {
+      if (state !== "active") return false;
+      cleanups.push({ owner, cleanup });
+      return true;
+    },
+    terminate
   };
 }
-function createRealmCapabilityMatrix(input) {
-  const realms = ["build", "host", "engine"].reduce(
-    (result, realm) => {
-      const supported = input.supported[realm];
-      result[realm] = supported ? { realm, supported: true } : { realm, supported: false, reason: "realm-capability-unavailable" };
-      return result;
-    },
-    {}
+
+// src/timing.ts
+var PHASES = [
+  "lookup",
+  "lease",
+  "transport",
+  "execute",
+  "capture",
+  "finalize",
+  "analyze"
+];
+function createExclusiveTiming(now = () => performance.now()) {
+  const phases = Object.fromEntries(
+    PHASES.map((phase) => [phase, { status: "not-applicable" }])
   );
-  return { catalogDigest: input.catalogDigest, realms };
-}
-function bootstrapNotCloneSafeError(detail) {
+  const closed = /* @__PURE__ */ new Set();
+  let active;
+  let startedAtMs;
+  let endedAtMs;
   return {
-    code: "tool-bootstrap-not-clone-safe",
-    expected: "bootstrap input to contain structured-clone-safe data",
-    hint: "Remove live handles, functions, ports, and realm-owned objects from bootstrap input.",
-    detail
+    begin(phase) {
+      if (active !== void 0) throw new TypeError(`phase '${active.phase}' is still open`);
+      if (closed.has(phase)) throw new TypeError(`phase '${phase}' was already closed`);
+      const at = now();
+      startedAtMs ??= at;
+      active = { phase, startedAtMs: at };
+    },
+    end(phase) {
+      if (active?.phase !== phase) throw new TypeError(`phase '${phase}' is not the active phase`);
+      const at = now();
+      phases[phase] = { status: "observed", durationMs: Math.max(0, at - active.startedAtMs) };
+      closed.add(phase);
+      active = void 0;
+      endedAtMs = at;
+    },
+    record(phase, durationMs) {
+      if (!Number.isFinite(durationMs) || durationMs < 0)
+        throw new TypeError("phase duration must be finite and non-negative");
+      if (closed.has(phase)) throw new TypeError(`phase '${phase}' was already closed`);
+      const at = now();
+      startedAtMs ??= at - durationMs;
+      phases[phase] = { status: "observed", durationMs };
+      closed.add(phase);
+      endedAtMs = at;
+    },
+    finish() {
+      if (active !== void 0) throw new TypeError(`phase '${active.phase}' is still open`);
+      const start = startedAtMs ?? now();
+      const end = endedAtMs ?? start;
+      return {
+        startedAtMs: start,
+        endedAtMs: end,
+        totalMs: Math.max(0, end - start),
+        phases: { ...phases }
+      };
+    }
   };
 }
-function validateRealmBootstrapPayload(value) {
-  try {
-    structuredClone(value);
-    return { ok: true };
-  } catch (cause) {
-    return {
-      ok: false,
-      error: bootstrapNotCloneSafeError({
-        message: cause instanceof Error ? cause.message : String(cause)
-      })
-    };
-  }
-}
-
-// src/carrier.ts
-function token() {
-  return crypto.randomUUID().replaceAll("-", "");
-}
-function carrierError(code, expected, hint, detail) {
-  return { code, expected, hint, detail };
+function startToolTiming() {
+  return performance.now();
 }
-function containsLiveKey(value, seen = /* @__PURE__ */ new Set()) {
-  if (typeof value !== "object" || value === null) return false;
-  if (seen.has(value)) return false;
-  seen.add(value);
-  if (Array.isArray(value)) return value.some((entry) => containsLiveKey(entry, seen));
-  return Object.entries(value).some(([key, nested]) => {
-    if (["world", "renderer", "canvas", "ui", "profile", "liveHandle", "context", "fiber"].includes(
-      key
-    ))
-      return true;
-    return containsLiveKey(nested, seen);
-  });
+function finishToolTiming(startedAtMs, operationTiming) {
+  const endedAtMs = performance.now();
+  const result = operationTiming?.finish();
+  const durationMs = Math.max(0, endedAtMs - startedAtMs);
+  const attributedMs = result === void 0 ? 0 : Object.values(result.phases).reduce(
+    (sum, observation) => observation.status === "observed" ? sum + observation.durationMs : sum,
+    0
+  );
+  return {
+    startedAtMs,
+    endedAtMs,
+    durationMs,
+    ...result === void 0 ? {} : { phases: result.phases, unattributedMs: Math.max(0, durationMs - attributedMs) }
+  };
 }
-function validateOptions(options) {
-  if (options.projectId.length === 0 || options.consumerId.length === 0) {
-    throw new TypeError("carrier projectId and consumerId must not be empty");
+
+// src/runtime.ts
+function defineTool(descriptor, execute) {
+  if (!/^[a-z][a-z0-9]*(?:[._-][a-z0-9]+)*$/.test(descriptor.id)) {
+    throw new TypeError(`Tool id must use a stable lower-case path: ${descriptor.id}`);
   }
-  const endpoint = new URL(options.endpoint);
-  if (endpoint.protocol !== "http:" || !["127.0.0.1", "localhost"].includes(endpoint.hostname)) {
-    throw new TypeError("carrier endpoint must be loopback HTTP");
+  if (descriptor.title.trim().length === 0 || descriptor.summary.trim().length === 0) {
+    throw new TypeError("Tool title and summary must not be empty");
   }
-  if (!Number.isFinite(options.now) || !Number.isFinite(options.ttlMs) || options.ttlMs <= 0) {
-    throw new TypeError("carrier clock and ttl must be finite and positive");
+  if (!Array.isArray(descriptor.evidence)) throw new TypeError("Tool evidence must be an array");
+  if (descriptor.preview !== void 0 && descriptor.preview.realm !== descriptor.realm) {
+    throw new TypeError(
+      `Tool ${descriptor.id} preview contract declares ${descriptor.preview.realm} but descriptor declares ${descriptor.realm}`
+    );
   }
-  if (containsLiveKey(options.payload)) throw new TypeError("carrier-payload-live-state");
-}
-function createCarrierStateMachine(options) {
-  validateOptions(options);
-  const offer = {
-    schemaVersion: "1.0.0",
-    projectId: options.projectId,
-    consumerId: options.consumerId,
-    offerId: `offer:${token()}`,
-    endpoint: options.endpoint,
-    bearerToken: token(),
-    livenessToken: token(),
-    expiresAt: options.now + options.ttlMs,
-    ...options.descriptorDigest === void 0 ? {} : { descriptorDigest: options.descriptorDigest },
-    ...options.recipeDigest === void 0 ? {} : { recipeDigest: options.recipeDigest },
-    state: "offered"
+  const argsSchema = descriptor.argsSchema;
+  const resultSchema = descriptor.resultSchema;
+  return {
+    descriptor: { ...descriptor, argsSchema, resultSchema, evidence: [...descriptor.evidence] },
+    execute
   };
-  let state = { state: "offered" };
-  let lease;
-  const leaseOffer = (requestOrId, maybeRequest) => {
-    const request = typeof requestOrId === "string" ? maybeRequest : requestOrId;
-    const requestedLeaseId = typeof requestOrId === "string" ? requestOrId : void 0;
-    if (request === void 0) {
-      return {
-        ok: false,
-        error: carrierError(
-          "carrier-token-invalid",
-          "a complete lease request",
-          "Provide consumer identity, bearer token, and current time.",
-          {}
-        )
-      };
-    }
-    if (state.state === "started") {
-      return {
-        ok: false,
-        error: carrierError(
-          "carrier-started",
-          "a started carrier not to be retried",
-          "Report one terminal failure and clean up the existing started lease.",
-          {}
-        )
-      };
-    }
-    if (state.state === "exited") {
-      return {
-        ok: false,
-        error: carrierError(
-          "carrier-exited",
-          "an exited carrier not to be retried",
-          "Re-run the operation from a serialized snapshot instead of migrating live state.",
-          {}
-        )
-      };
-    }
-    if (request.consumerId !== offer.consumerId) {
-      return {
-        ok: false,
-        error: carrierError(
-          "carrier-consumer-mismatch",
-          "the offer consumer identity to match",
-          "Use the consumer identity that was authenticated for this project offer.",
-          { expected: offer.consumerId, actual: request.consumerId }
-        )
-      };
-    }
-    if (request.bearerToken !== offer.bearerToken) {
-      return {
-        ok: false,
-        error: carrierError(
-          "carrier-token-invalid",
-          "the bearer token to match the ephemeral offer",
-          "Request a fresh visible offer; never persist or guess bearer tokens.",
-          {}
-        )
-      };
-    }
-    if (offer.descriptorDigest !== void 0 && request.descriptorDigest !== offer.descriptorDigest) {
-      return {
-        ok: false,
-        error: carrierError(
-          "carrier-descriptor-mismatch",
-          "the descriptor digest to match the authenticated offer",
-          "Refresh the descriptor and request a new visible offer before retrying.",
-          { expected: offer.descriptorDigest, actual: request.descriptorDigest }
-        )
-      };
-    }
-    if (offer.recipeDigest !== void 0 && request.recipeDigest !== offer.recipeDigest) {
-      return {
-        ok: false,
-        error: carrierError(
-          "carrier-recipe-mismatch",
-          "the recipe digest to match the authenticated offer",
-          "Serialize the current snapshot and request a fresh visible offer before retrying.",
-          { expected: offer.recipeDigest, actual: request.recipeDigest }
-        )
-      };
-    }
-    if (request.now >= offer.expiresAt) {
-      state = { state: "expired" };
-      return {
-        ok: false,
-        error: carrierError(
-          "carrier-offer-expired",
-          "the offer to be within its expiry window",
-          "Fall back to the ordinary visible carrier before retrying.",
-          { expiresAt: offer.expiresAt, now: request.now }
-        )
-      };
-    }
-    if (requestedLeaseId !== void 0 && requestedLeaseId !== lease?.leaseId) {
-      return {
-        ok: false,
-        error: carrierError(
-          "carrier-token-invalid",
-          "the lease id to match the authenticated offer",
-          "Use the lease id returned by the first successful lease.",
-          {}
-        )
-      };
-    }
-    lease = {
-      leaseId: `lease:${token()}`,
-      offerId: offer.offerId,
-      consumerId: request.consumerId,
-      state: "leased"
-    };
-    state = { state: "leased", leaseId: lease.leaseId };
-    return { ok: true, value: lease, state: "leased" };
-  };
-  const started = (leaseId) => {
-    if (lease?.leaseId !== leaseId) {
-      return {
-        ok: false,
-        error: carrierError(
-          "carrier-lease-required",
-          "a valid lease before started",
-          "Lease the authenticated offer before reporting provider started.",
-          {}
-        )
-      };
-    }
-    state = { state: "started", leaseId };
-    return { ok: true, value: state, state: "started" };
+}
+function eventChannel() {
+  const queue = [];
+  const waiters = [];
+  let closed = false;
+  const emit = (event) => {
+    const waiter = waiters.shift();
+    if (waiter !== void 0) waiter({ done: false, value: event });
+    else queue.push(event);
   };
-  const exit = (leaseId) => {
-    if (lease?.leaseId !== leaseId || state.state !== "started") {
-      return {
-        ok: false,
-        error: carrierError(
-          "carrier-lease-required",
-          "a started lease before provider exit",
-          "Provider exit is terminal only after started has been acknowledged.",
-          {}
-        )
-      };
-    }
-    state = { state: "exited", leaseId };
-    return { ok: true, value: state, state: "exited" };
+  const close = () => {
+    closed = true;
+    while (waiters.length > 0) waiters.shift()?.({ done: true, value: void 0 });
   };
-  const fallback = () => {
-    if (state.state === "started" || state.state === "exited") {
+  const events = {
+    [Symbol.asyncIterator]() {
       return {
-        ok: false,
-        error: carrierError(
-          "carrier-started",
-          "fallback to happen before provider started",
-          "Do not retry or migrate a carrier after started; return its terminal failure.",
-          { state: state.state }
-        )
+        next: async () => {
+          const event = queue.shift();
+          if (event !== void 0) return { done: false, value: event };
+          if (closed) return { done: true, value: void 0 };
+          return new Promise((resolve) => waiters.push(resolve));
+        }
       };
     }
-    state = { state: "fallback" };
-    return { ok: true, value: state, state: "fallback" };
-  };
-  return {
-    offer,
-    lease: leaseOffer,
-    started,
-    exit,
-    fallback,
-    snapshot: () => state
   };
+  return { emit, close, events };
 }
-
-// src/lease.ts
-function createLexicalLease(runId) {
-  const cleanups = [];
-  let state = "active";
-  let terminalId;
-  let termination;
-  const terminate = (reason) => {
-    if (termination !== void 0) return termination;
-    terminalId = `${runId}:terminal:${crypto.randomUUID()}`;
-    state = "terminating";
-    termination = (async () => {
-      const failures = [];
-      for (let index = cleanups.length - 1; index >= 0; index -= 1) {
-        const entry = cleanups[index];
-        if (entry === void 0) continue;
-        try {
-          await entry.cleanup();
-        } catch (cause) {
-          failures.push({
-            owner: entry.owner,
-            message: cause instanceof Error ? cause.message : String(cause)
-          });
-        }
-      }
-      state = "terminated";
-      return { terminalId, reason, failures };
-    })();
-    return termination;
-  };
-  return {
-    get state() {
-      return state;
-    },
-    register(owner, cleanup) {
-      if (state !== "active") return false;
-      cleanups.push({ owner, cleanup });
-      return true;
-    },
-    terminate
-  };
+function isTerminal(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const outcome = Reflect.get(value, "outcome");
+  return outcome === "succeeded" || outcome === "failed";
 }
-
-// src/timing.ts
-var PHASES = [
-  "lookup",
-  "lease",
-  "transport",
-  "execute",
-  "capture",
-  "finalize",
-  "analyze"
-];
-function createExclusiveTiming(now = () => performance.now()) {
-  const phases = Object.fromEntries(
-    PHASES.map((phase) => [phase, { status: "not-applicable" }])
-  );
-  const closed = /* @__PURE__ */ new Set();
-  let active;
-  let startedAtMs;
-  let endedAtMs;
-  return {
-    begin(phase) {
-      if (active !== void 0) throw new TypeError(`phase '${active.phase}' is still open`);
-      if (closed.has(phase)) throw new TypeError(`phase '${phase}' was already closed`);
-      const at = now();
-      startedAtMs ??= at;
-      active = { phase, startedAtMs: at };
-    },
-    end(phase) {
-      if (active?.phase !== phase) throw new TypeError(`phase '${phase}' is not the active phase`);
-      const at = now();
-      phases[phase] = { status: "observed", durationMs: Math.max(0, at - active.startedAtMs) };
-      closed.add(phase);
-      active = void 0;
-      endedAtMs = at;
-    },
-    record(phase, durationMs) {
-      if (!Number.isFinite(durationMs) || durationMs < 0)
-        throw new TypeError("phase duration must be finite and non-negative");
-      if (closed.has(phase)) throw new TypeError(`phase '${phase}' was already closed`);
-      const at = now();
-      startedAtMs ??= at - durationMs;
-      phases[phase] = { status: "observed", durationMs };
-      closed.add(phase);
-      endedAtMs = at;
-    },
-    finish() {
-      if (active !== void 0) throw new TypeError(`phase '${active.phase}' is still open`);
-      const start = startedAtMs ?? now();
-      const end = endedAtMs ?? start;
-      return {
-        startedAtMs: start,
-        endedAtMs: end,
-        totalMs: Math.max(0, end - start),
-        phases: { ...phases }
-      };
-    }
-  };
-}
-function startToolTiming() {
-  return performance.now();
-}
-function finishToolTiming(startedAtMs, operationTiming) {
-  const endedAtMs = performance.now();
-  const result = operationTiming?.finish();
-  const durationMs = Math.max(0, endedAtMs - startedAtMs);
-  const attributedMs = result === void 0 ? 0 : Object.values(result.phases).reduce(
-    (sum, observation) => observation.status === "observed" ? sum + observation.durationMs : sum,
-    0
-  );
-  return {
-    startedAtMs,
-    endedAtMs,
-    durationMs,
-    ...result === void 0 ? {} : { phases: result.phases, unattributedMs: Math.max(0, durationMs - attributedMs) }
-  };
-}
-
-// src/runtime.ts
-function defineTool(descriptor, execute) {
-  if (!/^[a-z][a-z0-9]*(?:[._-][a-z0-9]+)*$/.test(descriptor.id)) {
-    throw new TypeError(`Tool id must use a stable lower-case path: ${descriptor.id}`);
-  }
-  if (descriptor.title.trim().length === 0 || descriptor.summary.trim().length === 0) {
-    throw new TypeError("Tool title and summary must not be empty");
-  }
-  if (!Array.isArray(descriptor.evidence)) throw new TypeError("Tool evidence must be an array");
-  if (descriptor.preview !== void 0 && descriptor.preview.realm !== descriptor.realm) {
-    throw new TypeError(
-      `Tool ${descriptor.id} preview contract declares ${descriptor.preview.realm} but descriptor declares ${descriptor.realm}`
-    );
-  }
-  const argsSchema = descriptor.argsSchema;
-  const resultSchema = descriptor.resultSchema;
-  return {
-    descriptor: { ...descriptor, argsSchema, resultSchema, evidence: [...descriptor.evidence] },
-    execute
-  };
-}
-function eventChannel() {
-  const queue = [];
-  const waiters = [];
-  let closed = false;
-  const emit = (event) => {
-    const waiter = waiters.shift();
-    if (waiter !== void 0) waiter({ done: false, value: event });
-    else queue.push(event);
-  };
-  const close = () => {
-    closed = true;
-    while (waiters.length > 0) waiters.shift()?.({ done: true, value: void 0 });
-  };
-  const events = {
-    [Symbol.asyncIterator]() {
-      return {
-        next: async () => {
-          const event = queue.shift();
-          if (event !== void 0) return { done: false, value: event };
-          if (closed) return { done: true, value: void 0 };
-          return new Promise((resolve) => waiters.push(resolve));
-        }
-      };
-    }
-  };
-  return { emit, close, events };
-}
-function isTerminal(value) {
-  if (typeof value !== "object" || value === null) return false;
-  const outcome = Reflect.get(value, "outcome");
-  return outcome === "succeeded" || outcome === "failed";
-}
-function serializablePreview(value) {
-  return isSerializableValue(value) ? value : null;
-}
-function domainError(error) {
-  return domainFailureError(
-    error.code,
-    error.expected ?? "the producer operation to succeed",
-    error.hint ?? "Inspect detail and repair the owning producer before retrying.",
-    error.detail
+function serializablePreview(value) {
+  return isSerializableValue(value) ? value : null;
+}
+function domainError(error) {
+  return domainFailureError(
+    error.code,
+    error.expected ?? "the producer operation to succeed",
+    error.hint ?? "Inspect detail and repair the owning producer before retrying.",
+    error.detail
   );
 }
 function hasOkField(value) {
@@ -765,6 +457,10 @@ function createToolRuntime(contributions) {
     const terminal = new Promise((resolve) => {
       resolveTerminal = resolve;
     });
+    let resolveExecutorExited;
+    const executorExited = new Promise((resolve) => {
+      resolveExecutorExited = resolve;
+    });
     const settle = async (candidate, reason = "terminal") => {
       if (terminalStarted) return;
       terminalStarted = true;
@@ -802,6 +498,8 @@ function createToolRuntime(contributions) {
     const context = {
       runId,
       signal: controller.signal,
+      ...options.owner === void 0 ? {} : { owner: options.owner },
+      ...options.caller === void 0 ? {} : { caller: options.caller },
       ...options.snapshot === void 0 ? {} : { snapshot: options.snapshot },
       emit: (event) => {
         if (!terminalStarted) channel.emit({ ...event, runId });
@@ -896,12 +594,25 @@ function createToolRuntime(contributions) {
     );
     channel.emit({ kind: "started", runId, atMs: performance.now() });
     void (async () => {
-      const parsedArgs = contribution.descriptor.argsSchema.parse(args);
-      if (!parsedArgs.ok) {
-        fail(invalidArgsError(parsedArgs.error, serializablePreview(args)));
-        return;
-      }
       try {
+        let parsedArgs;
+        try {
+          parsedArgs = contribution.descriptor.argsSchema.parse(args);
+        } catch (cause) {
+          await settle({
+            outcome: "failed",
+            failure: invalidArgsError(
+              cause instanceof Error ? cause.message : String(cause),
+              serializablePreview(args)
+            ),
+            artifacts: []
+          });
+          return;
+        }
+        if (!parsedArgs.ok) {
+          fail(invalidArgsError(parsedArgs.error, serializablePreview(args)));
+          return;
+        }
         if (options.signal?.aborted) {
           cancelReason = "aborted by caller";
           fail(cancellationError(cancelReason));
@@ -1021,12 +732,14 @@ function createToolRuntime(contributions) {
         });
       } finally {
         if (timeout !== void 0) clearTimeout(timeout);
+        resolveExecutorExited();
       }
     })();
     const runtimeRun = {
       id: runId,
       events: channel.events,
       terminal,
+      executorExited,
       cancel,
       disconnect,
       providerExit
@@ -1042,6 +755,670 @@ function createToolRuntime(contributions) {
   return runtime;
 }
 
+// src/api.ts
+function assertName(value, label) {
+  if (typeof value !== "string" || !/^[a-zA-Z0-9][a-zA-Z0-9._:/-]*$/.test(value)) {
+    throw new TypeError(`${label} must be a stable non-empty identity`);
+  }
+}
+function operationPath(descriptor) {
+  return (descriptor.path ?? descriptor.id.split(".")).join(" ");
+}
+function providerKey(sourceId, providerId) {
+  return `${sourceId}\0${providerId}`;
+}
+function apiFailure(code, expected, hint, detail) {
+  return domainFailureError(code, expected, hint, detail);
+}
+function failedRun(failure) {
+  const id = `api:${crypto.randomUUID()}`;
+  const terminal = Promise.resolve({
+    outcome: "failed",
+    failure,
+    artifacts: []
+  });
+  const events = {
+    async *[Symbol.asyncIterator]() {
+      yield { kind: "started", runId: id, atMs: performance.now() };
+      yield { kind: "terminal", runId: id, outcome: "failed", atMs: performance.now() };
+    }
+  };
+  return {
+    id,
+    events,
+    terminal,
+    executorExited: Promise.resolve(),
+    cancel() {
+    },
+    disconnect() {
+    },
+    providerExit() {
+    }
+  };
+}
+function validateProvider(input) {
+  assertName(input.providerId, "providerId");
+  assertName(input.sourceId, "sourceId");
+  if (!["build", "host", "engine"].includes(input.realm))
+    throw new TypeError(`unsupported Tool API realm ${String(input.realm)}`);
+  if (!Array.isArray(input.tools) || input.tools.length === 0)
+    throw new TypeError("Tool API providers must publish at least one contribution");
+  const ids = /* @__PURE__ */ new Set();
+  const paths = /* @__PURE__ */ new Set();
+  if (input.initialState !== void 0 && input.initialState !== "pending" && input.initialState !== "active")
+    throw new TypeError("Tool API provider initialState must be pending or active");
+  for (const contribution of input.tools) {
+    if (contribution === null || typeof contribution !== "object")
+      throw new TypeError("Tool API contributions must be objects");
+    if (typeof contribution.execute !== "function")
+      throw new TypeError(
+        `Tool API contribution ${String(contribution.descriptor?.id)} needs an executor`
+      );
+    const descriptor = contribution.descriptor;
+    if (descriptor.realm !== input.realm)
+      throw new TypeError(
+        `Tool API ${descriptor.id} declares ${descriptor.realm} but provider is ${input.realm}`
+      );
+    if (ids.has(descriptor.id))
+      throw new TypeError(`duplicate Tool API operation id ${descriptor.id}`);
+    ids.add(descriptor.id);
+    const path = operationPath(descriptor);
+    if (paths.has(path)) throw new TypeError(`duplicate Tool API command path ${path}`);
+    paths.add(path);
+  }
+}
+function createToolApi() {
+  const providers = /* @__PURE__ */ new Map();
+  const listeners = /* @__PURE__ */ new Set();
+  let providerGeneration = 0;
+  let disposed = false;
+  const notify = () => {
+    const value = api.snapshot();
+    for (const listener of listeners) {
+      try {
+        listener(value);
+      } catch {
+      }
+    }
+  };
+  const snapshot = () => {
+    const providerSnapshots = [];
+    const operations = [];
+    for (const record of providers.values()) {
+      providerSnapshots.push({
+        owner: record.owner,
+        state: record.state,
+        ...record.fiberState === void 0 ? {} : { fiberState: record.fiberState },
+        callable: record.state === "active",
+        operationIds: record.input.tools.map(({ descriptor }) => descriptor.id)
+      });
+      for (const contribution of record.input.tools) {
+        operations.push({
+          descriptor: contribution.descriptor,
+          owner: record.owner,
+          providerState: record.state,
+          declared: true,
+          callable: record.state === "active",
+          ...record.fiberState === void 0 ? {} : { fiberState: record.fiberState }
+        });
+      }
+    }
+    providerSnapshots.sort(
+      (left, right) => providerKey(left.owner.sourceId, left.owner.providerId).localeCompare(
+        providerKey(right.owner.sourceId, right.owner.providerId)
+      )
+    );
+    operations.sort((left, right) => {
+      const source = left.owner.sourceId.localeCompare(right.owner.sourceId);
+      return source !== 0 ? source : left.descriptor.id.localeCompare(right.descriptor.id);
+    });
+    return { providers: providerSnapshots, operations };
+  };
+  const registerProvider = (input) => {
+    if (disposed) throw new Error("Tool API is disposed");
+    validateProvider(input);
+    const key = providerKey(input.sourceId, input.providerId);
+    if (providers.get(key)?.state === "active" || providers.get(key)?.state === "revoking") {
+      throw new TypeError(
+        `Tool API provider ${input.sourceId}/${input.providerId} is already registered`
+      );
+    }
+    const operationKeys = /* @__PURE__ */ new Set();
+    for (const contribution of input.tools) {
+      const operationKey = `${input.sourceId}\0${contribution.descriptor.id}`;
+      const pathKey2 = `${input.sourceId}\0${operationPath(contribution.descriptor)}`;
+      if (operationKeys.has(operationKey) || operationKeys.has(pathKey2))
+        throw new TypeError(`Tool API contribution conflict for ${contribution.descriptor.id}`);
+      operationKeys.add(operationKey);
+      operationKeys.add(pathKey2);
+      for (const record2 of providers.values()) {
+        if (!["pending", "active", "revoking"].includes(record2.state) || record2.owner.sourceId !== input.sourceId)
+          continue;
+        if (record2.input.tools.some(({ descriptor }) => descriptor.id === contribution.descriptor.id)) {
+          throw new TypeError(
+            `Tool API operation ${contribution.descriptor.id} already exists for source ${input.sourceId}`
+          );
+        }
+        if (record2.input.tools.some(
+          ({ descriptor }) => operationPath(descriptor) === operationPath(contribution.descriptor)
+        )) {
+          throw new TypeError(
+            `Tool API command path ${operationPath(contribution.descriptor)} already exists for source ${input.sourceId}`
+          );
+        }
+      }
+    }
+    const generation = input.generation ?? ++providerGeneration;
+    if (!Number.isSafeInteger(generation) || generation <= 0)
+      throw new TypeError("Tool API provider generation must be a positive integer");
+    providerGeneration = Math.max(providerGeneration, generation);
+    const owner = {
+      providerId: input.providerId,
+      sourceId: input.sourceId,
+      generation,
+      realm: input.realm,
+      ...input.fiberId === void 0 ? {} : { fiberId: input.fiberId },
+      ...input.module === void 0 ? {} : { module: input.module }
+    };
+    const runtime = createToolRuntime(input.tools);
+    const record = {
+      input: { ...input, tools: [...input.tools] },
+      owner,
+      runtime,
+      runs: /* @__PURE__ */ new Set(),
+      state: input.initialState ?? "active",
+      ...input.fiberState === void 0 ? {} : { fiberState: input.fiberState }
+    };
+    providers.set(key, record);
+    notify();
+    const activate = (fiberState = "active") => {
+      if (record.state !== "pending") return;
+      record.state = "active";
+      record.fiberState = fiberState;
+      notify();
+    };
+    const fail = (reason = "provider failed", fiberState = "failed") => {
+      if (record.state !== "pending" && record.state !== "active") return;
+      record.state = "failed";
+      record.reason = reason;
+      record.fiberState = fiberState;
+      for (const run2 of record.runs) run2.cancel(reason);
+      notify();
+    };
+    const revoke = async (reason = "provider revoked") => {
+      if (record.state === "revoked") return;
+      if (record.state === "active" || record.state === "pending") {
+        record.state = "revoking";
+        record.reason = reason;
+        record.fiberState = "unloading";
+        notify();
+        for (const run2 of record.runs) run2.cancel(reason);
+      }
+      await Promise.all([...record.runs].map((run2) => run2.executorExited));
+      if (record.state !== "failed") {
+        record.state = "revoked";
+        record.fiberState = "disposed";
+      }
+      notify();
+    };
+    return Object.freeze({
+      owner,
+      activate,
+      fail,
+      snapshot: () => ({
+        owner,
+        state: record.state,
+        ...record.fiberState === void 0 ? {} : { fiberState: record.fiberState },
+        callable: record.state === "active",
+        operationIds: record.input.tools.map(({ descriptor }) => descriptor.id)
+      }),
+      revoke
+    });
+  };
+  const findRecords = (id, sourceId) => [...providers.values()].filter(
+    (record) => (sourceId === void 0 || record.owner.sourceId === sourceId) && record.input.tools.some(({ descriptor }) => descriptor.id === id)
+  );
+  const run = (id, args, options = {}) => {
+    if (disposed) {
+      return failedRun(
+        apiFailure(
+          "api-disposed",
+          "the Tool API owner to remain available",
+          "Create a fresh owner and retry the operation.",
+          { operation: id }
+        )
+      );
+    }
+    if (options.providerId !== void 0 && options.sourceId === void 0) {
+      return failedRun(
+        apiFailure(
+          "api-source-required",
+          `operation ${id} to include its explicit sourceId with providerId`,
+          "Refresh Tool API sources and pass both sourceId and providerId from one snapshot.",
+          { operation: id, providerId: options.providerId }
+        )
+      );
+    }
+    const matches = findRecords(id, options.sourceId);
+    const active = matches.filter((record) => record.state === "active");
+    const selected = options.providerId === void 0 ? active.length === 1 ? active[0] : void 0 : active.find((record) => record.owner.providerId === options.providerId);
+    if (selected === void 0) {
+      const code = matches.length === 0 || active.length === 0 ? "api-operation-unavailable" : "api-provider-route-required";
+      return failedRun(
+        apiFailure(
+          code,
+          `operation ${id} to have one active, explicitly routable provider`,
+          "Refresh Tool API sources and select the providerId/sourceId returned by discovery.",
+          {
+            operation: id,
+            ...options.providerId === void 0 ? {} : { providerId: options.providerId },
+            providers: matches.map((record) => record.owner.providerId)
+          }
+        )
+      );
+    }
+    if (options.generation !== void 0 && options.generation !== selected.owner.generation) {
+      return failedRun(
+        apiFailure(
+          "api-stale-generation",
+          `provider ${selected.owner.providerId} generation ${options.generation} to match ${selected.owner.generation}`,
+          "Refresh the source snapshot before retrying the operation.",
+          {
+            operation: id,
+            providerId: selected.owner.providerId,
+            expectedGeneration: selected.owner.generation,
+            actualGeneration: options.generation
+          }
+        )
+      );
+    }
+    const contribution = selected.input.tools.find(({ descriptor }) => descriptor.id === id);
+    if (contribution === void 0) {
+      return failedRun(
+        apiFailure(
+          "api-operation-unavailable",
+          `operation ${id} to remain published by its provider`,
+          "Refresh Tool API sources before retrying.",
+          { operation: id }
+        )
+      );
+    }
+    if (selected.input.authorize?.(options.caller, contribution.descriptor) === false) {
+      return failedRun(
+        apiFailure(
+          "api-unauthorized",
+          `caller to be authorized for operation ${id}`,
+          "Use the authenticated Host connection and the capability it was granted.",
+          { operation: id, providerId: selected.owner.providerId }
+        )
+      );
+    }
+    const runOptions = {
+      ...options,
+      owner: selected.owner,
+      ...options.caller === void 0 ? {} : { caller: options.caller }
+    };
+    const activeRun = selected.runtime.run(contribution, args, runOptions);
+    selected.runs.add(activeRun);
+    void activeRun.executorExited.finally(
+      () => selected.runs.delete(activeRun)
+    );
+    return activeRun;
+  };
+  const api = {
+    snapshot,
+    list: () => snapshot().operations,
+    describe: (id, sourceId) => findRecords(id, sourceId).flatMap((record) => {
+      const contribution = record.input.tools.find(({ descriptor }) => descriptor.id === id);
+      return contribution === void 0 ? [] : [
+        {
+          descriptor: contribution.descriptor,
+          owner: record.owner,
+          providerState: record.state,
+          declared: true,
+          callable: record.state === "active",
+          ...record.fiberState === void 0 ? {} : { fiberState: record.fiberState }
+        }
+      ];
+    }),
+    registerProvider,
+    run,
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    async dispose() {
+      if (disposed) return;
+      disposed = true;
+      const pending = [...providers.values()].map((record) => {
+        if (record.state === "active" || record.state === "pending") {
+          record.state = "revoking";
+          record.fiberState = "unloading";
+          for (const run2 of record.runs) run2.cancel("Tool API owner disposed");
+        }
+        return Promise.all([...record.runs].map((run2) => run2.executorExited)).then(() => {
+          if (record.state !== "failed") {
+            record.state = "revoked";
+            record.fiberState = "disposed";
+          }
+        });
+      });
+      await Promise.all(pending);
+      notify();
+      listeners.clear();
+    }
+  };
+  return api;
+}
+
+// src/capability.ts
+var capabilityIdPattern = /^[a-z][a-z0-9]*(?:[._-][a-z0-9]+)*$/;
+function defineToolCapability(id) {
+  if (!capabilityIdPattern.test(id)) {
+    throw new TypeError(`Tool capability id must use a stable lower-case path: ${id}`);
+  }
+  return Object.freeze({ id });
+}
+function createCapabilityResolver(resolve) {
+  return (capability) => {
+    const value = resolve(capability);
+    return value === void 0 ? void 0 : { ok: true, value };
+  };
+}
+function admissionFailure(admission, expected) {
+  if (admission === void 0) return "no workload-scoped admission report was supplied";
+  if (admission.schema !== "forgeax.tool-service-admission-ref.v1" || !/^sha256:[0-9a-f]{64}$/.test(admission.reportDigest)) {
+    return "admission report identity is invalid";
+  }
+  for (const key of [
+    "toolId",
+    "descriptorDigest",
+    "recipeDigest",
+    "workloadClass",
+    "codeDigest",
+    "browserVersion",
+    "backend"
+  ]) {
+    if (admission[key] !== expected[key]) return `admission ${key} does not match this run`;
+  }
+  if (admission.frameCount < 300) return "admission workload ran fewer than 300 frames";
+  if (Object.values(admission.samples).some((count) => count < 30)) {
+    return "admission sample set is incomplete";
+  }
+  if (!admission.correctness.terminalEquivalent || !admission.correctness.artifactIntegrity || !admission.correctness.freshReplay || !admission.correctness.hiddenParity || admission.correctness.drawCalls <= 0 || admission.correctness.nonBlackPixels <= 0) {
+    return "admission correctness gate failed";
+  }
+  const performance2 = admission.performance;
+  if (Object.values(performance2).some((value) => !Number.isFinite(value) || value <= 0) || performance2.serviceMedianMs > performance2.privateMedianMs * 0.8 || performance2.serviceP95Ms > performance2.privateP95Ms * 0.9 || performance2.serviceMaxMs > performance2.privateMaxMs * 1.1 || performance2.serviceRssBytes > performance2.privateRssBytes * 1.25) {
+    return "admission performance threshold failed";
+  }
+  if (!admission.cleanupPassed) return "admission cleanup gate failed";
+  if (!admission.evictionPassed) return "admission eviction gate failed";
+  return void 0;
+}
+function createServiceCapability(admission, expected) {
+  const reason = admissionFailure(admission, expected);
+  if (reason === void 0 && admission !== void 0) {
+    return { available: true, reportDigest: admission.reportDigest };
+  }
+  return {
+    available: false,
+    code: "tool-service-capability-absent",
+    expected: "an admitted acceleration service",
+    hint: "Use the private executor and rerun benchmark admission before enabling service.",
+    detail: { reason: reason ?? "benchmark admission did not pass" }
+  };
+}
+function createRealmCapabilityMatrix(input) {
+  const realms = ["build", "host", "engine"].reduce(
+    (result, realm) => {
+      const supported = input.supported[realm];
+      result[realm] = supported ? { realm, supported: true } : { realm, supported: false, reason: "realm-capability-unavailable" };
+      return result;
+    },
+    {}
+  );
+  return { catalogDigest: input.catalogDigest, realms };
+}
+function bootstrapNotCloneSafeError(detail) {
+  return {
+    code: "tool-bootstrap-not-clone-safe",
+    expected: "bootstrap input to contain structured-clone-safe data",
+    hint: "Remove live handles, functions, ports, and realm-owned objects from bootstrap input.",
+    detail
+  };
+}
+function validateRealmBootstrapPayload(value) {
+  try {
+    structuredClone(value);
+    return { ok: true };
+  } catch (cause) {
+    return {
+      ok: false,
+      error: bootstrapNotCloneSafeError({
+        message: cause instanceof Error ? cause.message : String(cause)
+      })
+    };
+  }
+}
+
+// src/carrier.ts
+function token() {
+  return crypto.randomUUID().replaceAll("-", "");
+}
+function carrierError(code, expected, hint, detail) {
+  return { code, expected, hint, detail };
+}
+function containsLiveKey(value, seen = /* @__PURE__ */ new Set()) {
+  if (typeof value !== "object" || value === null) return false;
+  if (seen.has(value)) return false;
+  seen.add(value);
+  if (Array.isArray(value)) return value.some((entry) => containsLiveKey(entry, seen));
+  return Object.entries(value).some(([key, nested]) => {
+    if (["world", "renderer", "canvas", "ui", "profile", "liveHandle", "context", "fiber"].includes(
+      key
+    ))
+      return true;
+    return containsLiveKey(nested, seen);
+  });
+}
+function validateOptions(options) {
+  if (options.projectId.length === 0 || options.consumerId.length === 0) {
+    throw new TypeError("carrier projectId and consumerId must not be empty");
+  }
+  const endpoint = new URL(options.endpoint);
+  if (endpoint.protocol !== "http:" || !["127.0.0.1", "localhost"].includes(endpoint.hostname)) {
+    throw new TypeError("carrier endpoint must be loopback HTTP");
+  }
+  if (!Number.isFinite(options.now) || !Number.isFinite(options.ttlMs) || options.ttlMs <= 0) {
+    throw new TypeError("carrier clock and ttl must be finite and positive");
+  }
+  if (containsLiveKey(options.payload)) throw new TypeError("carrier-payload-live-state");
+}
+function createCarrierStateMachine(options) {
+  validateOptions(options);
+  const offer = {
+    schemaVersion: "1.0.0",
+    projectId: options.projectId,
+    consumerId: options.consumerId,
+    offerId: `offer:${token()}`,
+    endpoint: options.endpoint,
+    bearerToken: token(),
+    livenessToken: token(),
+    expiresAt: options.now + options.ttlMs,
+    ...options.descriptorDigest === void 0 ? {} : { descriptorDigest: options.descriptorDigest },
+    ...options.recipeDigest === void 0 ? {} : { recipeDigest: options.recipeDigest },
+    state: "offered"
+  };
+  let state = { state: "offered" };
+  let lease;
+  const leaseOffer = (requestOrId, maybeRequest) => {
+    const request = typeof requestOrId === "string" ? maybeRequest : requestOrId;
+    const requestedLeaseId = typeof requestOrId === "string" ? requestOrId : void 0;
+    if (request === void 0) {
+      return {
+        ok: false,
+        error: carrierError(
+          "carrier-token-invalid",
+          "a complete lease request",
+          "Provide consumer identity, bearer token, and current time.",
+          {}
+        )
+      };
+    }
+    if (state.state === "started") {
+      return {
+        ok: false,
+        error: carrierError(
+          "carrier-started",
+          "a started carrier not to be retried",
+          "Report one terminal failure and clean up the existing started lease.",
+          {}
+        )
+      };
+    }
+    if (state.state === "exited") {
+      return {
+        ok: false,
+        error: carrierError(
+          "carrier-exited",
+          "an exited carrier not to be retried",
+          "Re-run the operation from a serialized snapshot instead of migrating live state.",
+          {}
+        )
+      };
+    }
+    if (request.consumerId !== offer.consumerId) {
+      return {
+        ok: false,
+        error: carrierError(
+          "carrier-consumer-mismatch",
+          "the offer consumer identity to match",
+          "Use the consumer identity that was authenticated for this project offer.",
+          { expected: offer.consumerId, actual: request.consumerId }
+        )
+      };
+    }
+    if (request.bearerToken !== offer.bearerToken) {
+      return {
+        ok: false,
+        error: carrierError(
+          "carrier-token-invalid",
+          "the bearer token to match the ephemeral offer",
+          "Request a fresh visible offer; never persist or guess bearer tokens.",
+          {}
+        )
+      };
+    }
+    if (offer.descriptorDigest !== void 0 && request.descriptorDigest !== offer.descriptorDigest) {
+      return {
+        ok: false,
+        error: carrierError(
+          "carrier-descriptor-mismatch",
+          "the descriptor digest to match the authenticated offer",
+          "Refresh the descriptor and request a new visible offer before retrying.",
+          { expected: offer.descriptorDigest, actual: request.descriptorDigest }
+        )
+      };
+    }
+    if (offer.recipeDigest !== void 0 && request.recipeDigest !== offer.recipeDigest) {
+      return {
+        ok: false,
+        error: carrierError(
+          "carrier-recipe-mismatch",
+          "the recipe digest to match the authenticated offer",
+          "Serialize the current snapshot and request a fresh visible offer before retrying.",
+          { expected: offer.recipeDigest, actual: request.recipeDigest }
+        )
+      };
+    }
+    if (request.now >= offer.expiresAt) {
+      state = { state: "expired" };
+      return {
+        ok: false,
+        error: carrierError(
+          "carrier-offer-expired",
+          "the offer to be within its expiry window",
+          "Fall back to the ordinary visible carrier before retrying.",
+          { expiresAt: offer.expiresAt, now: request.now }
+        )
+      };
+    }
+    if (requestedLeaseId !== void 0 && requestedLeaseId !== lease?.leaseId) {
+      return {
+        ok: false,
+        error: carrierError(
+          "carrier-token-invalid",
+          "the lease id to match the authenticated offer",
+          "Use the lease id returned by the first successful lease.",
+          {}
+        )
+      };
+    }
+    lease = {
+      leaseId: `lease:${token()}`,
+      offerId: offer.offerId,
+      consumerId: request.consumerId,
+      state: "leased"
+    };
+    state = { state: "leased", leaseId: lease.leaseId };
+    return { ok: true, value: lease, state: "leased" };
+  };
+  const started = (leaseId) => {
+    if (lease?.leaseId !== leaseId) {
+      return {
+        ok: false,
+        error: carrierError(
+          "carrier-lease-required",
+          "a valid lease before started",
+          "Lease the authenticated offer before reporting provider started.",
+          {}
+        )
+      };
+    }
+    state = { state: "started", leaseId };
+    return { ok: true, value: state, state: "started" };
+  };
+  const exit = (leaseId) => {
+    if (lease?.leaseId !== leaseId || state.state !== "started") {
+      return {
+        ok: false,
+        error: carrierError(
+          "carrier-lease-required",
+          "a started lease before provider exit",
+          "Provider exit is terminal only after started has been acknowledged.",
+          {}
+        )
+      };
+    }
+    state = { state: "exited", leaseId };
+    return { ok: true, value: state, state: "exited" };
+  };
+  const fallback = () => {
+    if (state.state === "started" || state.state === "exited") {
+      return {
+        ok: false,
+        error: carrierError(
+          "carrier-started",
+          "fallback to happen before provider started",
+          "Do not retry or migrate a carrier after started; return its terminal failure.",
+          { state: state.state }
+        )
+      };
+    }
+    state = { state: "fallback" };
+    return { ok: true, value: state, state: "fallback" };
+  };
+  return {
+    offer,
+    lease: leaseOffer,
+    started,
+    exit,
+    fallback,
+    snapshot: () => state
+  };
+}
+
 // src/command-tree.ts
 var ToolCommandError = class extends Error {
   code;
@@ -1543,6 +1920,6 @@ function createAuthenticatedLoopbackTransport(options) {
   };
 }
 
-export { CarrierTransportError, ToolCommandError, artifactIncompleteError, cancellationError, capabilityUnavailableError, cleanupError, commandPath, createArtifactManifest, createArtifactRef, createAuthenticatedCarrierTransport, createAuthenticatedLoopbackTransport, createCapabilityResolver, createCapabilityToken, createCarrierStateMachine, createExclusiveTiming, createLexicalLease, createLoopbackTransport, createMigrationRecipe, createPreviewArtifactManifest, createRealmCapabilityMatrix, createServiceCapability, createSnapshotRef, createToolCommandRegistry, createToolRuntime, defineCommand, defineTool, defineToolCapability, disconnectedError, domainFailureError, finishToolTiming, invalidArgsError, isSerializableValue, isSnapshotRef, parseToolJsonSchema, probeMigrationTarget, snapshotStaleError, startToolTiming, terminalError, terminalSnapshot, timeoutError, toolJsonSchema, validateArtifactManifest, validateArtifactRefs, validateMigrationPayload, validatePreviewArtifactManifest, validateRealmBootstrapPayload };
+export { CarrierTransportError, ToolCommandError, artifactIncompleteError, cancellationError, capabilityUnavailableError, cleanupError, commandPath, createArtifactManifest, createArtifactRef, createAuthenticatedCarrierTransport, createAuthenticatedLoopbackTransport, createCapabilityResolver, createCapabilityToken, createCarrierStateMachine, createExclusiveTiming, createLexicalLease, createLoopbackTransport, createMigrationRecipe, createPreviewArtifactManifest, createRealmCapabilityMatrix, createServiceCapability, createSnapshotRef, createToolApi, createToolCommandRegistry, createToolRuntime, defineCommand, defineTool, defineToolCapability, disconnectedError, domainFailureError, finishToolTiming, invalidArgsError, isSerializableValue, isSnapshotRef, parseToolJsonSchema, probeMigrationTarget, snapshotStaleError, startToolTiming, terminalError, terminalSnapshot, timeoutError, toolJsonSchema, validateArtifactManifest, validateArtifactRefs, validateMigrationPayload, validatePreviewArtifactManifest, validateRealmBootstrapPayload };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map