@phosphorco/bb-identity 0.1.0

package/dist/bb-entry-runtime.js

@@ -0,0 +1,2574 @@
+// @bun
+// http-lifetime-runtime.ts
+function retainIdentityHttpResponse(response, invocationSignal, requestSignal, release) {
+  let settled = false;
+  const finish = () => {
+    if (settled)
+      return;
+    settled = true;
+    invocationSignal.removeEventListener("abort", abort);
+    requestSignal.removeEventListener("abort", abort);
+    release();
+  };
+  let reader;
+  let stream;
+  const abort = () => {
+    if (settled)
+      return;
+    finish();
+    stream?.error(new Error("Identity HTTP invocation expired."));
+    reader?.cancel().catch(() => {
+      return;
+    });
+  };
+  if (!response.body) {
+    finish();
+    return response;
+  }
+  reader = response.body.getReader();
+  const body = new ReadableStream({
+    start(controller) {
+      stream = controller;
+      invocationSignal.addEventListener("abort", abort, { once: true });
+      requestSignal.addEventListener("abort", abort, { once: true });
+      if (invocationSignal.aborted || requestSignal.aborted)
+        abort();
+    },
+    async pull(controller) {
+      if (settled)
+        return;
+      try {
+        const item = await reader.read();
+        if (settled)
+          return;
+        if (item.done) {
+          finish();
+          controller.close();
+        } else
+          controller.enqueue(item.value);
+      } catch (cause) {
+        if (!settled) {
+          finish();
+          controller.error(cause);
+        }
+      }
+    },
+    cancel(reason) {
+      finish();
+      return reader.cancel(reason);
+    }
+  });
+  return new Response(body, { status: response.status, statusText: response.statusText, headers: response.headers });
+}
+
+// bb-upstream-runtime.ts
+import { z } from "zod";
+
+// model-runtime.ts
+var ID_MAX_LENGTH = 256;
+var ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:@/-]*$/;
+function failure(code, message, retry = "never") {
+  return { code, message, retry };
+}
+function ok(value) {
+  return { ok: true, value };
+}
+function err(code, message, retry = "never") {
+  return { ok: false, error: failure(code, message, retry) };
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isBoundedString(value, maximum = ID_MAX_LENGTH) {
+  return typeof value === "string" && value.length > 0 && value.length <= maximum;
+}
+function idCodec(kind) {
+  return {
+    decode(input) {
+      const valid = kind === "server-session" ? isBoundedString(input, 4096) && !/[\u0000-\u0020\u007f]/.test(input) : isBoundedString(input) && ID_PATTERN.test(input);
+      if (!valid) {
+        return err("invalid-input", `Invalid ${kind} identifier.`);
+      }
+      return ok(input);
+    },
+    encode(value) {
+      return value;
+    }
+  };
+}
+var identityKeyCodec = {
+  decode(input) {
+    if (!isBoundedString(input, 512) || /[\u0000-\u001f\u007f]/.test(input)) {
+      return err("invalid-input", "Invalid identity key.");
+    }
+    return ok(input);
+  },
+  encode(value) {
+    return value;
+  }
+};
+function decodePresentation(value) {
+  return isRecord(value) && isBoundedString(value.displayName, 512) && (value.handle === null || isBoundedString(value.handle, 512)) && (value.avatarUrl === null || isBoundedString(value.avatarUrl, 2048));
+}
+function decodeIdentity(value) {
+  if (!isRecord(value) || !identityKeyCodec.decode(value.key).ok)
+    return false;
+  if (value.kind === "person")
+    return isBoundedString(value.issuer, 512) && isBoundedString(value.subject, 512);
+  if (value.kind === "default-user")
+    return isBoundedString(value.instanceId);
+  if (value.kind === "machine") {
+    return isBoundedString(value.instanceId) && (value.hostId === null || isBoundedString(value.hostId, 512));
+  }
+  return value.kind === "external" && isBoundedString(value.pluginId) && isBoundedString(value.subject, 512);
+}
+var profileCodec = {
+  decode(input) {
+    if (!isRecord(input) || !decodeIdentity(input.identity) || !decodePresentation(input.presentation) || !isBoundedString(input.revision) || input.status !== "current" && input.status !== "historical") {
+      return err("invalid-input", "Invalid identity profile.");
+    }
+    return ok(input);
+  },
+  encode(value) {
+    return value;
+  }
+};
+function isContributionReference(value) {
+  return isRecord(value) && idCodec("thread").decode(value.threadId).ok && idCodec("contribution").decode(value.contributionId).ok;
+}
+function isPersonReference(value) {
+  return isRecord(value) && (value.kind === "person" || value.kind === "default-user") && decodeIdentity(value);
+}
+function isMachineReference(value) {
+  return isRecord(value) && value.kind === "machine" && decodeIdentity(value);
+}
+function isActorSnapshot(value) {
+  if (!isRecord(value) || !decodeIdentity(value.identity) || !decodePresentation(value.presentation))
+    return false;
+  const evidence = value.evidence;
+  if (evidence !== "provider-verified" && evidence !== "local-user" && evidence !== "upstream-default" && evidence !== "integration-asserted" && evidence !== "legacy" && evidence !== "machine")
+    return false;
+  return isMachineReference(value.identity) ? evidence === "machine" : evidence !== "machine";
+}
+function isOrigin(value) {
+  if (!isRecord(value))
+    return false;
+  if (value.kind === "person") {
+    const actor = value.actor;
+    return isActorSnapshot(actor) && isRecord(actor) && isPersonReference(actor.identity);
+  }
+  if (value.kind === "machine") {
+    const actor = value.actor;
+    return isActorSnapshot(actor) && isRecord(actor) && isMachineReference(actor.identity) && isRecord(actor) && actor.evidence === "machine";
+  }
+  if (value.kind === "external") {
+    const actor = value.actor;
+    return isActorSnapshot(actor) && isRecord(actor) && isRecord(actor.identity) && actor.identity.kind === "external" && actor.evidence !== "machine";
+  }
+  if (value.kind === "agent")
+    return value.agentId === null || isBoundedString(value.agentId);
+  if (value.kind === "system")
+    return isBoundedString(value.reason, 1024);
+  return value.kind === "unknown" && (value.reason === "legacy" || value.reason === "upstream-unattributed" || value.reason === "missing-source");
+}
+function isContribution(value) {
+  return isRecord(value) && isContributionReference(value.reference) && isOrigin(value.author) && (value.latestEditor === null || isActorSnapshot(value.latestEditor)) && isBoundedString(value.acceptedAt, 256) && Array.isArray(value.mentionedPeople) && value.mentionedPeople.every(isPersonReference);
+}
+function isCorrelation(value) {
+  return isRecord(value) && idCodec("thread").decode(value.threadId).ok && isBoundedString(value.turnId) && isBoundedString(value.attemptId) && (value.toolCallId === null || isBoundedString(value.toolCallId));
+}
+function referenceKey(value) {
+  return `${value.threadId}\x00${value.contributionId}`;
+}
+function isInputSource(value) {
+  if (!isRecord(value))
+    return false;
+  if (value.kind === "contribution")
+    return isContributionReference(value.reference);
+  if (value.kind === "interaction")
+    return isBoundedString(value.interactionId) && isOrigin(value.resolver);
+  return value.kind === "generated" && (value.purpose === "continuation" || value.purpose === "resolved-resource" || value.purpose === "system-context") && Array.isArray(value.basedOn) && value.basedOn.every(isContributionReference);
+}
+function causalReferences(groups) {
+  const references = [];
+  for (const group of groups) {
+    if (!isRecord(group) || !Array.isArray(group.sources) || !group.sources.every(isInputSource))
+      return null;
+    for (const source of group.sources) {
+      if (!isRecord(source))
+        return null;
+      if (source.kind === "contribution" && isContributionReference(source.reference))
+        references.push(source.reference);
+      if (source.kind === "generated" && Array.isArray(source.basedOn) && source.basedOn.every(isContributionReference))
+        references.push(...source.basedOn);
+    }
+  }
+  return references;
+}
+function hasCompleteCausality(groups, contributions, missing) {
+  const references = causalReferences(groups);
+  if (references === null || !contributions.every(isContribution) || !missing.every(isContributionReference))
+    return false;
+  const required = new Set(references.map(referenceKey));
+  const found = new Set;
+  for (const contribution of contributions) {
+    if (!isRecord(contribution) || !isContributionReference(contribution.reference))
+      return false;
+    const key = referenceKey(contribution.reference);
+    if (found.has(key))
+      return false;
+    found.add(key);
+  }
+  const absent = new Set;
+  for (const reference of missing) {
+    const key = referenceKey(reference);
+    if (absent.has(key) || found.has(key))
+      return false;
+    absent.add(key);
+  }
+  return required.size === found.size + absent.size && [...required].every((key) => found.has(key) || absent.has(key));
+}
+var provenanceCodec = {
+  decode(input) {
+    if (!isRecord(input) || input.status !== "known" && input.status !== "partial" && input.status !== "unknown") {
+      return err("invalid-input", "Invalid execution provenance.");
+    }
+    if (input.status === "unknown")
+      return (input.correlation === null || isCorrelation(input.correlation)) && isBoundedString(input.reason, 1024) ? ok(input) : err("invalid-input", "Unknown provenance needs a valid correlation and reason.");
+    if (!Array.isArray(input.inputGroups) || !Array.isArray(input.contributions))
+      return err("invalid-input", "Provenance needs input groups and contributions.");
+    if (input.status === "known") {
+      return isCorrelation(input.correlation) && hasCompleteCausality(input.inputGroups, input.contributions, []) ? ok(input) : err("invalid-input", "Known provenance needs complete correlated evidence.");
+    }
+    if ((input.correlation === null || isCorrelation(input.correlation)) && Array.isArray(input.missing) && isBoundedString(input.reason, 1024) && hasCompleteCausality(input.inputGroups, input.contributions, input.missing)) {
+      return ok(input);
+    }
+    return err("invalid-input", "Partial provenance needs complete causal accounting.");
+  },
+  encode(value) {
+    return value;
+  }
+};
+function defaultIdentityKey(instance) {
+  return `local:${instance}`;
+}
+
+// bb-upstream-runtime.ts
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isJson(value) {
+  return value === null || typeof value === "boolean" || typeof value === "string" || typeof value === "number" && Number.isFinite(value) || Array.isArray(value) && value.every(isJson) || isRecord2(value) && Object.values(value).every(isJson);
+}
+function cloneJson(value) {
+  return structuredClone(value);
+}
+function clonePluginRpcInput(value) {
+  return structuredClone(value);
+}
+function freeze(value) {
+  if (value && typeof value === "object") {
+    Object.freeze(value);
+    for (const child of Object.values(value))
+      freeze(child);
+  }
+  return value;
+}
+function escapeExternalEnvelopeValue(value) {
+  return value.replace(/[\[\]\r\n%<>]/g, (character) => encodeURIComponent(character));
+}
+function renderExternalPrompt(pluginId, author, input) {
+  const displayName = author.presentation.handle ?? author.presentation.displayName;
+  const label = escapeExternalEnvelopeValue(`${pluginId}:${displayName.length ? displayName : "External source"}`);
+  return Object.freeze([
+    { type: "text", text: `[message received from external source]
+[sender=${label}]
+`, mentions: [], visibility: "agent-only" },
+    ...input,
+    { type: "text", text: `
+[/sender=${label}]`, mentions: [], visibility: "agent-only" }
+  ]);
+}
+function defaultScheduler() {
+  return {
+    now: () => Date.now(),
+    schedule(delayMs, callback) {
+      const timeout = setTimeout(callback, delayMs);
+      return () => clearTimeout(timeout);
+    }
+  };
+}
+var promptInputCodec = {
+  decode(value) {
+    if (!isRecord2(value) || !isJson(value) || typeof value.type !== "string")
+      return err("invalid-input", "Prompt input must be a JSON SDK prompt part.");
+    const valid = value.type === "text" ? typeof value.text === "string" && (value.mentions === undefined || Array.isArray(value.mentions)) : value.type === "image" ? typeof value.url === "string" : value.type === "localImage" ? typeof value.path === "string" : value.type === "localFile" ? typeof value.path === "string" : false;
+    return valid ? ok(freeze(structuredClone(value))) : err("invalid-input", "Invalid installed-SDK prompt input shape.");
+  },
+  encode(value) {
+    const encoded = value;
+    if (!isJson(encoded))
+      throw new TypeError("Prompt input codec received non-JSON data.");
+    return cloneJson(encoded);
+  }
+};
+function unavailableSession(instanceId, code, message) {
+  return { status: "unauthenticated", instanceId, error: { code, message, retry: "never" } };
+}
+function nativeIds(value) {
+  if (!isRecord2(value) || value.ok !== true)
+    return err("incompatible", "Malformed upstream dispatch response.");
+  if (!Object.hasOwn(value, "delivery"))
+    return ok({ deliveryId: null, queuedMessageId: null, turnId: null });
+  if (value.delivery === "sent")
+    return ok({ deliveryId: null, queuedMessageId: null, turnId: null });
+  if (value.delivery === "queued" && isRecord2(value.queuedMessage) && typeof value.queuedMessage.id === "string" && value.queuedMessage.id.length) {
+    return ok({ deliveryId: null, queuedMessageId: value.queuedMessage.id, turnId: null });
+  }
+  return err("incompatible", "Malformed upstream dispatch response.");
+}
+function createBbUpstreamDriver(options) {
+  const externalMessageRendering = options.externalMessageRendering ?? "host";
+  if (externalMessageRendering !== "host" && externalMessageRendering !== "producer") {
+    return err("invalid-input", "Invalid external message rendering mode.");
+  }
+  const instance = idCodec("instance").decode(options.stateNamespace ?? "local");
+  const plugin = idCodec("plugin").decode(options.bb.pluginId);
+  if (!instance.ok || !plugin.ok)
+    return err("invalid-input", "The upstream binding requires valid plugin and state namespace IDs.");
+  const instanceId = instance.value;
+  const pluginId = plugin.value;
+  const singletonKey = defaultIdentityKey(instanceId);
+  const machineKey = identityKeyCodec.decode("p6r-machine:v1:" + encodeURIComponent(instanceId) + ":server");
+  const stamp = idCodec("server-session").decode("singleton:" + instanceId);
+  const revision = idCodec("revision").decode("singleton:" + instanceId);
+  if (!machineKey.ok || !stamp.ok || !revision.ok)
+    return err("incompatible", "Unable to construct stable upstream identity identifiers.");
+  const machineIdentity = { kind: "machine", key: machineKey.value, instanceId, hostId: null };
+  const capabilities = {
+    requestIdentity: "singleton",
+    acceptance: "pre-dispatch-check",
+    forwarding: "singleton-convention",
+    directory: { search: false, lookup: false },
+    participants: false,
+    externalSend: "source-labelled",
+    toolProvenance: "unknown",
+    operationLookup: false
+  };
+  const readySession = () => freeze({
+    status: "ready",
+    instanceId,
+    mode: "single-user",
+    actor: {
+      identity: { kind: "default-user", key: singletonKey, instanceId },
+      presentation: { displayName: "Local user", handle: null, avatarUrl: null },
+      evidence: "upstream-default"
+    },
+    stamp: stamp.value,
+    capabilities
+  });
+  const machineSession = () => freeze({
+    status: "ready",
+    instanceId,
+    mode: "single-user",
+    actor: {
+      identity: machineIdentity,
+      presentation: { displayName: "BB machine", handle: null, avatarUrl: null },
+      evidence: "machine"
+    },
+    stamp: stamp.value,
+    capabilities
+  });
+  const selfProfile = () => freeze({
+    identity: { kind: "default-user", key: singletonKey, instanceId },
+    presentation: { displayName: "Local user", handle: null, avatarUrl: null },
+    revision: revision.value,
+    status: "current"
+  });
+  const machineProfile = () => freeze({
+    identity: machineIdentity,
+    presentation: { displayName: "BB machine", handle: null, avatarUrl: null },
+    revision: revision.value,
+    status: "current"
+  });
+  let disposed = false;
+  const records = new WeakMap;
+  const active = new Set;
+  const listeners = new Set;
+  const labelledExternal = new WeakSet;
+  const terminateScope = (record, scope) => {
+    if (!scope || scope.released)
+      return;
+    scope.released = true;
+    record.controller.signal.removeEventListener("abort", scope.parentAbort);
+    scope.controller.abort();
+    record.scopes.delete(scope);
+  };
+  const terminate = (record) => {
+    for (const scope of [...record.scopes])
+      terminateScope(record, scope);
+    record.controller.abort();
+    active.delete(record);
+  };
+  const known = (context) => {
+    const record = records.get(context);
+    return !record ? err("invalid-input", "Invocation context was not issued by this binding.") : disposed ? err("disposed", "Upstream binding is disposed.") : record.controller.signal.aborted ? err("expired", "Invocation context has expired.") : ok(record);
+  };
+  const admission = (context) => {
+    const record = known(context);
+    if (!record.ok)
+      return record;
+    if (record.value.origin === "external")
+      return err("unauthenticated", "External upstream work uses an explicit external source.");
+    return record;
+  };
+  const session = (context) => {
+    const record = known(context);
+    if (!record.ok)
+      return unavailableSession(instanceId, record.error.code === "invalid-input" ? "incompatible" : "unauthenticated", record.error.message);
+    if (record.value.origin === "interactive-user")
+      return readySession();
+    return record.value.origin === "background" ? machineSession() : unavailableSession(instanceId, "unauthenticated", "External upstream work uses an explicit external source.");
+  };
+  const driver = {
+    instanceId,
+    pluginId,
+    inputCodec: promptInputCodec,
+    scheduler: options.scheduler ?? defaultScheduler(),
+    async session(context) {
+      return session(context);
+    },
+    async selfProfile(context) {
+      const allowed = admission(context);
+      return allowed.ok ? ok(allowed.value.origin === "background" ? machineProfile() : selfProfile()) : allowed;
+    },
+    async openScope(context) {
+      const allowed = admission(context);
+      if (!allowed.ok)
+        return allowed;
+      const record = allowed.value;
+      let scope;
+      const parentAbort = () => terminateScope(record, scope);
+      scope = { controller: new AbortController, parentAbort, released: false };
+      record.scopes.add(scope);
+      const expire = () => terminateScope(record, scope);
+      record.controller.signal.addEventListener("abort", parentAbort, { once: true });
+      const exposedSession = record.origin === "background" ? machineSession() : readySession();
+      const expectedKey = record.origin === "background" ? machineKey.value : singletonKey;
+      return ok({
+        signal: scope.controller.signal,
+        session: exposedSession,
+        validate(expected) {
+          if (scope.released || scope.controller.signal.aborted || record.controller.signal.aborted || disposed) {
+            return err("expired", "Upstream request context is no longer live.");
+          }
+          return expected.actor === expectedKey && expected.session === stamp.value ? ok(undefined) : err("stale-context", "Request expectation does not match the singleton session.");
+        },
+        release: expire
+      });
+    },
+    async submit(input, readOptions) {
+      if (disposed)
+        return { status: "rejected", error: { code: "disposed", message: "Upstream binding is disposed.", retry: "never" } };
+      if (readOptions?.signal?.aborted)
+        return { status: "rejected", error: { code: "cancelled", message: "Submission was cancelled before dispatch.", retry: "never" } };
+      const operation = idCodec("operation").decode(input.operationId);
+      const thread = idCodec("thread").decode(input.threadId);
+      if (!operation.ok || !thread.ok || !["auto", "start", "steer-if-active", "queue-if-active"].includes(input.mode)) {
+        return { status: "rejected", error: { code: "invalid-input", message: "Invalid upstream submission metadata.", retry: "never" } };
+      }
+      const labelled = labelledExternal.has(input.input);
+      const prompts = [];
+      for (const item of input.input) {
+        const decoded = promptInputCodec.decode(item);
+        if (!decoded.ok)
+          return { status: "rejected", error: decoded.error };
+        prompts.push(decoded.value);
+      }
+      try {
+        const response = await options.bb.sdk.threads.send({ threadId: thread.value, mode: input.mode, input: prompts });
+        const native = nativeIds(response);
+        if (!native.ok)
+          return { status: "indeterminate", operationId: operation.value, message: "Upstream dispatch returned an unrecognized response after submission." };
+        return {
+          status: "submitted",
+          receipt: {
+            evidence: "upstream-response",
+            operationId: operation.value,
+            acceptedAt: null,
+            references: null,
+            native: native.value,
+            provenance: labelled ? "source-labelled" : "upstream-default",
+            deduplication: "not-guaranteed"
+          }
+        };
+      } catch {
+        return { status: "indeterminate", operationId: operation.value, message: "Upstream submission may have been accepted before its response failed." };
+      }
+    },
+    labelExternal(_author, input) {
+      const copied = Object.freeze(input.map((item) => {
+        const decoded = promptInputCodec.decode(item);
+        return decoded.ok ? decoded.value : item;
+      }));
+      labelledExternal.add(copied);
+      return copied;
+    },
+    toolCorrelation(_context) {
+      return { status: "unknown", correlation: null, reason: "upstream-unattributed" };
+    },
+    async forward(context, destinationPlugin, method, input, readOptions) {
+      const allowed = known(context);
+      if (!allowed.ok)
+        throw allowed.error;
+      if (readOptions?.signal?.aborted)
+        throw { code: "cancelled", message: "Plugin forwarding was cancelled before dispatch.", retry: "never" };
+      const destination = idCodec("plugin").decode(destinationPlugin);
+      if (!destination.ok || !/^[A-Za-z0-9_-]+(?:\.[A-Za-z0-9_-]+)*$/.test(method) || !isJson(input)) {
+        throw { code: "invalid-input", message: "Invalid upstream plugin RPC destination.", retry: "never" };
+      }
+      return options.bb.sdk.plugins.callRpc({ pluginId: destination.value, method, input: clonePluginRpcInput(input), outputSchema: z.unknown() });
+    },
+    subscribe(listener) {
+      if (!disposed)
+        listeners.add(listener);
+      return () => listeners.delete(listener);
+    }
+  };
+  const binding = {
+    externalMessageRendering,
+    driver,
+    issue(origin) {
+      if (disposed)
+        throw new Error("Upstream binding is disposed.");
+      const controller = new AbortController;
+      const invocation = Object.freeze({ origin, signal: controller.signal });
+      const record = { origin, controller, scopes: new Set };
+      records.set(invocation, record);
+      active.add(record);
+      return invocation;
+    },
+    release(invocation) {
+      const record = records.get(invocation);
+      if (record)
+        terminate(record);
+    },
+    dispose() {
+      if (disposed)
+        return;
+      disposed = true;
+      for (const record of [...active])
+        terminate(record);
+      for (const listener of [...listeners]) {
+        try {
+          listener({ kind: "disposed" });
+        } catch {}
+      }
+      listeners.clear();
+    }
+  };
+  try {
+    options.bb.onDispose(() => binding.dispose());
+  } catch {
+    binding.dispose();
+    return err("unavailable", "Unable to register upstream binding cleanup.", "after-refresh");
+  }
+  return ok(binding);
+}
+
+// host-runtime.ts
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function unavailable(message) {
+  return { code: "unavailable", message, retry: "after-reconnect" };
+}
+function isPresentation(value) {
+  return isRecord3(value) && typeof value.displayName === "string" && (value.handle === null || typeof value.handle === "string") && (value.avatarUrl === null || typeof value.avatarUrl === "string");
+}
+function isPersonIdentity(value) {
+  if (!isRecord3(value) || !identityKeyCodec.decode(value.key).ok)
+    return false;
+  return value.kind === "person" ? typeof value.issuer === "string" && typeof value.subject === "string" : value.kind === "default-user" && idCodec("instance").decode(value.instanceId).ok;
+}
+function isMachineIdentity(value) {
+  return isRecord3(value) && value.kind === "machine" && identityKeyCodec.decode(value.key).ok && idCodec("instance").decode(value.instanceId).ok && (value.hostId === null || typeof value.hostId === "string" && value.hostId.length > 0 && value.hostId.length <= 512);
+}
+function isActorIdentity(value) {
+  return isPersonIdentity(value) || isMachineIdentity(value);
+}
+function isCapabilities(value) {
+  return isRecord3(value) && (value.requestIdentity === "singleton" || value.requestIdentity === "host-resolved") && (value.acceptance === "pre-dispatch-check" || value.acceptance === "transactional-check") && (value.forwarding === "singleton-convention" || value.forwarding === "host-bound") && isRecord3(value.directory) && typeof value.directory.search === "boolean" && typeof value.directory.lookup === "boolean" && typeof value.participants === "boolean" && (value.externalSend === "source-labelled" || value.externalSend === "structured") && (value.toolProvenance === "unknown" || value.toolProvenance === "partial" || value.toolProvenance === "causal") && typeof value.operationLookup === "boolean";
+}
+function asResult(value) {
+  if (!isRecord3(value) || typeof value.ok !== "boolean")
+    return err("incompatible", "Host returned a malformed Result.");
+  if (value.ok)
+    return "value" in value ? ok(value.value) : err("incompatible", "Host returned a successful Result without a value.");
+  const failure2 = decodeError(value.error);
+  return failure2.ok ? { ok: false, error: failure2.value } : failure2;
+}
+function decodeError(value) {
+  const codes = new Set([
+    "unavailable",
+    "unauthenticated",
+    "unsupported",
+    "incompatible",
+    "invalid-input",
+    "not-found",
+    "ambiguous",
+    "stale-owner",
+    "stale-context",
+    "conflict",
+    "cancelled",
+    "disposed",
+    "limit-exceeded",
+    "invalid-operation",
+    "expired"
+  ]);
+  const retries = new Set(["never", "after-refresh", "after-reconnect", "same-operation"]);
+  return isRecord3(value) && typeof value.code === "string" && codes.has(value.code) && typeof value.message === "string" && typeof value.retry === "string" && retries.has(value.retry) ? ok(value) : err("incompatible", "Host returned a malformed identity error.");
+}
+function isReference(value) {
+  return isRecord3(value) && idCodec("thread").decode(value.threadId).ok && idCodec("contribution").decode(value.contributionId).ok;
+}
+function isNativeIds(value) {
+  return isRecord3(value) && ["deliveryId", "queuedMessageId", "turnId"].every((key) => value[key] === null || typeof value[key] === "string");
+}
+function decodeAcceptance(value) {
+  if (!isRecord3(value) || typeof value.status !== "string")
+    return err("incompatible", "Host returned a malformed acceptance outcome.");
+  if (value.status === "rejected") {
+    const error = decodeError(value.error);
+    return error.ok ? ok({ status: "rejected", error: error.value }) : error;
+  }
+  if (value.status === "indeterminate") {
+    const operationId2 = idCodec("operation").decode(value.operationId);
+    return operationId2.ok && typeof value.message === "string" ? ok({ status: "indeterminate", operationId: operationId2.value, message: value.message }) : err("incompatible", "Host returned malformed indeterminate acceptance metadata.");
+  }
+  if (value.status !== "submitted" || !isRecord3(value.receipt))
+    return err("incompatible", "Host returned an unknown acceptance outcome.");
+  const receipt = value.receipt;
+  const operationId = idCodec("operation").decode(receipt.operationId);
+  if (!operationId.ok || !isNativeIds(receipt.native))
+    return err("incompatible", "Host returned malformed acceptance receipt identifiers.");
+  if (receipt.evidence === "host-accepted") {
+    return typeof receipt.acceptedAt === "string" && Array.isArray(receipt.references) && receipt.references.every(isReference) && receipt.provenance === "structured" && receipt.deduplication === "guaranteed" && typeof receipt.retainedUntil === "string" ? ok(value) : err("incompatible", "Host returned malformed durable acceptance metadata.");
+  }
+  if (receipt.evidence === "upstream-response") {
+    return receipt.acceptedAt === null && receipt.references === null && (receipt.provenance === "source-labelled" || receipt.provenance === "upstream-default") && receipt.deduplication === "not-guaranteed" ? ok(value) : err("incompatible", "Host returned malformed upstream acceptance metadata.");
+  }
+  return err("incompatible", "Host returned an unknown acceptance receipt evidence value.");
+}
+function decodeLookup(value) {
+  if (!isRecord3(value) || typeof value.status !== "string")
+    return err("incompatible", "Host returned a malformed operation lookup.");
+  if (value.status === "final") {
+    const outcome = decodeAcceptance(value.outcome);
+    return outcome.ok ? ok({ status: "final", outcome: outcome.value }) : outcome;
+  }
+  if (value.status === "pending")
+    return ok({ status: "pending" });
+  if (value.status === "absent-final" && value.retry === "same-operation-only")
+    return ok({ status: "absent-final", retry: "same-operation-only" });
+  if (value.status === "unknown" && (value.reason === "unsupported" || value.reason === "expired" || value.reason === "unavailable")) {
+    return ok({ status: "unknown", reason: value.reason });
+  }
+  return err("incompatible", "Host returned malformed operation lookup metadata.");
+}
+var serverSessionCodec = {
+  decode(input) {
+    if (!isRecord3(input) || typeof input.status !== "string" || !identityKeyCodec.decode(input.instanceId).ok) {
+      return err("invalid-input", "Invalid server session.");
+    }
+    if (input.status !== "ready") {
+      if ((input.status === "unavailable" || input.status === "unauthenticated" || input.status === "incompatible") && isRecord3(input.error)) {
+        return ok(input);
+      }
+      return err("invalid-input", "Invalid unavailable server session.");
+    }
+    if (!isRecord3(input.actor) || !isActorIdentity(input.actor.identity) || !isPresentation(input.actor.presentation) || input.actor.evidence !== "provider-verified" && input.actor.evidence !== "local-user" && input.actor.evidence !== "upstream-default" && input.actor.evidence !== "integration-asserted" && input.actor.evidence !== "legacy" && input.actor.evidence !== "machine" || isMachineIdentity(input.actor.identity) !== (input.actor.evidence === "machine") || !isCapabilities(input.capabilities) || typeof input.stamp !== "string" || input.mode !== "single-user" && input.mode !== "multi-user") {
+      return err("invalid-input", "Invalid ready server session.");
+    }
+    return ok(input);
+  },
+  encode(value) {
+    return value;
+  }
+};
+function unsupportedDirectory() {
+  return {
+    search: async () => err("unsupported", "Directory search is unavailable."),
+    getMany: async () => err("unsupported", "Directory lookup is unavailable."),
+    subscribe: () => () => {}
+  };
+}
+function unsupportedParticipants() {
+  return {
+    list: async () => err("unsupported", "Participant history is unavailable."),
+    previews: async () => err("unsupported", "Participant previews are unavailable.")
+  };
+}
+function unsupportedHistory() {
+  return {
+    contributions: async (_query) => ok({ status: "unavailable", reason: "unsupported" }),
+    attempts: async (_query) => ok({ status: "unavailable", reason: "unsupported" })
+  };
+}
+function isProfilePresentation(value) {
+  if (!isRecord3(value))
+    return false;
+  const displayName = value.displayName;
+  const handle = value.handle;
+  const avatarUrl = value.avatarUrl;
+  return typeof displayName === "string" && displayName.length > 0 && displayName.length <= 512 && (handle === null || typeof handle === "string" && handle.length > 0 && handle.length <= 512) && (avatarUrl === null || typeof avatarUrl === "string" && avatarUrl.length > 0 && avatarUrl.length <= 2048);
+}
+function isExternalIdentity(value) {
+  return isRecord3(value) && value.kind === "external" && identityKeyCodec.decode(value.key).ok && idCodec("plugin").decode(value.pluginId).ok && idCodec("subject").decode(value.subject).ok;
+}
+function isParticipant(value) {
+  if (!isRecord3(value))
+    return false;
+  const roles = value.roles;
+  return (isActorIdentity(value.identity) || isExternalIdentity(value.identity)) && isProfilePresentation(value.presentation) && Array.isArray(roles) && roles.length > 0 && new Set(roles).size === roles.length && roles.every((role) => role === "author" || role === "editor" || role === "mentioned" || role === "interaction-resolver");
+}
+function decodeParticipantPage(value) {
+  if (!isRecord3(value) || !Array.isArray(value.items) || value.nextCursor !== null && !idCodec("cursor").decode(value.nextCursor).ok || !idCodec("revision").decode(value.revision).ok || value.coverage !== "complete-history" && value.coverage !== "partial-history") {
+    return err("incompatible", "Host returned a malformed participant page.");
+  }
+  const items = [];
+  for (const item of value.items) {
+    if (!isParticipant(item) || !isRecord3(item) || !Array.isArray(item.roles))
+      return err("incompatible", "Host returned a malformed participant item.");
+    const identity = profileCodec.decode({ identity: item.identity, presentation: item.presentation, revision: "participant", status: "current" });
+    if (!identity.ok)
+      return err("incompatible", "Host returned a malformed participant identity.");
+    items.push({ identity: identity.value.identity, presentation: identity.value.presentation, roles: [...item.roles] });
+  }
+  const cursor = value.nextCursor === null ? null : idCodec("cursor").decode(value.nextCursor);
+  const revision = idCodec("revision").decode(value.revision);
+  if (cursor !== null && !cursor.ok || !revision.ok)
+    return err("incompatible", "Host returned malformed participant identifiers.");
+  return ok({ items, nextCursor: cursor === null ? null : cursor.value, revision: revision.value, coverage: value.coverage });
+}
+function isContribution2(value) {
+  if (!isRecord3(value) || !isReference(value.reference) || typeof value.acceptedAt !== "string" || value.acceptedAt.length === 0 || value.acceptedAt.length > 256 || !Array.isArray(value.mentionedPeople) || !value.mentionedPeople.every(isPersonIdentity))
+    return false;
+  const snapshot = (candidate) => {
+    if (!isRecord3(candidate) || !(isActorIdentity(candidate.identity) || isExternalIdentity(candidate.identity)) || !isProfilePresentation(candidate.presentation))
+      return false;
+    const evidence = candidate.evidence;
+    if (!["provider-verified", "local-user", "upstream-default", "integration-asserted", "legacy", "machine"].includes(evidence))
+      return false;
+    return isMachineIdentity(candidate.identity) ? evidence === "machine" : evidence !== "machine";
+  };
+  const origin = value.author;
+  if (!isRecord3(origin))
+    return false;
+  const validOrigin = origin.kind === "person" ? snapshot(origin.actor) && isRecord3(origin.actor) && isPersonIdentity(origin.actor.identity) : origin.kind === "machine" ? snapshot(origin.actor) && isRecord3(origin.actor) && isMachineIdentity(origin.actor.identity) : origin.kind === "external" ? snapshot(origin.actor) && isRecord3(origin.actor) && isExternalIdentity(origin.actor.identity) : origin.kind === "agent" ? origin.agentId === null || idCodec("agent").decode(origin.agentId).ok : origin.kind === "system" ? typeof origin.reason === "string" && origin.reason.length > 0 && origin.reason.length <= 1024 : origin.kind === "unknown" && (origin.reason === "legacy" || origin.reason === "upstream-unattributed" || origin.reason === "missing-source");
+  return validOrigin && (value.latestEditor === null || snapshot(value.latestEditor));
+}
+function decodeEvidencePage(value, decodeItem) {
+  if (!isRecord3(value) || typeof value.status !== "string")
+    return err("incompatible", "Host returned a malformed evidence page.");
+  if (value.status === "pending")
+    return ok({ status: "pending" });
+  if (value.status === "unavailable")
+    return value.reason === "unsupported" || value.reason === "missing-history" || value.reason === "outage" ? ok({ status: "unavailable", reason: value.reason }) : err("incompatible", "Host returned an invalid evidence-unavailable reason.");
+  if (value.status !== "known" && value.status !== "partial" || !Array.isArray(value.items) || !value.items.every(decodeItem) || !Array.isArray(value.missing) || !value.missing.every((missing) => typeof missing === "string" && missing.length > 0 && missing.length <= 512) || value.nextCursor !== null && !idCodec("cursor").decode(value.nextCursor).ok || value.traversal !== "complete" && value.traversal !== "continued" || value.status === "known" && value.missing.length !== 0)
+    return err("incompatible", "Host returned malformed evidence metadata.");
+  return ok(value);
+}
+function validContributionQuery(query) {
+  const cursor = query.cursor === undefined || idCodec("cursor").decode(query.cursor).ok;
+  const limit = query.limit === undefined || Number.isInteger(query.limit) && query.limit >= 1 && query.limit <= 200;
+  if (!cursor || !limit)
+    return false;
+  return query.kind === "references" ? query.references.length <= 100 && query.references.every(isReference) : idCodec("thread").decode(query.threadId).ok && idCodec(query.kind === "native-message" ? "message" : "event").decode(query.kind === "native-message" ? query.messageId : query.eventId).ok;
+}
+function validAttemptQuery(query) {
+  return (query.cursor === undefined || idCodec("cursor").decode(query.cursor).ok) && (query.limit === undefined || Number.isInteger(query.limit) && query.limit >= 1 && query.limit <= 200) && (query.kind === "operation" ? idCodec("operation").decode(query.operationId).ok : isReference(query.reference));
+}
+function decodeP6rPersonKey(key) {
+  const prefix = "p6r-person:v1:";
+  if (!key.startsWith(prefix))
+    return null;
+  const encoded = key.slice(prefix.length);
+  const divider = encoded.indexOf(":");
+  if (divider < 1 || divider === encoded.length - 1)
+    return null;
+  const encodedIssuer = encoded.slice(0, divider);
+  const encodedSubject = encoded.slice(divider + 1);
+  try {
+    const issuer = decodeURIComponent(encodedIssuer);
+    const subject = decodeURIComponent(encodedSubject);
+    return encodeURIComponent(issuer) === encodedIssuer && encodeURIComponent(subject) === encodedSubject && idCodec("issuer").decode(issuer).ok && idCodec("subject").decode(subject).ok ? { issuer, subject } : null;
+  } catch {
+    return null;
+  }
+}
+function createEnhancedDirectory(protocol) {
+  const mappings = new Map;
+  let activeGeneration = null;
+  const sources = () => {
+    let raw;
+    try {
+      raw = protocol.directorySources();
+    } catch {
+      return err("unavailable", "Enhanced provider directory is unavailable.", "after-reconnect");
+    }
+    if (!Array.isArray(raw))
+      return err("incompatible", "Enhanced provider directory sources are malformed.");
+    if (raw.length > 1)
+      return err("incompatible", "Enhanced protocol exposed multiple active provider directories.");
+    for (const source of raw) {
+      if (!isRecord3(source) || !Array.isArray(source.issuers) || source.issuers.length === 0 || new Set(source.issuers).size !== source.issuers.length || !source.issuers.every((issuer) => idCodec("issuer").decode(issuer).ok) || !idCodec("provider-generation").decode(source.generation).ok || typeof source.person !== "function" || source.directory !== undefined && typeof source.directory !== "function" || source.lookup !== undefined && typeof source.lookup !== "function")
+        return err("incompatible", "Enhanced provider directory source is malformed.");
+    }
+    const generation = raw[0]?.generation ?? null;
+    if (activeGeneration !== generation) {
+      mappings.clear();
+      activeGeneration = generation;
+    }
+    return ok(raw);
+  };
+  const sameGeneration = (generation) => {
+    const current = sources();
+    if (!current.ok)
+      return current;
+    const source = current.value[0];
+    return source && source.generation === generation ? ok(source) : err("unavailable", "Provider directory generation changed during the read.", "after-reconnect");
+  };
+  const remember = (key, mapping) => {
+    if (mappings.size >= 512 && !mappings.has(key)) {
+      const oldest = mappings.keys().next().value;
+      if (oldest !== undefined)
+        mappings.delete(oldest);
+    }
+    mappings.set(key, mapping);
+  };
+  const profile = (source, record, revision) => {
+    if (!isRecord3(record) || !source.issuers.includes(record.issuer) || !idCodec("issuer").decode(record.issuer).ok || !idCodec("subject").decode(record.subject).ok || !isProfilePresentation(record.presentation) || record.status !== "current" && record.status !== "historical" || !idCodec("revision").decode(revision).ok)
+      return err("incompatible", "Provider directory record is malformed.");
+    const issuer = record.issuer;
+    const subject = record.subject;
+    if (typeof issuer !== "string" || typeof subject !== "string")
+      return err("incompatible", "Provider directory record is malformed.");
+    let person;
+    try {
+      person = asResult(source.person(issuer, subject));
+    } catch {
+      return err("unavailable", "Provider person normalization failed.", "after-reconnect");
+    }
+    if (!person.ok)
+      return person;
+    if (person.value.kind !== "person" || person.value.issuer !== record.issuer || person.value.subject !== record.subject || !identityKeyCodec.decode(person.value.key).ok) {
+      return err("incompatible", "Provider directory returned an invalid person reference.");
+    }
+    return profileCodec.decode({ identity: person.value, presentation: record.presentation, revision, status: record.status });
+  };
+  return {
+    async search(input, options) {
+      if (typeof input.query !== "string" || input.query.length > 512 || !Number.isInteger(input.limit) || input.limit < 1 || input.limit > 100 || !Array.isArray(input.kinds) || input.kinds.some((kind) => kind !== "person" && kind !== "default-user" && kind !== "machine" && kind !== "external") || input.history !== "current" && input.history !== "include-historical")
+        return err("invalid-input", "Invalid directory search request.");
+      const available = sources();
+      if (!available.ok)
+        return available;
+      const source = available.value[0];
+      if (!source || !source.directory || !input.kinds.includes("person"))
+        return err("unsupported", "Provider directory search is unavailable.");
+      let result;
+      try {
+        result = asResult(await source.directory(input, options));
+      } catch {
+        return err("unavailable", "Provider directory search failed.", "after-reconnect");
+      }
+      if (!result.ok)
+        return result;
+      const current = sameGeneration(source.generation);
+      if (!current.ok)
+        return current;
+      if (!Array.isArray(result.value.records) || result.value.records.length > input.limit || result.value.nextCursor !== null && !idCodec("cursor").decode(result.value.nextCursor).ok || !idCodec("revision").decode(result.value.revision).ok)
+        return err("incompatible", "Provider directory page is malformed.");
+      const profiles = [];
+      for (const record of result.value.records) {
+        const decoded = profile(current.value, record, result.value.revision);
+        if (!decoded.ok)
+          return decoded;
+        if (input.history === "current" && decoded.value.status !== "current")
+          return err("incompatible", "Provider directory returned historical data for a current query.");
+        if (decoded.value.identity.kind !== "person")
+          return err("incompatible", "Provider directory returned a non-person profile.");
+        remember(decoded.value.identity.key, { generation: current.value.generation, issuer: decoded.value.identity.issuer, subject: decoded.value.identity.subject });
+        profiles.push(decoded.value);
+      }
+      const nextCursor = result.value.nextCursor === null ? null : idCodec("cursor").decode(result.value.nextCursor);
+      const revision = idCodec("revision").decode(result.value.revision);
+      if (nextCursor !== null && !nextCursor.ok || !revision.ok)
+        return err("incompatible", "Provider directory page identifiers are malformed.");
+      return ok({ items: profiles, nextCursor: nextCursor === null ? null : nextCursor.value, revision: revision.value });
+    },
+    async getMany(input, options) {
+      if (!Array.isArray(input.keys) || input.keys.length > 64 || !input.keys.every((key) => identityKeyCodec.decode(key).ok))
+        return err("invalid-input", "Invalid profile lookup request.");
+      const available = sources();
+      if (!available.ok)
+        return available;
+      const source = available.value[0];
+      if (!source || !source.lookup)
+        return err("unsupported", "Provider directory lookup is unavailable.");
+      const selected = [];
+      for (const key of input.keys) {
+        const mapped = mappings.get(key);
+        if (mapped?.generation === source.generation) {
+          selected.push(mapped);
+          continue;
+        }
+        const decoded = decodeP6rPersonKey(key);
+        if (!decoded || !source.issuers.includes(decoded.issuer)) {
+          selected.push(undefined);
+          continue;
+        }
+        let person;
+        try {
+          person = asResult(source.person(decoded.issuer, decoded.subject));
+        } catch {
+          return err("unavailable", "Provider person normalization failed.", "after-reconnect");
+        }
+        if (!person.ok)
+          return person;
+        if (person.value.kind !== "person" || person.value.key !== key || person.value.issuer !== decoded.issuer || person.value.subject !== decoded.subject) {
+          return err("incompatible", "Provider directory rejected the canonical profile key.");
+        }
+        const entry = { generation: source.generation, issuer: decoded.issuer, subject: decoded.subject };
+        remember(key, entry);
+        selected.push(entry);
+      }
+      const unresolved = [...new Map(selected.filter((entry) => entry !== undefined).map((entry) => [JSON.stringify([entry.issuer, entry.subject]), entry])).values()];
+      if (unresolved.length === 0)
+        return ok(input.keys.map((key) => ({ key, status: "missing" })));
+      let result;
+      try {
+        result = asResult(await source.lookup(unresolved.map(({ issuer, subject }) => ({ issuer, subject })), options));
+      } catch {
+        return err("unavailable", "Provider directory lookup failed.", "after-reconnect");
+      }
+      if (!result.ok)
+        return result;
+      const current = sameGeneration(source.generation);
+      if (!current.ok)
+        return current;
+      if (!isRecord3(result.value) || !idCodec("revision").decode(result.value.revision).ok || !Array.isArray(result.value.records) || result.value.records.length !== unresolved.length)
+        return err("incompatible", "Provider profile lookup page is malformed.");
+      const found = new Map;
+      const seen = new Set;
+      for (const entry of result.value.records) {
+        if (!isRecord3(entry) || typeof entry.issuer !== "string" || typeof entry.subject !== "string")
+          return err("incompatible", "Provider profile lookup entry is malformed.");
+        const mapping = unresolved.find((candidate) => candidate.issuer === entry.issuer && candidate.subject === entry.subject);
+        if (!mapping || seen.has(`${entry.issuer}\x00${entry.subject}`))
+          return err("incompatible", "Provider profile lookup response is misaligned.");
+        seen.add(`${entry.issuer}\x00${entry.subject}`);
+        if (entry.record !== null) {
+          if (!isRecord3(entry.record) || entry.record.issuer !== entry.issuer || entry.record.subject !== entry.subject)
+            return err("incompatible", "Provider profile lookup identity does not match its requested subject.");
+          const decoded = profile(current.value, entry.record, result.value.revision);
+          if (!decoded.ok)
+            return decoded;
+          if (decoded.value.identity.kind !== "person")
+            return err("incompatible", "Provider lookup returned a non-person profile.");
+          remember(decoded.value.identity.key, { generation: current.value.generation, issuer: decoded.value.identity.issuer, subject: decoded.value.identity.subject });
+          found.set(`${entry.issuer}\x00${entry.subject}`, decoded.value);
+        }
+      }
+      return ok(input.keys.map((key, index) => {
+        const mapping = selected[index];
+        const profileValue = mapping === undefined ? undefined : found.get(`${mapping.issuer}\x00${mapping.subject}`);
+        return profileValue === undefined ? { key, status: "missing" } : { key, status: "found", profile: profileValue };
+      }));
+    },
+    subscribe: () => () => {}
+  };
+}
+function sameExpectation(session, expected) {
+  return session.actor.identity.key === expected.actor && session.stamp === expected.session ? ok(undefined) : err("stale-context", "The request actor or session changed.", "after-refresh");
+}
+function toLiveRequest(handle) {
+  const decoded = serverSessionCodec.decode(handle.session);
+  if (!decoded.ok)
+    return decoded;
+  const session = decoded.value;
+  if (session.status !== "ready")
+    return err("unauthenticated", "No ready identity session is available.", "after-refresh");
+  const request = {
+    signal: handle.signal,
+    session,
+    validate(expected) {
+      const local = sameExpectation(session, expected);
+      if (!local.ok)
+        return local;
+      return asResult(handle.validate(expected));
+    },
+    release: () => handle.release()
+  };
+  return ok(request);
+}
+function toForkRequest(handle) {
+  if (!isRecord3(handle.scope) || typeof handle.scope.release !== "function" || typeof handle.scope.validate !== "function" || !(handle.scope.signal instanceof AbortSignal)) {
+    return err("incompatible", "Host returned an invalid enhanced request scope.");
+  }
+  const request = toLiveRequest(handle);
+  return request.ok ? ok({ request: request.value, scope: handle.scope }) : request;
+}
+function normalizeRegistration(raw) {
+  const generation = idCodec("provider-generation").decode(raw.generation);
+  if (!generation.ok)
+    return err("incompatible", "Host returned an invalid provider generation.");
+  let disposed = false;
+  return ok({
+    generation: generation.value,
+    configuration: raw.configuration,
+    getStatus: () => raw.getStatus(),
+    signal: raw.signal,
+    subscribe: (listener) => raw.subscribe(listener),
+    invalidate: (change) => raw.invalidate(change),
+    person(issuer, subject) {
+      const result = asResult(raw.person(issuer, subject));
+      if (!result.ok)
+        return result;
+      if (result.value.kind === "default-user" || !identityKeyCodec.decode(result.value.key).ok || result.value.issuer !== issuer || result.value.subject !== subject) {
+        return err("incompatible", "Host returned an invalid provider person reference.");
+      }
+      return ok(result.value);
+    },
+    dispose() {
+      if (disposed)
+        return;
+      disposed = true;
+      raw.dispose();
+    }
+  });
+}
+function toForkProvider(provider) {
+  const validateReadiness = provider.validateReadiness;
+  const directory = provider.directory;
+  const lookup = provider.lookup;
+  return {
+    issuers: provider.issuers,
+    ...validateReadiness ? { validateReadiness: async (input) => {
+      const generation = idCodec("provider-generation").decode(input.generation);
+      if (!generation.ok)
+        return generation;
+      return validateReadiness({ ...input, generation: generation.value });
+    } } : {},
+    resolve: (evidence) => provider.resolve(evidence),
+    ...directory ? { directory: (input, options) => directory(input, options) } : {},
+    ...lookup ? { lookup: (subjects, options) => lookup(subjects, options) } : {}
+  };
+}
+function wireInput(input, codec) {
+  return {
+    ...input,
+    input: input.input.map((value) => codec.encode(value))
+  };
+}
+function protocolError(extension) {
+  if (extension.status === "unsupported-version")
+    return { code: "incompatible", message: `Unsupported identity protocol version ${extension.version}.`, retry: "never" };
+  if (extension.status === "malformed")
+    return extension.error;
+  return unavailable("The configured identity boundary is unavailable.");
+}
+function createHostAdapter(options) {
+  const { upstream, extension } = options;
+  const directory = options.directory ?? unsupportedDirectory();
+  const participants = unsupportedParticipants();
+  const history = unsupportedHistory();
+  const listeners = new Set;
+  let disposed = false;
+  const close = () => {
+    if (disposed)
+      return;
+    disposed = true;
+    for (const listener of listeners)
+      listener({ kind: "disposed" });
+    listeners.clear();
+  };
+  if (extension.status === "absent") {
+    const subscriptions = upstream.subscribe((event) => {
+      for (const listener of listeners)
+        listener(event);
+    });
+    const contexts = new WeakMap;
+    return {
+      pluginId: upstream.pluginId,
+      instanceId: upstream.instanceId,
+      session: (context) => upstream.session(context),
+      selfProfile: (context, readOptions) => upstream.selfProfile(context, readOptions),
+      async openPersonRequest(context) {
+        const raw = await upstream.openScope(context);
+        if (!raw.ok)
+          return raw;
+        const request = toLiveRequest(raw.value);
+        if (request.ok)
+          contexts.set(request.value, context);
+        return request;
+      },
+      readToolProvenance: async (context) => ok(upstream.toolCorrelation(context)),
+      directory,
+      participants,
+      history,
+      async send(request, input, readOptions) {
+        if (request.signal.aborted)
+          return { status: "rejected", error: { code: "expired", message: "The request context is no longer live.", retry: "never" } };
+        return upstream.submit(input, readOptions);
+      },
+      sendExternal: (author, input, readOptions) => upstream.submit({ ...input, input: upstream.labelExternal(author, input.input) }, readOptions),
+      lookupOperation: async () => ok({ status: "unknown", reason: "unsupported" }),
+      async forward(request, destinationPlugin, method, input) {
+        const context = contexts.get(request);
+        if (!context)
+          throw { code: "stale-context", message: "The request scope is no longer live.", retry: "after-refresh" };
+        return upstream.forward(context, destinationPlugin, method, input);
+      },
+      registerProvider: async () => err("unsupported", "Identity provider registration requires the enhanced host."),
+      subscribe(listener) {
+        listeners.add(listener);
+        return () => listeners.delete(listener);
+      },
+      dispose() {
+        subscriptions();
+        close();
+      }
+    };
+  }
+  if (extension.status !== "supported") {
+    const error = protocolError(extension);
+    const unavailableResult = async () => ({ ok: false, error });
+    return {
+      pluginId: upstream.pluginId,
+      instanceId: upstream.instanceId,
+      session: async () => ({ status: error.code === "incompatible" ? "incompatible" : "unavailable", instanceId: upstream.instanceId, error }),
+      selfProfile: unavailableResult,
+      openPersonRequest: unavailableResult,
+      readToolProvenance: unavailableResult,
+      directory,
+      participants,
+      history,
+      send: async () => ({ status: "rejected", error }),
+      sendExternal: async () => ({ status: "rejected", error }),
+      lookupOperation: unavailableResult,
+      forward: async () => {
+        throw error;
+      },
+      registerProvider: unavailableResult,
+      subscribe(listener) {
+        listeners.add(listener);
+        return () => listeners.delete(listener);
+      },
+      dispose: close
+    };
+  }
+  const protocol = extension.protocol;
+  const enhancedDirectory = createEnhancedDirectory(protocol);
+  const enhancedParticipants = {
+    async list(input, readOptions) {
+      if (!Number.isInteger(input.limit) || input.limit < 1 || input.limit > 100 || !idCodec("thread").decode(input.threadId).ok || input.cursor !== undefined && !idCodec("cursor").decode(input.cursor).ok)
+        return err("invalid-input", "Invalid participant request.");
+      if (disposed)
+        return err("disposed", "Identity host is disposed.");
+      let result;
+      try {
+        result = asResult(await protocol.participants(input, readOptions));
+      } catch {
+        return err("unavailable", "Participant history is unavailable.", "after-reconnect");
+      }
+      return result.ok ? decodeParticipantPage(result.value) : result;
+    },
+    previews: async () => err("unsupported", "Participant previews are unavailable from this enhanced protocol.")
+  };
+  const enhancedHistory = {
+    async contributions(query, readOptions) {
+      if (!validContributionQuery(query))
+        return err("invalid-input", "Invalid contribution history request.");
+      if (disposed)
+        return err("disposed", "Identity host is disposed.");
+      let result;
+      try {
+        result = asResult(await protocol.historyContributions(query, readOptions));
+      } catch {
+        return err("unavailable", "Contribution history is unavailable.", "after-reconnect");
+      }
+      return result.ok ? decodeEvidencePage(result.value, isContribution2) : result;
+    },
+    async attempts(query, readOptions) {
+      if (!validAttemptQuery(query))
+        return err("invalid-input", "Invalid execution history request.");
+      if (disposed)
+        return err("disposed", "Identity host is disposed.");
+      let result;
+      try {
+        result = asResult(await protocol.historyAttempts(query, readOptions));
+      } catch {
+        return err("unavailable", "Execution history is unavailable.", "after-reconnect");
+      }
+      return result.ok ? decodeEvidencePage(result.value, (item) => provenanceCodec.decode(item).ok) : result;
+    }
+  };
+  const subscription = protocol.subscribe((event) => {
+    for (const listener of listeners)
+      listener(event);
+  });
+  const scopes = new WeakMap;
+  return {
+    pluginId: upstream.pluginId,
+    instanceId: protocol.instanceId,
+    async session(context) {
+      const decoded = serverSessionCodec.decode(await protocol.session(context));
+      if (!decoded.ok)
+        return { status: "incompatible", instanceId: protocol.instanceId, error: decoded.error };
+      return decoded.value.instanceId === protocol.instanceId ? decoded.value : { status: "incompatible", instanceId: protocol.instanceId, error: { code: "incompatible", message: "Enhanced ready session instance does not match persisted host instance.", retry: "never" } };
+    },
+    async selfProfile(context, readOptions) {
+      const result = asResult(await protocol.selfProfile(context, readOptions));
+      if (!result.ok)
+        return result;
+      return profileCodec.decode(result.value);
+    },
+    async openPersonRequest(context) {
+      const raw = await protocol.openRequest(context);
+      if (!raw.ok)
+        return raw;
+      const enhanced = toForkRequest(raw.value);
+      if (!enhanced.ok) {
+        raw.value.release();
+        return enhanced;
+      }
+      if (enhanced.value.request.session.instanceId !== protocol.instanceId) {
+        raw.value.release();
+        return err("incompatible", "Enhanced request instance does not match persisted host instance.");
+      }
+      scopes.set(enhanced.value.request, enhanced.value.scope);
+      return ok(enhanced.value.request);
+    },
+    async readToolProvenance(context) {
+      const result = asResult(await protocol.provenance(context));
+      return result.ok ? provenanceCodec.decode(result.value) : result;
+    },
+    directory: {
+      search: (input, readOptions) => disposed ? Promise.resolve(err("disposed", "Identity host is disposed.")) : enhancedDirectory.search(input, readOptions),
+      getMany: (input, readOptions) => disposed ? Promise.resolve(err("disposed", "Identity host is disposed.")) : enhancedDirectory.getMany(input, readOptions),
+      subscribe: enhancedDirectory.subscribe
+    },
+    participants: enhancedParticipants,
+    history: enhancedHistory,
+    async send(request, input, readOptions) {
+      const scope = scopes.get(request);
+      if (!scope)
+        return { status: "rejected", error: { code: "stale-context", message: "The request scope is no longer live.", retry: "after-refresh" } };
+      const result = decodeAcceptance(await protocol.accept({ source: { kind: "scope", scope }, input: wireInput(input, upstream.inputCodec) }, readOptions));
+      return result.ok ? result.value : { status: "rejected", error: result.error };
+    },
+    async sendExternal(author, input, readOptions) {
+      if (disposed)
+        return { status: "rejected", error: { code: "disposed", message: "Identity host is disposed.", retry: "never" } };
+      const result = decodeAcceptance(await protocol.accept({ source: { kind: "external", author }, input: wireInput(input, upstream.inputCodec) }, readOptions));
+      return result.ok ? result.value : { status: "rejected", error: result.error };
+    },
+    async lookupOperation(operationId, readOptions) {
+      const result = asResult(await protocol.lookup(operationId, readOptions));
+      return result.ok ? decodeLookup(result.value) : result;
+    },
+    async forward(request, destinationPlugin, method, input) {
+      const scope = scopes.get(request);
+      if (!scope)
+        throw { code: "stale-context", message: "The request scope is no longer live.", retry: "after-refresh" };
+      return protocol.forwardRpc(scope, { pluginId: destinationPlugin, method }, input);
+    },
+    async registerProvider(provider) {
+      if (disposed)
+        return err("disposed", "Identity host is disposed.");
+      const result = await protocol.registerProvider(toForkProvider(provider));
+      if (!result.ok)
+        return result;
+      if (disposed) {
+        result.value.dispose();
+        return err("disposed", "Identity host is disposed.");
+      }
+      return normalizeRegistration(result.value);
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    dispose() {
+      subscription();
+      close();
+    }
+  };
+}
+function inspectForkExtension(value) {
+  if (value === undefined)
+    return { status: "absent" };
+  if (!isRecord3(value) || value.version !== 1 || !idCodec("instance").decode(value.instanceId).ok || typeof value.bindInvocation !== "function" || typeof value.session !== "function" || typeof value.openRequest !== "function" || typeof value.selfProfile !== "function" || typeof value.accept !== "function" || typeof value.lookup !== "function" || typeof value.provenance !== "function" || typeof value.historyContributions !== "function" || typeof value.historyAttempts !== "function" || typeof value.directorySources !== "function" || typeof value.participants !== "function" || typeof value.forwardRpc !== "function" || typeof value.registerProvider !== "function" || typeof value.subscribe !== "function") {
+    const version = isRecord3(value) && typeof value.version === "number" ? value.version : null;
+    return version === null ? { status: "malformed", error: { code: "incompatible", message: "Malformed experimental_p6rIdentity extension.", retry: "never" } } : { status: "unsupported-version", version };
+  }
+  return { status: "supported", protocol: value };
+}
+
+// server-runtime.ts
+function sameExpectation2(actor, stamp, expectedActor, expectedStamp) {
+  return actor === expectedActor && stamp === expectedStamp ? ok(undefined) : err("stale-context", "The request actor or session changed.", "after-refresh");
+}
+function isPerson(value) {
+  return value.kind === "person" || value.kind === "default-user";
+}
+function freezePerson(input) {
+  return input.kind === "person" ? Object.freeze({ kind: "person", key: input.key, issuer: input.issuer, subject: input.subject }) : Object.freeze({ kind: "default-user", key: input.key, instanceId: input.instanceId });
+}
+function freezeActorReference(input) {
+  return input.kind === "machine" ? Object.freeze({ kind: "machine", key: input.key, instanceId: input.instanceId, hostId: input.hostId }) : freezePerson(input);
+}
+function freezeActor(input) {
+  return Object.freeze({
+    identity: freezeActorReference(input.identity),
+    presentation: Object.freeze({
+      displayName: input.presentation.displayName,
+      handle: input.presentation.handle,
+      avatarUrl: input.presentation.avatarUrl
+    }),
+    evidence: input.evidence
+  });
+}
+function freezeExpected(input) {
+  return Object.freeze({ actor: input.actor, session: input.session });
+}
+function createIdentityServer(options) {
+  const { host } = options;
+  let disposed = false;
+  const dispose = () => {
+    disposed = true;
+  };
+  const commits = {
+    boundary: "same-process-synchronous",
+    validate(target, scope) {
+      if (typeof target !== "object" || target === null || target.intent !== "write" || typeof target.snapshot !== "function" || !(target.signal instanceof AbortSignal)) {
+        return err("invalid-input", "Write target does not have write intent.");
+      }
+      if (disposed || target.signal.aborted)
+        return err("expired", "The request context is no longer live.");
+      const addressIsConcrete = scope.collection.length > 0 && scope.recordId.length > 0 && Number.isInteger(scope.schemaVersion) && scope.schemaVersion >= 0;
+      try {
+        const snapshot = target.snapshot();
+        const capturedActor = snapshot.actor.identity.key;
+        const capturedSubject = snapshot.subject.key;
+        const capturedExpected = snapshot.expected;
+        const capturedFactsAreConsistent = capturedExpected.actor === capturedActor;
+        return addressIsConcrete && scope.instanceId === host.instanceId && scope.pluginId === host.pluginId && capturedFactsAreConsistent && scope.subject === capturedSubject && scope.expected.actor === capturedExpected.actor && scope.expected.session === capturedExpected.session ? ok(undefined) : err("stale-context", "Target does not match this live commit scope.", "after-refresh");
+      } catch {
+        return err("invalid-input", "Write target snapshot is unavailable.");
+      }
+    }
+  };
+  async function issueTarget(live, request, input) {
+    if (request.signal.aborted)
+      return err("expired", "The request context is no longer live.");
+    const currentRequest = live.validate(request.expected);
+    if (!currentRequest.ok)
+      return currentRequest;
+    const actor = freezeActor(request.actor);
+    let subject = freezeActorReference(actor.identity);
+    if (input.selection.kind === "person") {
+      if (input.policy.kind === "self-only")
+        return err("unsupported", "This operation only supports the acting person.");
+      const profiles = await host.directory.getMany({ keys: [input.selection.key] });
+      if (!profiles.ok)
+        return profiles;
+      const found = profiles.value[0];
+      if (!found || found.status !== "found" || !isPerson(found.profile.identity))
+        return err("not-found", "Selected person was not found.");
+      subject = freezePerson(found.profile.identity);
+    }
+    if (input.intent === "write") {
+      const current = sameExpectation2(request.actor.identity.key, request.expected.session, input.expected.actor, input.expected.session);
+      if (!current.ok)
+        return current;
+      if (input.expectedSubject !== subject.key)
+        return err("stale-owner", "Selected subject changed.", "after-refresh");
+    }
+    const expected = freezeExpected({ actor: actor.identity.key, session: request.expected.session });
+    const snapshot = Object.freeze({
+      actor,
+      subject,
+      expected
+    });
+    const target = Object.freeze({
+      intent: input.intent,
+      snapshot: () => snapshot,
+      signal: request.signal
+    });
+    return ok(target);
+  }
+  const server = {
+    instanceId: host.instanceId,
+    directory: host.directory,
+    participants: host.participants,
+    history: host.history,
+    commits,
+    session: (context, readOptions) => host.session(context, readOptions),
+    selfProfile: (context, readOptions) => host.selfProfile(context, readOptions),
+    subscribe: (listener) => host.subscribe(listener),
+    async personRequest(context, readOptions) {
+      if (disposed)
+        return err("disposed", "Identity server is disposed.");
+      const opened = await host.openPersonRequest(context, readOptions);
+      if (!opened.ok)
+        return opened;
+      const live = opened.value;
+      let released = false;
+      let request;
+      async function target(input) {
+        return issueTarget(live, request, input);
+      }
+      request = {
+        actor: live.session.actor,
+        expected: { actor: live.session.actor.identity.key, session: live.session.stamp },
+        capabilities: live.session.capabilities,
+        signal: live.signal,
+        target,
+        async send(input, sendOptions) {
+          const valid = live.validate(input.expected);
+          if (!valid.ok)
+            return { status: "rejected", error: valid.error };
+          return host.send(live, input, sendOptions);
+        },
+        async callPlugin(input, callOptions) {
+          const valid = live.validate(request.expected);
+          if (!valid.ok)
+            return valid;
+          try {
+            return input.output.decode(await host.forward(live, input.pluginId, input.method, input.payload));
+          } catch {
+            return err("unavailable", "Destination plugin call failed.", callOptions?.signal?.aborted ? "never" : "after-reconnect");
+          }
+        },
+        dispose() {
+          if (released)
+            return;
+          released = true;
+          live.release();
+        }
+      };
+      return ok(request);
+    },
+    toolProvenance: (context) => disposed ? Promise.resolve(err("disposed", "Identity server is disposed.")) : host.readToolProvenance(context),
+    sendExternal: (author, input, readOptions) => disposed ? Promise.resolve({ status: "rejected", error: { code: "disposed", message: "Identity server is disposed.", retry: "never" } }) : host.sendExternal(author, input, readOptions),
+    lookupOperation: (operationId, readOptions) => disposed ? Promise.resolve(err("disposed", "Identity server is disposed.")) : host.lookupOperation(operationId, readOptions),
+    dispose
+  };
+  return server;
+}
+function createIdentityEndpoint(options) {
+  let disposed = false;
+  let stop = null;
+  const dispose = () => {
+    disposed = true;
+    const unsubscribe = stop;
+    stop = null;
+    unsubscribe?.();
+  };
+  const subscribed = options.server.subscribe((event) => {
+    if (disposed)
+      return;
+    try {
+      if (event.kind === "directory") {
+        const keys = event.keys.map((key) => identityKeyCodec.decode(key));
+        options.publish({ kind: "directory", keys: keys.every((key) => key.ok) ? keys.map((key) => key.value) : [], revision: null });
+      } else if (event.kind === "participants") {
+        const ids = event.threadIds.map((id) => idCodec("thread").decode(id));
+        if (ids.every((id) => id.ok))
+          options.publish({ kind: "participants", threadIds: ids.map((id) => id.value) });
+      } else if (event.kind === "session")
+        options.publish(event.reason === undefined ? { kind: "session" } : { kind: "session", reason: event.reason });
+      else if (event.kind === "reconnected" || event.kind === "disconnected")
+        options.publish({ kind: event.kind });
+      else if (event.kind === "disposed") {
+        dispose();
+        options.publish({ kind: "disconnected" });
+      }
+    } catch {}
+  });
+  if (disposed)
+    subscribed();
+  else
+    stop = subscribed;
+  const reject = () => Promise.resolve(err("disposed", "Identity endpoint is disposed."));
+  const fence = async (work) => {
+    try {
+      const result = await work;
+      return disposed ? err("disposed", "Identity endpoint is disposed.") : result;
+    } catch {
+      return err(disposed ? "disposed" : "unavailable", disposed ? "Identity endpoint is disposed." : "Identity endpoint read failed.");
+    }
+  };
+  return {
+    bootstrap(context, readOptions) {
+      return disposed ? reject() : fence(options.server.session(context, readOptions).then(ok));
+    },
+    selfProfile(context, readOptions) {
+      return disposed ? reject() : fence(options.server.selfProfile(context, readOptions));
+    },
+    search(context, input, readOptions) {
+      return disposed ? reject() : fence(options.server.directory.search(input, readOptions));
+    },
+    profiles(context, input, readOptions) {
+      return disposed ? reject() : fence(options.server.directory.getMany(input, readOptions));
+    },
+    participants(context, input, readOptions) {
+      return disposed ? reject() : fence(options.server.participants.list(input, readOptions));
+    },
+    participantPreviews(context, input, readOptions) {
+      return disposed ? reject() : fence(options.server.participants.previews(input, readOptions));
+    },
+    dispose
+  };
+}
+
+// state-service-runtime.ts
+function isRecord4(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function nonEmpty(value) {
+  return typeof value === "string" && value.length > 0;
+}
+function decodeAddress(value) {
+  if (!isRecord4(value) || !nonEmpty(value.collection) || !nonEmpty(value.recordId))
+    return err("invalid-input", "Invalid state address.");
+  const instanceId = idCodec("instance").decode(value.instanceId);
+  const pluginId = idCodec("plugin").decode(value.pluginId);
+  const owner = identityKeyCodec.decode(value.owner);
+  return instanceId.ok && pluginId.ok && owner.ok ? ok({ instanceId: instanceId.value, pluginId: pluginId.value, collection: value.collection, recordId: value.recordId, owner: owner.value }) : err("invalid-input", "Invalid state address identifiers.");
+}
+function decodeVersion(value) {
+  return isRecord4(value) && nonEmpty(value.epoch) && typeof value.sequence === "number" && Number.isInteger(value.sequence) && value.sequence >= 0 ? ok({ epoch: value.epoch, sequence: value.sequence }) : err("invalid-input", "Invalid state version.");
+}
+function decodeActor(value) {
+  if (value === null)
+    return ok(null);
+  if (!isRecord4(value) || !isRecord4(value.identity) || !isRecord4(value.presentation) || !nonEmpty(value.presentation.displayName) || value.presentation.handle !== null && typeof value.presentation.handle !== "string" || value.presentation.avatarUrl !== null && typeof value.presentation.avatarUrl !== "string" || !["provider-verified", "local-user", "upstream-default", "integration-asserted", "legacy", "machine"].includes(value.evidence)) {
+    return err("invalid-input", "Invalid state editor snapshot.");
+  }
+  const key = identityKeyCodec.decode(value.identity.key);
+  if (!key.ok)
+    return key;
+  const identity = value.identity;
+  const presentation = { displayName: value.presentation.displayName, handle: value.presentation.handle, avatarUrl: value.presentation.avatarUrl };
+  if (identity.kind === "machine") {
+    const instanceId = idCodec("instance").decode(identity.instanceId);
+    if (!instanceId.ok || value.evidence !== "machine" || identity.hostId !== null && (typeof identity.hostId !== "string" || identity.hostId.length === 0 || identity.hostId.length > 512)) {
+      return err("invalid-input", "Invalid machine editor identity.");
+    }
+    return ok({ identity: { kind: "machine", key: key.value, instanceId: instanceId.value, hostId: identity.hostId }, presentation, evidence: "machine" });
+  }
+  if (value.evidence === "machine")
+    return err("invalid-input", "Machine evidence requires a machine identity.");
+  if (identity.kind === "person" && nonEmpty(identity.issuer) && nonEmpty(identity.subject)) {
+    return ok({ identity: { kind: "person", key: key.value, issuer: identity.issuer, subject: identity.subject }, presentation, evidence: value.evidence });
+  }
+  if (identity.kind === "default-user") {
+    const instanceId = idCodec("instance").decode(identity.instanceId);
+    return instanceId.ok ? ok({ identity: { kind: "default-user", key: key.value, instanceId: instanceId.value }, presentation, evidence: value.evidence }) : instanceId;
+  }
+  if (identity.kind === "external") {
+    const pluginId = idCodec("plugin").decode(identity.pluginId);
+    return pluginId.ok && nonEmpty(identity.subject) ? ok({ identity: { kind: "external", key: key.value, pluginId: pluginId.value, subject: identity.subject }, presentation, evidence: value.evidence }) : err("invalid-input", "Invalid external editor identity.");
+  }
+  return err("invalid-input", "Invalid editor identity.");
+}
+function sameAddress(left, right) {
+  return left.instanceId === right.instanceId && left.pluginId === right.pluginId && left.collection === right.collection && left.recordId === right.recordId && left.owner === right.owner;
+}
+function decodeEnvelope(value, codec) {
+  if (!isRecord4(value) || typeof value.schemaVersion !== "number" || !Number.isInteger(value.schemaVersion) || value.schemaVersion < 0) {
+    return err("invalid-input", "Invalid state envelope.");
+  }
+  const address = decodeAddress(value.address);
+  const version = decodeVersion(value.version);
+  const decoded = codec.decode(value.value);
+  const editor = decodeActor(value.lastEditedBy);
+  return address.ok && version.ok && decoded.ok && editor.ok ? ok({ address: address.value, version: version.value, schemaVersion: value.schemaVersion, value: decoded.value, lastEditedBy: editor.value }) : err("invalid-input", "Invalid state envelope fields.");
+}
+function decodeRead(value, codec) {
+  if (!isRecord4(value) || typeof value.status !== "string")
+    return err("invalid-input", "Invalid state read.");
+  if (value.status === "present") {
+    const envelope = decodeEnvelope(value.envelope, codec);
+    return envelope.ok ? ok({ status: "present", envelope: envelope.value }) : envelope;
+  }
+  if (value.status === "empty") {
+    const address = decodeAddress(value.address);
+    const version = decodeVersion(value.version);
+    return address.ok && version.ok ? ok({ status: "empty", address: address.value, version: version.value }) : err("invalid-input", "Invalid empty state read.");
+  }
+  if (value.status === "migration-required") {
+    const address = decodeAddress(value.address);
+    return address.ok && typeof value.storedSchemaVersion === "number" && Number.isInteger(value.storedSchemaVersion) && value.storedSchemaVersion >= 0 ? ok({ status: "migration-required", address: address.value, storedSchemaVersion: value.storedSchemaVersion }) : err("invalid-input", "Invalid migration-required read.");
+  }
+  return err("invalid-input", "Unknown state read status.");
+}
+function decodeMutation(value, codec) {
+  if (!isRecord4(value) || value.kind !== "initialize" && value.kind !== "replace" || !isRecord4(value.expected) || typeof value.schemaVersion !== "number" || !Number.isInteger(value.schemaVersion) || value.schemaVersion < 0 || typeof value.localGeneration !== "number" || !Number.isInteger(value.localGeneration) || value.localGeneration < 0) {
+    return err("invalid-input", "Invalid state mutation.");
+  }
+  const address = decodeAddress(value.address);
+  const expectedVersion = decodeVersion(value.expectedVersion);
+  const actor = identityKeyCodec.decode(value.expected.actor);
+  const session = idCodec("server-session").decode(value.expected.session);
+  const ownerSession = idCodec("owner-session").decode(value.ownerSession);
+  const operationId = idCodec("operation").decode(value.operationId);
+  const decoded = codec.decode(value.value);
+  return address.ok && expectedVersion.ok && actor.ok && session.ok && ownerSession.ok && operationId.ok && decoded.ok ? ok({
+    kind: value.kind,
+    address: address.value,
+    expectedVersion: expectedVersion.value,
+    expected: { actor: actor.value, session: session.value },
+    ownerSession: ownerSession.value,
+    localGeneration: value.localGeneration,
+    operationId: operationId.value,
+    schemaVersion: value.schemaVersion,
+    value: decoded.value
+  }) : err("invalid-input", "Invalid state mutation fields.");
+}
+function freezeDeep(value) {
+  if (value && typeof value === "object" && !Object.isFrozen(value)) {
+    for (const child of Object.values(value))
+      freezeDeep(child);
+    Object.freeze(value);
+  }
+  return value;
+}
+function cloneTyped(input, codec) {
+  try {
+    return codec.decode(structuredClone(codec.encode(input)));
+  } catch {
+    return err("invalid-input", "State value could not be encoded.");
+  }
+}
+function immutableMutation(input, codec) {
+  const decoded = cloneTyped(input, stateCodecs(codec).mutation);
+  return decoded.ok ? ok(freezeDeep(decoded.value)) : decoded;
+}
+function decodeOutcome(value, codec) {
+  if (!isRecord4(value) || typeof value.status !== "string")
+    return err("invalid-input", "Invalid state outcome.");
+  const operationId = idCodec("operation").decode(value.operationId);
+  if (!operationId.ok)
+    return operationId;
+  if (value.status === "saved" || value.status === "unchanged") {
+    const envelope = decodeEnvelope(value.envelope, codec);
+    return envelope.ok ? ok({ status: value.status, envelope: envelope.value, operationId: operationId.value }) : envelope;
+  }
+  if (value.status === "already-initialized" || value.status === "conflict") {
+    const current = decodeRead(value.current, codec);
+    return current.ok ? ok({ status: value.status, current: current.value, operationId: operationId.value }) : current;
+  }
+  return err("invalid-input", "Unknown state outcome status.");
+}
+function decodeSave(value, codec) {
+  if (isRecord4(value) && value.status === "indeterminate") {
+    const operationId = idCodec("operation").decode(value.operationId);
+    return operationId.ok ? ok({ status: "indeterminate", operationId: operationId.value }) : operationId;
+  }
+  return decodeOutcome(value, codec);
+}
+function assertRead(read, address, schemaVersion) {
+  const actual = read.status === "present" ? read.envelope.address : read.address;
+  if (!sameAddress(actual, address))
+    return err("incompatible", "Storage returned a state record for a different address.");
+  if (read.status === "present" && read.envelope.schemaVersion !== schemaVersion) {
+    return err("incompatible", "Storage returned an unexpected state schema.");
+  }
+  return ok(read);
+}
+function assertOutcome(outcome, address, schemaVersion, operationId) {
+  if (outcome.operationId !== operationId)
+    return err("incompatible", "Storage returned an outcome for a different operation.");
+  const read = "envelope" in outcome ? { status: "present", envelope: outcome.envelope } : outcome.current;
+  const checked = assertRead(read, address, schemaVersion);
+  return checked.ok ? ok(outcome) : checked;
+}
+function assertSave(save, address, schemaVersion, operationId) {
+  if (save.status === "indeterminate")
+    return save.operationId === operationId ? ok(save) : err("incompatible", "Storage returned an indeterminate result for a different operation.");
+  return assertOutcome(save, address, schemaVersion, operationId);
+}
+function addressFor(target, recordId, resource, instanceId) {
+  if (!nonEmpty(recordId))
+    return err("invalid-input", "State record id is required.");
+  const snapshot = target.snapshot();
+  return ok({ instanceId, pluginId: resource.pluginId, collection: resource.definition.collection, recordId, owner: snapshot.subject.key });
+}
+function createStateService(options) {
+  const resource = { pluginId: options.pluginId, definition: options.definition };
+  const codecs = stateCodecs(options.definition.codec);
+  const staticMutation = (target, mutation) => {
+    const expected = addressFor(target, mutation.address.recordId, resource, options.instanceId);
+    if (!expected.ok)
+      return expected;
+    const snapshot = target.snapshot();
+    return sameAddress(mutation.address, expected.value) && mutation.schemaVersion === options.definition.schemaVersion && mutation.expected.actor === snapshot.expected.actor && mutation.expected.session === snapshot.expected.session ? ok(undefined) : err("invalid-input", "Mutation does not match this state resource and target.");
+  };
+  return {
+    async read(target, recordId, readOptions) {
+      if (target.signal.aborted)
+        return err("expired", "The request context is no longer live.");
+      const address = addressFor(target, recordId, resource, options.instanceId);
+      if (!address.ok)
+        return address;
+      const result = await options.storage.read(address.value, readOptions);
+      if (!result.ok)
+        return result;
+      const decoded = cloneTyped(result.value, codecs.read);
+      return decoded.ok ? assertRead(decoded.value, address.value, options.definition.schemaVersion) : decoded;
+    },
+    async save(target, mutation, readOptions) {
+      const submitted = immutableMutation(mutation, options.definition.codec);
+      if (!submitted.ok)
+        return submitted;
+      const valid = staticMutation(target, submitted.value);
+      if (!valid.ok)
+        return valid;
+      const targetSnapshot = target.snapshot();
+      const expected = Object.freeze({ actor: targetSnapshot.expected.actor, session: targetSnapshot.expected.session });
+      const subject = targetSnapshot.subject.key;
+      const editor = freezeDeep({
+        identity: { ...targetSnapshot.actor.identity },
+        presentation: { ...targetSnapshot.actor.presentation },
+        evidence: targetSnapshot.actor.evidence
+      });
+      const committed = await options.storage.commit({
+        mutation: submitted.value,
+        validateAtCommit: () => {
+          if (readOptions?.signal?.aborted)
+            return err("cancelled", "State save was cancelled before durable acceptance.");
+          const scope = {
+            instanceId: options.instanceId,
+            pluginId: options.pluginId,
+            collection: options.definition.collection,
+            recordId: submitted.value.address.recordId,
+            subject,
+            expected,
+            schemaVersion: options.definition.schemaVersion
+          };
+          const live = options.commits.validate(target, scope);
+          return live.ok ? ok(editor) : live;
+        }
+      });
+      if (!committed.ok)
+        return committed;
+      const decoded = cloneTyped(committed.value, codecs.save);
+      if (!decoded.ok)
+        return decoded;
+      const checked = assertSave(decoded.value, submitted.value.address, options.definition.schemaVersion, submitted.value.operationId);
+      if (!checked.ok)
+        return checked;
+      const outcome = checked.value;
+      const publishedEnvelope = outcome.status === "saved" ? outcome.envelope : outcome.status === "already-initialized" && outcome.current.status === "present" ? outcome.current.envelope : null;
+      if (publishedEnvelope) {
+        try {
+          options.publish({ address: publishedEnvelope.address, version: publishedEnvelope.version, operationId: outcome.operationId });
+        } catch {}
+      }
+      return ok(outcome);
+    },
+    async reconcile(target, recordId, operationId) {
+      const address = addressFor(target, recordId, resource, options.instanceId);
+      if (!address.ok)
+        return address;
+      const result = await options.storage.reconcile({ address: address.value, operationId });
+      if (!result.ok)
+        return result;
+      const decoded = cloneTyped(result.value, codecs.lookup);
+      if (!decoded.ok || decoded.value.status !== "final")
+        return decoded;
+      const checked = assertOutcome(decoded.value.outcome, address.value, options.definition.schemaVersion, operationId);
+      return checked.ok ? ok({ status: "final", outcome: checked.value }) : checked;
+    }
+  };
+}
+function decodeLookup2(value, codec) {
+  if (!isRecord4(value) || typeof value.status !== "string")
+    return err("invalid-input", "Invalid state lookup.");
+  if (value.status === "final") {
+    const outcome = decodeOutcome(value.outcome, codec);
+    return outcome.ok ? ok({ status: "final", outcome: outcome.value }) : outcome;
+  }
+  if (value.status === "pending")
+    return ok({ status: "pending" });
+  if (value.status === "absent-final" && value.retry === "same-operation-only")
+    return ok({ status: "absent-final", retry: "same-operation-only" });
+  if (value.status === "unknown" && (value.reason === "unsupported" || value.reason === "expired" || value.reason === "unavailable"))
+    return ok({ status: "unknown", reason: value.reason });
+  return err("invalid-input", "Invalid state lookup metadata.");
+}
+function encodeAddress(address) {
+  return { instanceId: address.instanceId, pluginId: address.pluginId, collection: address.collection, recordId: address.recordId, owner: address.owner };
+}
+function encodeVersion(version) {
+  return { epoch: version.epoch, sequence: version.sequence };
+}
+function encodeActor(actor) {
+  return actor === null ? null : { identity: actor.identity, presentation: actor.presentation, evidence: actor.evidence };
+}
+function encodeEnvelope(envelope, codec) {
+  return { address: encodeAddress(envelope.address), version: encodeVersion(envelope.version), schemaVersion: envelope.schemaVersion, value: codec.encode(envelope.value), lastEditedBy: encodeActor(envelope.lastEditedBy) };
+}
+function encodeRead(read, codec) {
+  return read.status === "present" ? { status: "present", envelope: encodeEnvelope(read.envelope, codec) } : read.status === "empty" ? { status: "empty", address: encodeAddress(read.address), version: encodeVersion(read.version) } : read.status === "migration-required" ? { status: "migration-required", address: encodeAddress(read.address), storedSchemaVersion: read.storedSchemaVersion } : (() => {
+    throw new TypeError("Invalid state read status.");
+  })();
+}
+function encodeMutation(mutation, codec) {
+  return { ...mutation, address: encodeAddress(mutation.address), expectedVersion: encodeVersion(mutation.expectedVersion), value: codec.encode(mutation.value) };
+}
+function encodeOutcome(outcome, codec) {
+  if (outcome.status === "saved" || outcome.status === "unchanged") {
+    return { status: outcome.status, envelope: encodeEnvelope(outcome.envelope, codec), operationId: outcome.operationId };
+  }
+  if ("current" in outcome)
+    return { status: outcome.status, current: encodeRead(outcome.current, codec), operationId: outcome.operationId };
+  throw new TypeError("Invalid state outcome.");
+}
+function encodeSave(save, codec) {
+  return save.status === "indeterminate" ? { status: "indeterminate", operationId: save.operationId } : encodeOutcome(save, codec);
+}
+function stateCodecs(value) {
+  return {
+    read: { decode: (input) => decodeRead(input, value), encode: (input) => encodeRead(input, value) },
+    mutation: { decode: (input) => decodeMutation(input, value), encode: (input) => encodeMutation(input, value) },
+    save: { decode: (input) => decodeSave(input, value), encode: (input) => encodeSave(input, value) },
+    invalidation: {
+      decode(input) {
+        if (!isRecord4(input))
+          return err("invalid-input", "Invalid state invalidation.");
+        const address = decodeAddress(input.address);
+        const version = decodeVersion(input.version);
+        const operationId = input.operationId === null ? ok(null) : idCodec("operation").decode(input.operationId);
+        return address.ok && version.ok && operationId.ok ? ok({ address: address.value, version: version.value, operationId: operationId.value }) : err("invalid-input", "Invalid state invalidation fields.");
+      },
+      encode: (input) => ({ address: encodeAddress(input.address), version: encodeVersion(input.version), operationId: input.operationId })
+    },
+    lookup: {
+      decode: (input) => decodeLookup2(input, value),
+      encode: (input) => input.status === "final" ? { status: "final", outcome: encodeOutcome(input.outcome, value) } : input
+    }
+  };
+}
+
+// rpc-routes-runtime.ts
+var identityRoutes = Object.freeze({
+  bootstrap: "bb-identity/v1/bootstrap",
+  selfProfile: "bb-identity/v1/selfProfile",
+  search: "bb-identity/v1/search",
+  profiles: "bb-identity/v1/profiles",
+  participants: "bb-identity/v1/participants",
+  participantPreviews: "bb-identity/v1/participantPreviews"
+});
+var identityStateRoutes = Object.freeze({
+  load: "bb-identity/v1/state/load",
+  save: "bb-identity/v1/state/save",
+  reconcile: "bb-identity/v1/state/reconcile"
+});
+var identityStateRpcMethods = Object.freeze({
+  [identityStateRoutes.load]: "bb-identity.v1.state.load",
+  [identityStateRoutes.save]: "bb-identity.v1.state.save",
+  [identityStateRoutes.reconcile]: "bb-identity.v1.state.reconcile"
+});
+var identityRpcMethods = Object.freeze({
+  [identityRoutes.bootstrap]: "bb-identity.v1.bootstrap",
+  [identityRoutes.selfProfile]: "bb-identity.v1.selfProfile",
+  [identityRoutes.search]: "bb-identity.v1.search",
+  [identityRoutes.profiles]: "bb-identity.v1.profiles",
+  [identityRoutes.participants]: "bb-identity.v1.participants",
+  [identityRoutes.participantPreviews]: "bb-identity.v1.participantPreviews",
+  ...identityStateRpcMethods
+});
+
+// state-rpc-runtime.ts
+var methods = {
+  load: identityStateRpcMethods[identityStateRoutes.load],
+  save: identityStateRpcMethods[identityStateRoutes.save],
+  reconcile: identityStateRpcMethods[identityStateRoutes.reconcile]
+};
+var inputSchema = { "~standard": { version: 1, vendor: "bb-identity", validate: (value) => ({ value }) } };
+function isJson2(value) {
+  return value === null || typeof value === "string" || typeof value === "boolean" || typeof value === "number" && Number.isFinite(value) || Array.isArray(value) && value.every(isJson2) || isRecord5(value) && Object.values(value).every(isJson2);
+}
+var outputSchema = { "~standard": { version: 1, vendor: "bb-identity", validate: (value) => isJson2(value) ? { value } : { issues: [{ message: "Expected an encoded identity state result." }] } } };
+function isRecord5(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function decodeRequest(input) {
+  if (!isRecord5(input) || !isRecord5(input.address) || !isRecord5(input.expected))
+    return err("invalid-input", "State request requires an address and expected session.");
+  const address = input.address;
+  const instance = idCodec("instance").decode(address.instanceId);
+  const plugin = idCodec("plugin").decode(address.pluginId);
+  const owner = identityKeyCodec.decode(address.owner);
+  const actor = identityKeyCodec.decode(input.expected.actor);
+  const session = idCodec("server-session").decode(input.expected.session);
+  if (!instance.ok || !plugin.ok || !owner.ok || !actor.ok || !session.ok || typeof address.collection !== "string" || !address.collection.length || typeof address.recordId !== "string" || !address.recordId.length)
+    return err("invalid-input", "Invalid state request metadata.");
+  return ok({ address: { instanceId: instance.value, pluginId: plugin.value, owner: owner.value, collection: address.collection, recordId: address.recordId }, expected: { actor: actor.value, session: session.value } });
+}
+function encoded(result, codec) {
+  return result.ok ? { ok: true, value: codec.encode(result.value) } : { ok: false, error: { ...result.error } };
+}
+function failed(code, message) {
+  return { ok: false, error: { code, message, retry: "never" } };
+}
+function createIdentityStateRpcBridge(options) {
+  if (options.rpc.instanceId !== options.server.instanceId)
+    return err("incompatible", "RPC and state server instance namespaces disagree.");
+  let disposed = false;
+  const resources = new Map;
+  const controllers = new Set;
+  const dispatch = async (action, input, context) => {
+    if (disposed)
+      return failed("disposed", "State RPC bridge is disposed.");
+    const decoded = decodeRequest(input);
+    if (!decoded.ok)
+      return { ok: false, error: { ...decoded.error } };
+    if (decoded.value.address.instanceId !== options.server.instanceId || decoded.value.address.pluginId !== options.pluginId)
+      return failed("invalid-input", "State address belongs to another instance or plugin.");
+    const handler = resources.get(decoded.value.address.collection);
+    return handler ? handler(action, input, context) : failed("not-found", "State collection is not registered.");
+  };
+  const route = { input: inputSchema, output: outputSchema };
+  const registered = options.rpc.register({
+    [methods.load]: route,
+    [methods.save]: route,
+    [methods.reconcile]: route
+  }, {
+    [methods.load]: { origin: "interactive-user", handle: (input, context) => dispatch("load", input, context.request) },
+    [methods.save]: { origin: "interactive-user", handle: (input, context) => dispatch("save", input, context.request) },
+    [methods.reconcile]: { origin: "interactive-user", handle: (input, context) => dispatch("reconcile", input, context.request) }
+  });
+  if (!registered.ok)
+    return registered;
+  return ok({
+    register({ resource, storage, policy, readPolicy }) {
+      if (disposed)
+        return err("disposed", "State RPC bridge is disposed.");
+      const definition = { ...resource.definition, codec: { ...resource.definition.codec } };
+      const capturedPolicy = { ...policy };
+      const capturedReadPolicy = { ...readPolicy ?? policy };
+      const collection = definition.collection;
+      if (resource.pluginId !== options.pluginId || !collection || !Number.isInteger(resource.definition.schemaVersion) || resource.definition.schemaVersion < 0 || storage.boundary !== "same-process-synchronous" || policy.kind !== "self-only" && policy.kind !== "collaborators" || capturedReadPolicy.kind !== "self-only" && capturedReadPolicy.kind !== "collaborators")
+        return err("invalid-input", "Invalid state resource registration.");
+      if (resources.has(collection))
+        return err("conflict", "State collection is already registered.");
+      const controller = new AbortController;
+      controllers.add(controller);
+      const codecs = stateCodecs(definition.codec);
+      const service = createStateService({
+        instanceId: options.server.instanceId,
+        pluginId: options.pluginId,
+        definition,
+        storage,
+        commits: { boundary: "same-process-synchronous", validate: (target, scope) => disposed || controller.signal.aborted ? err("expired", "State resource registration expired.") : options.server.commits.validate(target, scope) },
+        publish: (event) => {
+          if (!disposed && !controller.signal.aborted)
+            options.publish(event);
+        }
+      });
+      const handler = async (action, input, context) => {
+        if (disposed || controller.signal.aborted)
+          return failed("disposed", "State resource registration expired.");
+        const decoded = decodeRequest(input);
+        if (!decoded.ok)
+          return { ok: false, error: { ...decoded.error } };
+        const captured = decoded.value;
+        const parsedMutation = action === "save" ? codecs.mutation.decode(input) : null;
+        const mutation = parsedMutation?.ok ? codecs.mutation.decode(structuredClone(codecs.mutation.encode(parsedMutation.value))) : parsedMutation;
+        if (mutation && !mutation.ok)
+          return { ok: false, error: { ...mutation.error } };
+        const operation = action === "reconcile" ? idCodec("operation").decode(isRecord5(input) ? input.operationId : undefined) : null;
+        if (operation && !operation.ok)
+          return { ok: false, error: { ...operation.error } };
+        const opened = await options.server.personRequest(context);
+        if (!opened.ok)
+          return { ok: false, error: { ...opened.error } };
+        const person = opened.value;
+        const signal = AbortSignal.any([person.signal, controller.signal]);
+        const live = () => !disposed && !signal.aborted;
+        try {
+          if (!live())
+            return failed("expired", "State request expired.");
+          if (captured.expected.actor !== person.expected.actor || captured.expected.session !== person.expected.session)
+            return failed("stale-context", "State request expected another actor or session.");
+          const selection = captured.address.owner === person.actor.identity.key ? { kind: "self" } : { kind: "person", key: captured.address.owner };
+          if (mutation?.ok) {
+            const target2 = await person.target({ intent: "write", selection, policy: capturedPolicy, expected: captured.expected, expectedSubject: captured.address.owner });
+            if (!target2.ok)
+              return { ok: false, error: { ...target2.error } };
+            if (!live())
+              return failed("expired", "State request expired.");
+            return encoded(await service.save(target2.value, mutation.value, { signal }), codecs.save);
+          }
+          const target = await person.target({ intent: "read", selection, policy: capturedReadPolicy });
+          if (!target.ok)
+            return { ok: false, error: { ...target.error } };
+          if (!live())
+            return failed("expired", "State request expired.");
+          if (target.value.snapshot().subject.key !== captured.address.owner)
+            return failed("incompatible", "Resolved state subject does not match the requested owner.");
+          if (operation?.ok) {
+            const result2 = await service.reconcile(target.value, captured.address.recordId, operation.value);
+            return live() ? encoded(result2, codecs.lookup) : failed("expired", "State request expired.");
+          }
+          const result = await service.read(target.value, captured.address.recordId, { signal });
+          return live() ? encoded(result, codecs.read) : failed("expired", "State request expired.");
+        } catch {
+          return failed("unavailable", "State resource operation failed.");
+        } finally {
+          person.dispose();
+        }
+      };
+      resources.set(collection, handler);
+      return ok({ dispose() {
+        if (controller.signal.aborted)
+          return;
+        controller.abort();
+        controllers.delete(controller);
+        if (resources.get(collection) === handler)
+          resources.delete(collection);
+      } });
+    },
+    dispose() {
+      if (disposed)
+        return;
+      disposed = true;
+      for (const controller of controllers)
+        controller.abort();
+      controllers.clear();
+      resources.clear();
+    }
+  });
+}
+
+// bb-binding-runtime.ts
+function isRecord6(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isJson3(value) {
+  return value === null || typeof value === "boolean" || typeof value === "string" || typeof value === "number" && Number.isFinite(value) || Array.isArray(value) && value.every(isJson3) || isRecord6(value) && Object.values(value).every(isJson3);
+}
+function jsonResult(result, codec) {
+  return result.ok ? { ok: true, value: codec ? codec.encode(result.value) : result.value } : { ok: false, error: { ...result.error } };
+}
+var jsonSchema = {
+  "~standard": { version: 1, vendor: "bb-identity", validate: (value) => isJson3(value) ? { value } : { issues: [{ message: "Expected JSON." }] } }
+};
+var inputSchema2 = {
+  "~standard": { version: 1, vendor: "bb-identity", validate: (value) => ({ value }) }
+};
+function invalid(message) {
+  return { ok: false, error: { code: "invalid-input", message, retry: "never" } };
+}
+function decodeEmpty(value) {
+  return isRecord6(value) && Object.keys(value).length === 0 ? ok(undefined) : err("invalid-input", "Endpoint requires an empty input object.");
+}
+function decodeDirectory(value) {
+  if (!isRecord6(value) || typeof value.query !== "string" || !Array.isArray(value.kinds) || !value.kinds.every((kind) => kind === "person" || kind === "default-user" || kind === "machine" || kind === "external") || value.history !== "current" && value.history !== "include-historical" || typeof value.limit !== "number" || !Number.isInteger(value.limit) || value.limit < 1 || value.limit > 100 || value.cursor !== undefined && !idCodec("cursor").decode(value.cursor).ok)
+    return err("invalid-input", "Invalid directory query.");
+  const cursor = value.cursor === undefined ? undefined : idCodec("cursor").decode(value.cursor);
+  const limit = value.limit;
+  return cursor && !cursor.ok ? cursor : ok({ query: value.query, kinds: [...value.kinds], history: value.history, limit, ...cursor ? { cursor: cursor.value } : {} });
+}
+function decodeProfiles(value) {
+  if (!isRecord6(value) || !Array.isArray(value.keys) || value.keys.length > 64)
+    return err("invalid-input", "Invalid profile query.");
+  const keys = value.keys.map((key) => identityKeyCodec.decode(key));
+  return keys.every((key) => key.ok) ? ok({ keys: keys.map((key) => key.value) }) : err("invalid-input", "Invalid profile key.");
+}
+function decodeParticipants(value) {
+  if (!isRecord6(value) || typeof value.limit !== "number" || !Number.isInteger(value.limit) || value.limit < 1 || value.limit > 100)
+    return err("invalid-input", "Invalid participant query.");
+  const thread = idCodec("thread").decode(value.threadId);
+  const cursor = value.cursor === undefined ? undefined : idCodec("cursor").decode(value.cursor);
+  const limit = value.limit;
+  return !thread.ok || cursor && !cursor.ok ? err("invalid-input", "Invalid participant query identifiers.") : ok({ threadId: thread.value, limit, ...cursor ? { cursor: cursor.value } : {} });
+}
+function decodePreviews(value) {
+  if (!isRecord6(value) || !Array.isArray(value.threadIds) || value.threadIds.length > 64 || typeof value.perThreadLimit !== "number" || !Number.isInteger(value.perThreadLimit) || value.perThreadLimit < 1 || value.perThreadLimit > 100)
+    return err("invalid-input", "Invalid participant preview query.");
+  const threads = value.threadIds.map((thread) => idCodec("thread").decode(thread));
+  const perThreadLimit = value.perThreadLimit;
+  return threads.every((thread) => thread.ok) ? ok({ threadIds: threads.map((thread) => thread.value), perThreadLimit }) : err("invalid-input", "Invalid participant preview thread ID.");
+}
+function createPortableFoundation(options) {
+  if (options.extension.status === "malformed")
+    return { ok: false, error: options.extension.error };
+  if (options.extension.status === "unsupported-version")
+    return err("incompatible", `Unsupported identity protocol version ${options.extension.version}.`);
+  let disposed = false;
+  const registrations = new Set;
+  const releaseRegistrations = () => {
+    for (const registration of [...registrations]) {
+      registrations.delete(registration);
+      try {
+        registration.dispose();
+      } catch {}
+    }
+  };
+  const dispose = () => {
+    if (disposed)
+      return;
+    disposed = true;
+    releaseRegistrations();
+  };
+  const invoke = async (descriptor, input, invocation) => {
+    if (disposed)
+      throw new Error("Identity binding is disposed.");
+    return descriptor.handle(input, invocation);
+  };
+  const foundation = {
+    instanceId: options.extension.status === "supported" ? options.extension.protocol.instanceId : options.upstream.driver.instanceId,
+    register(contract, handlers) {
+      if (disposed)
+        return err("disposed", "Identity binding is disposed.");
+      const names = Object.keys(contract);
+      if (!names.length || names.length !== Object.keys(handlers).length || names.some((name) => {
+        if (!Object.hasOwn(handlers, name))
+          return true;
+        const descriptor = handlers[name];
+        return !descriptor || typeof descriptor.handle !== "function" || !["interactive-user", "background", "external"].includes(descriptor.origin);
+      }))
+        return err("invalid-input", "RPC handlers must exactly match the contract and declare a valid origin.");
+      if (options.extension.status === "absent") {
+        let admitted2 = true;
+        const wrapped2 = {};
+        for (const name of names) {
+          const method = name;
+          const descriptor = handlers[method];
+          wrapped2[method] = async (input) => {
+            if (disposed || !admitted2)
+              throw new Error("Identity RPC registration is retired.");
+            const request = options.upstream.issue(descriptor.origin);
+            try {
+              return await invoke(descriptor, input, { request, signal: request.signal, origin: descriptor.origin });
+            } finally {
+              options.upstream.release(request);
+            }
+          };
+        }
+        try {
+          options.bb.rpc.register(contract, wrapped2);
+          if (disposed) {
+            admitted2 = false;
+            return err("disposed", "Identity binding disposed during RPC registration.");
+          }
+          return ok(undefined);
+        } catch {
+          admitted2 = false;
+          return err("unavailable", "Upstream RPC registration failed.", "after-refresh");
+        }
+      }
+      if (options.extension.status !== "supported")
+        return err("incompatible", "Identity protocol is unavailable.");
+      const staged = [];
+      const wrapped = {};
+      let admitted = true;
+      try {
+        for (const name of names) {
+          const method = name;
+          const descriptor = handlers[method];
+          const bound = options.extension.protocol.bindInvocation({
+            routeClass: descriptor.origin === "interactive-user" ? "interactive-session" : descriptor.origin === "external" ? "external-credential" : "plugin-background",
+            handler: async (raw, input) => {
+              if (disposed || !admitted)
+                throw new Error("Identity RPC registration is retired.");
+              try {
+                return await invoke(descriptor, input, { request: raw.request, signal: raw.scope.signal, origin: descriptor.origin });
+              } finally {
+                raw.scope.release();
+              }
+            }
+          });
+          staged.push(bound.registration);
+          wrapped[method] = bound.handler;
+        }
+        options.bb.rpc.register(contract, wrapped);
+        if (disposed) {
+          for (const registration of staged)
+            registration.dispose();
+          return err("disposed", "Identity binding disposed during registration.");
+        }
+        for (const registration of staged)
+          registrations.add(registration);
+        return ok(undefined);
+      } catch {
+        admitted = false;
+        for (const registration of staged) {
+          try {
+            registration.dispose();
+          } catch {}
+        }
+        return err("unavailable", "Enhanced RPC registration failed.", "after-refresh");
+      }
+    },
+    dispose
+  };
+  try {
+    options.bb.onDispose(dispose);
+  } catch {
+    dispose();
+    return err("unavailable", "Could not register RPC cleanup.", "after-refresh");
+  }
+  return ok(foundation);
+}
+function createBbIdentityServerBinding(options) {
+  const upstream = createBbUpstreamDriver({ bb: options.bb, ...options.stateNamespace !== undefined ? { stateNamespace: options.stateNamespace } : {}, ...options.scheduler !== undefined ? { scheduler: options.scheduler } : {}, ...options.externalMessageRendering !== undefined ? { externalMessageRendering: options.externalMessageRendering } : {} });
+  if (!upstream.ok)
+    return upstream;
+  const extension = inspectForkExtension(options.bb.experimental_p6rIdentity);
+  if (extension.status !== "absent" && extension.status !== "supported") {
+    upstream.value.dispose();
+    return extension.status === "malformed" ? { ok: false, error: extension.error } : err("incompatible", `Unsupported identity protocol version ${extension.version}.`);
+  }
+  if (upstream.value.externalMessageRendering === "producer" && extension.status === "supported") {
+    const enableProducerRendering = extension.protocol.experimental_useProducerMessageRendering;
+    if (typeof enableProducerRendering !== "function") {
+      upstream.value.dispose();
+      return err("incompatible", "Enhanced identity host does not support producer-owned external message rendering.");
+    }
+    try {
+      const hookResult = enableProducerRendering.call(extension.protocol);
+      if (hookResult !== undefined)
+        throw Error("Producer rendering hook must be synchronous.");
+    } catch {
+      upstream.value.dispose();
+      return err("incompatible", "Enhanced identity host could not enable producer-owned external message rendering.");
+    }
+  }
+  const host = createHostAdapter({ upstream: upstream.value.driver, extension });
+  const server = createIdentityServer({ host });
+  let disposed = false;
+  const publish = (event) => {
+    if (!disposed)
+      try {
+        options.bb.realtime.publish("bb-identity/v1", event);
+      } catch {}
+  };
+  const endpoint = createIdentityEndpoint({ server, publish });
+  const foundation = createPortableFoundation({ bb: options.bb, extension, upstream: upstream.value });
+  if (!foundation.ok) {
+    endpoint.dispose();
+    server.dispose();
+    host.dispose();
+    upstream.value.dispose();
+    return foundation;
+  }
+  const state = createIdentityStateRpcBridge({ rpc: foundation.value, server, pluginId: host.pluginId, publish: (event) => publish({ kind: "state", event }) });
+  if (!state.ok) {
+    foundation.value.dispose();
+    endpoint.dispose();
+    server.dispose();
+    host.dispose();
+    upstream.value.dispose();
+    return state;
+  }
+  const invocations = new WeakMap;
+  const expired = () => err("expired", "Invocation has already settled.");
+  const recordFor = (invocation) => {
+    const record = invocations.get(invocation);
+    return disposed || !record || record.settled || record.signal.aborted ? expired() : ok(record);
+  };
+  const unavailableSession2 = () => ({
+    status: "unavailable",
+    instanceId: server.instanceId,
+    error: { code: "expired", message: "Invocation has already settled.", retry: "after-refresh" }
+  });
+  const openPerson = async (invocation) => {
+    const record = recordFor(invocation);
+    if (!record.ok)
+      return record;
+    const opened = await server.personRequest(record.value.request);
+    if (record.value.settled || record.value.signal.aborted) {
+      if (opened.ok)
+        opened.value.dispose();
+      return expired();
+    }
+    if (opened.ok)
+      record.value.people.add(opened.value);
+    return opened;
+  };
+  const guardEndpoint = async (invocation, operation) => {
+    const record = recordFor(invocation);
+    if (!record.ok)
+      return record;
+    const result = await operation(record.value.request);
+    return record.value.settled || record.value.signal.aborted ? expired() : result;
+  };
+  let disposeBinding = () => {};
+  const guardedHistory = {
+    async contributions(query, readOptions) {
+      if (disposed)
+        return err("disposed", "Identity binding is disposed.");
+      const result = await server.history.contributions(query, readOptions);
+      return disposed ? err("disposed", "Identity binding is disposed.") : result;
+    },
+    async attempts(query, readOptions) {
+      if (disposed)
+        return err("disposed", "Identity binding is disposed.");
+      const result = await server.history.attempts(query, readOptions);
+      return disposed ? err("disposed", "Identity binding is disposed.") : result;
+    }
+  };
+  const publicServer = {
+    instanceId: server.instanceId,
+    commits: server.commits,
+    async session(invocation) {
+      const record = recordFor(invocation);
+      if (!record.ok)
+        return unavailableSession2();
+      const session = await server.session(record.value.request);
+      return record.value.settled || record.value.signal.aborted ? unavailableSession2() : session;
+    },
+    selfProfile: (invocation) => guardEndpoint(invocation, (request) => server.selfProfile(request)),
+    personRequest: openPerson,
+    async sendExternal(author, input, readOptions) {
+      if (disposed)
+        return { status: "rejected", error: { code: "disposed", message: "Identity binding is disposed.", retry: "never" } };
+      const renderedInput = upstream.value.externalMessageRendering === "host" ? renderExternalPrompt(upstream.value.driver.pluginId, author, input.input) : input.input;
+      return server.sendExternal(author, { ...input, input: renderedInput }, readOptions);
+    },
+    lookupOperation: (operationId, readOptions) => disposed ? Promise.resolve(err("disposed", "Identity binding is disposed.")) : server.lookupOperation(operationId, readOptions),
+    history: guardedHistory
+  };
+  const publicEndpoint = {
+    bootstrap: (invocation) => guardEndpoint(invocation, (request) => endpoint.bootstrap(request)),
+    selfProfile: (invocation) => guardEndpoint(invocation, (request) => endpoint.selfProfile(request)),
+    search: (invocation, input) => guardEndpoint(invocation, (request) => endpoint.search(request, input)),
+    profiles: (invocation, input) => guardEndpoint(invocation, (request) => endpoint.profiles(request, input)),
+    participants: (invocation, input) => guardEndpoint(invocation, (request) => endpoint.participants(request, input)),
+    participantPreviews: (invocation, input) => guardEndpoint(invocation, (request) => endpoint.participantPreviews(request, input)),
+    dispose: () => disposeBinding()
+  };
+  const endpointContract = {
+    [identityRpcMethods[identityRoutes.bootstrap]]: { input: inputSchema2, output: jsonSchema },
+    [identityRpcMethods[identityRoutes.selfProfile]]: { input: inputSchema2, output: jsonSchema },
+    [identityRpcMethods[identityRoutes.search]]: { input: inputSchema2, output: jsonSchema },
+    [identityRpcMethods[identityRoutes.profiles]]: { input: inputSchema2, output: jsonSchema },
+    [identityRpcMethods[identityRoutes.participants]]: { input: inputSchema2, output: jsonSchema },
+    [identityRpcMethods[identityRoutes.participantPreviews]]: { input: inputSchema2, output: jsonSchema }
+  };
+  const endpointRegistered = foundation.value.register(endpointContract, {
+    [identityRpcMethods[identityRoutes.bootstrap]]: { origin: "interactive-user", handle: async (input, context) => {
+      const decoded = decodeEmpty(input);
+      return decoded.ok ? jsonResult(await endpoint.bootstrap(context.request)) : invalid(decoded.error.message);
+    } },
+    [identityRpcMethods[identityRoutes.selfProfile]]: { origin: "interactive-user", handle: async (input, context) => {
+      const decoded = decodeEmpty(input);
+      return decoded.ok ? jsonResult(await endpoint.selfProfile(context.request)) : invalid(decoded.error.message);
+    } },
+    [identityRpcMethods[identityRoutes.search]]: { origin: "interactive-user", handle: async (input, context) => {
+      const decoded = decodeDirectory(input);
+      return decoded.ok ? jsonResult(await endpoint.search(context.request, decoded.value)) : invalid(decoded.error.message);
+    } },
+    [identityRpcMethods[identityRoutes.profiles]]: { origin: "interactive-user", handle: async (input, context) => {
+      const decoded = decodeProfiles(input);
+      return decoded.ok ? jsonResult(await endpoint.profiles(context.request, decoded.value)) : invalid(decoded.error.message);
+    } },
+    [identityRpcMethods[identityRoutes.participants]]: { origin: "interactive-user", handle: async (input, context) => {
+      const decoded = decodeParticipants(input);
+      return decoded.ok ? jsonResult(await endpoint.participants(context.request, decoded.value)) : invalid(decoded.error.message);
+    } },
+    [identityRpcMethods[identityRoutes.participantPreviews]]: { origin: "interactive-user", handle: async (input, context) => {
+      const decoded = decodePreviews(input);
+      return decoded.ok ? jsonResult(await endpoint.participantPreviews(context.request, decoded.value)) : invalid(decoded.error.message);
+    } }
+  });
+  if (!endpointRegistered.ok) {
+    state.value.dispose();
+    foundation.value.dispose();
+    endpoint.dispose();
+    server.dispose();
+    host.dispose();
+    upstream.value.dispose();
+    return endpointRegistered;
+  }
+  const createInvocation = (context) => {
+    const record = { request: context.request, signal: context.signal, people: new Set, settled: false };
+    const invocation = {
+      origin: context.origin,
+      signal: context.signal,
+      person: () => context.origin === "external" ? Promise.resolve(err("unauthenticated", "External invocation uses an explicit external source.")) : openPerson(invocation)
+    };
+    invocations.set(invocation, record);
+    const finish = () => {
+      record.settled = true;
+      for (const request of record.people)
+        request.dispose();
+      record.people.clear();
+    };
+    return { invocation, finish };
+  };
+  const httpRegistrations = new Set;
+  const httpReleases = new Set;
+  const binding = {
+    server: publicServer,
+    endpoint: publicEndpoint,
+    rpc: { register(contract, handlers) {
+      const names = Object.keys(contract);
+      if (!names.length || names.length !== Object.keys(handlers).length || names.some((name) => {
+        if (!Object.hasOwn(handlers, name))
+          return true;
+        const descriptor = handlers[name];
+        return !descriptor || typeof descriptor.handle !== "function" || !["interactive-user", "background", "external"].includes(descriptor.origin);
+      }))
+        return err("invalid-input", "RPC handlers must exactly match the contract and declare a valid origin.");
+      const normalized = {};
+      for (const name of names) {
+        const descriptor = handlers[name];
+        if (!descriptor)
+          return err("invalid-input", "RPC handlers must exactly match the contract.");
+        normalized[name] = { origin: descriptor.origin, handle: async (input, context) => {
+          const issued = createInvocation(context);
+          try {
+            return await descriptor.handle(input, issued.invocation);
+          } finally {
+            issued.finish();
+          }
+        } };
+      }
+      return foundation.value.register(contract, normalized);
+    } },
+    http: { route(method, path, descriptor, routeOptions) {
+      if (disposed)
+        return err("disposed", "Identity binding is disposed.");
+      if (!options.bb.http)
+        return err("unsupported", "This SDK has no HTTP registration.");
+      if (!descriptor || typeof descriptor.handle !== "function" || !["interactive-user", "external"].includes(descriptor.origin) || descriptor.origin === "interactive-user" && (routeOptions?.auth ?? "local") !== "local") {
+        return err("invalid-input", "Interactive HTTP identity requires local authentication.");
+      }
+      const run = async (context, raw, release, coreOwnsBody = false) => {
+        if (disposed) {
+          release();
+          throw new Error("Identity HTTP registration is retired.");
+        }
+        const issued = createInvocation(raw);
+        let finished = false;
+        const finish = () => {
+          if (finished)
+            return;
+          finished = true;
+          context.req.raw.signal.removeEventListener("abort", finish);
+          raw.signal.removeEventListener("abort", finish);
+          httpReleases.delete(finish);
+          issued.finish();
+          release();
+        };
+        httpReleases.add(finish);
+        context.req.raw.signal.addEventListener("abort", finish, { once: true });
+        raw.signal.addEventListener("abort", finish, { once: true });
+        if (context.req.raw.signal.aborted) {
+          finish();
+          throw new Error("HTTP request is aborted.");
+        }
+        try {
+          const response = await descriptor.handle(context, issued.invocation);
+          if (coreOwnsBody)
+            return response;
+          return retainIdentityHttpResponse(response, raw.signal, context.req.raw.signal, finish);
+        } catch (cause) {
+          finish();
+          throw cause;
+        }
+      };
+      let registration;
+      try {
+        if (extension.status === "supported") {
+          const bound = extension.protocol.bindInvocation({
+            routeClass: descriptor.origin === "interactive-user" ? "interactive-session" : "external-credential",
+            handler: (raw, context) => run(context, { request: raw.request, signal: raw.scope.signal, origin: descriptor.origin }, () => raw.scope.release(), true)
+          });
+          registration = bound.registration;
+          options.bb.http.route(method, path, bound.handler, routeOptions);
+          if (disposed)
+            registration.dispose();
+          else
+            httpRegistrations.add(registration);
+        } else {
+          options.bb.http.route(method, path, (context) => {
+            const request = upstream.value.issue(descriptor.origin);
+            return run(context, { request, signal: request.signal, origin: descriptor.origin }, () => upstream.value.release(request));
+          }, routeOptions);
+        }
+        return disposed ? err("disposed", "Identity binding is disposed.") : ok(undefined);
+      } catch {
+        registration?.dispose();
+        return err("unavailable", "HTTP registration failed.");
+      }
+    } },
+    state: { register: (options2) => disposed ? err("disposed", "Identity binding is disposed.") : state.value.register(options2) },
+    async registerProvider(provider) {
+      if (disposed)
+        return err("disposed", "Identity binding is disposed.");
+      const registration = await host.registerProvider(provider);
+      return disposed && registration.ok ? (registration.value.dispose(), err("disposed", "Identity binding is disposed.")) : registration;
+    },
+    toolProvenance: (context) => disposed ? Promise.resolve(err("disposed", "Identity binding is disposed.")) : server.toolProvenance(context),
+    async background(run) {
+      if (disposed)
+        throw new Error("Identity binding is disposed.");
+      const request = upstream.value.issue("background");
+      const issued = createInvocation({ request, origin: "background", signal: request.signal });
+      try {
+        return await run(issued.invocation);
+      } finally {
+        issued.finish();
+        upstream.value.release(request);
+      }
+    },
+    dispose() {
+      if (disposed)
+        return;
+      disposed = true;
+      for (const release of [...httpReleases])
+        release();
+      for (const registration of httpRegistrations)
+        registration.dispose();
+      httpRegistrations.clear();
+      state.value.dispose();
+      foundation.value.dispose();
+      endpoint.dispose();
+      server.dispose();
+      host.dispose();
+      upstream.value.dispose();
+    }
+  };
+  disposeBinding = () => binding.dispose();
+  try {
+    options.bb.onDispose(() => binding.dispose());
+  } catch {
+    binding.dispose();
+    return err("unavailable", "Could not register binding cleanup.", "after-refresh");
+  }
+  return ok(binding);
+}
+
+// bb-entry-runtime.ts
+function bindBbIdentity(bb, options) {
+  return createBbIdentityServerBinding({
+    bb,
+    ...options?.stateNamespace === undefined ? {} : { stateNamespace: options.stateNamespace },
+    ...options?.scheduler === undefined ? {} : { scheduler: options.scheduler },
+    ...options?.externalMessageRendering === undefined ? {} : { externalMessageRendering: options.externalMessageRendering }
+  });
+}
+export {
+  bindBbIdentity
+};