@phosphorco/bb-identity 0.1.0

package/dist/testing-runtime.js

@@ -0,0 +1,4084 @@
+// @bun
+// 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}`;
+}
+
+// host-runtime.ts
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function unavailable(message) {
+  return { code: "unavailable", message, retry: "after-reconnect" };
+}
+function isPresentation(value) {
+  return isRecord2(value) && typeof value.displayName === "string" && (value.handle === null || typeof value.handle === "string") && (value.avatarUrl === null || typeof value.avatarUrl === "string");
+}
+function isPersonIdentity(value) {
+  if (!isRecord2(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 isRecord2(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 isRecord2(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") && isRecord2(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 (!isRecord2(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 isRecord2(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 isRecord2(value) && idCodec("thread").decode(value.threadId).ok && idCodec("contribution").decode(value.contributionId).ok;
+}
+function isNativeIds(value) {
+  return isRecord2(value) && ["deliveryId", "queuedMessageId", "turnId"].every((key) => value[key] === null || typeof value[key] === "string");
+}
+function decodeAcceptance(value) {
+  if (!isRecord2(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" || !isRecord2(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 (!isRecord2(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 (!isRecord2(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") && isRecord2(input.error)) {
+        return ok(input);
+      }
+      return err("invalid-input", "Invalid unavailable server session.");
+    }
+    if (!isRecord2(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 (!isRecord2(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 isRecord2(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 (!isRecord2(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 (!isRecord2(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) || !isRecord2(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 (!isRecord2(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 (!isRecord2(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 (!isRecord2(origin))
+    return false;
+  const validOrigin = origin.kind === "person" ? snapshot(origin.actor) && isRecord2(origin.actor) && isPersonIdentity(origin.actor.identity) : origin.kind === "machine" ? snapshot(origin.actor) && isRecord2(origin.actor) && isMachineIdentity(origin.actor.identity) : origin.kind === "external" ? snapshot(origin.actor) && isRecord2(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 (!isRecord2(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 (!isRecord2(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 (!isRecord2(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 (!isRecord2(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 (!isRecord2(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 (!isRecord2(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 (!isRecord2(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 (!isRecord2(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 = isRecord2(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 };
+}
+
+// state-service-runtime.ts
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function nonEmpty(value) {
+  return typeof value === "string" && value.length > 0;
+}
+function decodeAddress(value) {
+  if (!isRecord3(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 isRecord3(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 (!isRecord3(value) || !isRecord3(value.identity) || !isRecord3(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 (!isRecord3(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 (!isRecord3(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 (!isRecord3(value) || value.kind !== "initialize" && value.kind !== "replace" || !isRecord3(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 (!isRecord3(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 (isRecord3(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 (!isRecord3(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 (!isRecord3(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
+    }
+  };
+}
+
+// client-connection-runtime.ts
+var errorCodes = new Set([
+  "unavailable",
+  "unauthenticated",
+  "unsupported",
+  "incompatible",
+  "invalid-input",
+  "not-found",
+  "ambiguous",
+  "stale-owner",
+  "stale-context",
+  "conflict",
+  "cancelled",
+  "disposed",
+  "limit-exceeded",
+  "invalid-operation",
+  "expired"
+]);
+var retryKinds = new Set(["never", "after-refresh", "after-reconnect", "same-operation"]);
+function isRecord4(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function decodeError2(value) {
+  if (!isRecord4(value) || typeof value.code !== "string" || !errorCodes.has(value.code) || typeof value.message !== "string" || typeof value.retry !== "string" || !retryKinds.has(value.retry)) {
+    return err("incompatible", "Malformed identity transport error.");
+  }
+  return ok({ code: value.code, message: value.message, retry: value.retry });
+}
+function isJson(value) {
+  if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean")
+    return true;
+  if (Array.isArray(value))
+    return value.every(isJson);
+  return isRecord4(value) && Object.values(value).every(isJson);
+}
+var jsonCodec = {
+  decode(value) {
+    return isJson(value) ? ok(value) : err("invalid-input", "Expected JSON payload.");
+  },
+  encode(value) {
+    return value;
+  }
+};
+var stateInvalidationCodec = stateCodecs(jsonCodec).invalidation;
+var clientInvalidationCodec = {
+  decode(value) {
+    if (!isRecord4(value) || typeof value.kind !== "string")
+      return err("invalid-input", "Invalid identity invalidation.");
+    if (value.kind === "session") {
+      const reason = value.reason;
+      return reason === undefined ? ok({ kind: "session" }) : reason === "actor" || reason === "provider" || reason === "capabilities" ? ok({ kind: "session", reason }) : err("invalid-input", "Invalid session invalidation reason.");
+    }
+    if (value.kind === "disconnected" || value.kind === "reconnected")
+      return ok({ kind: value.kind });
+    if (value.kind === "directory" && Array.isArray(value.keys)) {
+      const keys = value.keys.map((key) => identityKeyCodec.decode(key));
+      const revision = value.revision === null ? ok(null) : idCodec("revision").decode(value.revision);
+      return keys.every((key) => key.ok) && revision.ok ? ok({ kind: "directory", keys: keys.map((key) => key.value), revision: revision.value }) : err("invalid-input", "Invalid directory invalidation keys.");
+    }
+    if (value.kind === "participants" && Array.isArray(value.threadIds)) {
+      const threadIds = value.threadIds.map((id) => idCodec("thread").decode(id));
+      return threadIds.every((id) => id.ok) ? ok({ kind: "participants", threadIds: threadIds.map((id) => id.value) }) : err("invalid-input", "Invalid participant invalidation thread IDs.");
+    }
+    return err("invalid-input", "Unknown identity invalidation.");
+  },
+  encode(value) {
+    return value;
+  }
+};
+function decodeEvent(value) {
+  const client = clientInvalidationCodec.decode(value);
+  if (client.ok)
+    return client.value;
+  if (isRecord4(value) && value.kind === "state") {
+    const state = stateInvalidationCodec.decode(value.event);
+    if (state.ok)
+      return { kind: "state", event: state.value };
+  }
+  return null;
+}
+function cloneHealth(value) {
+  const clone = (link) => link.status === "unavailable" ? { status: "unavailable", error: { ...link.error } } : { status: link.status };
+  return { generation: value.generation, identity: clone(value.identity), state: clone(value.state) };
+}
+function cancelled(options) {
+  return options?.signal?.aborted ? err("cancelled", "Identity request was cancelled.") : null;
+}
+function createIdentityConnection(inputs) {
+  let disposed = false;
+  const channel = (subscribeSource) => {
+    const listeners = new Set;
+    let source = null;
+    const close = () => {
+      const previous = source;
+      source = null;
+      if (previous) {
+        previous.closed = true;
+        try {
+          previous.stop?.();
+        } catch {}
+        previous.stop = null;
+      }
+    };
+    return {
+      subscribe(listener) {
+        if (disposed)
+          return () => {};
+        const entry = { observer: listener };
+        listeners.add(entry);
+        if (!source) {
+          const current = { closed: false, stop: null };
+          source = current;
+          try {
+            const stop = subscribeSource((value) => {
+              if (disposed || current.closed)
+                return;
+              for (const entry2 of [...listeners]) {
+                if (disposed || current.closed)
+                  break;
+                if (listeners.has(entry2)) {
+                  try {
+                    entry2.observer(value);
+                  } catch {}
+                }
+              }
+            });
+            if (current.closed) {
+              try {
+                stop();
+              } catch {}
+            } else
+              current.stop = stop;
+          } catch (error) {
+            if (source === current)
+              source = null;
+            current.closed = true;
+            listeners.delete(entry);
+            throw error;
+          }
+        }
+        let removed = false;
+        return () => {
+          if (removed)
+            return;
+          removed = true;
+          listeners.delete(entry);
+          if (!listeners.size)
+            close();
+        };
+      },
+      dispose() {
+        close();
+        listeners.clear();
+      }
+    };
+  };
+  const events = channel((listener) => inputs.subscribe((payload) => {
+    const event = decodeEvent(payload);
+    if (event)
+      listener(event);
+  }));
+  const healthEvents = channel((listener) => inputs.subscribeHealth(() => listener()));
+  return {
+    getHealth() {
+      return disposed ? { generation: -1, identity: { status: "unavailable", error: { code: "disposed", message: "Identity connection is disposed.", retry: "never" } }, state: { status: "unavailable", error: { code: "disposed", message: "Identity connection is disposed.", retry: "never" } } } : cloneHealth(inputs.getHealth());
+    },
+    subscribeHealth(listener) {
+      return healthEvents.subscribe(listener);
+    },
+    async request(method, input, options) {
+      const aborted = cancelled(options);
+      if (aborted && !aborted.ok)
+        throw new Error(aborted.error.message);
+      if (disposed)
+        throw new Error("Identity connection is disposed.");
+      return inputs.request(method, input, options);
+    },
+    subscribe(listener) {
+      return events.subscribe(listener);
+    },
+    async revalidate(options) {
+      const aborted = cancelled(options);
+      if (aborted)
+        return aborted;
+      if (disposed)
+        return err("disposed", "Identity connection is disposed.");
+      try {
+        const result = await inputs.revalidate(options);
+        if (disposed)
+          return err("disposed", "Identity connection is disposed.");
+        const aborted2 = cancelled(options);
+        if (aborted2)
+          return aborted2;
+        if (!isRecord4(result) || typeof result.ok !== "boolean")
+          return err("incompatible", "Malformed connection revalidation result.");
+        if (result.ok)
+          return ok(undefined);
+        const failure2 = decodeError2(result.error);
+        return failure2.ok ? { ok: false, error: failure2.value } : failure2;
+      } catch {
+        if (disposed)
+          return err("disposed", "Identity connection is disposed.");
+        const aborted2 = cancelled(options);
+        if (aborted2)
+          return aborted2;
+        return err("unavailable", "Identity connection revalidation failed.", "after-reconnect");
+      }
+    },
+    dispose() {
+      if (disposed)
+        return;
+      disposed = true;
+      events.dispose();
+      healthEvents.dispose();
+      inputs.dispose?.();
+    }
+  };
+}
+
+// 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
+});
+
+// client-runtime.ts
+var errorCodes2 = new Set([
+  "unavailable",
+  "unauthenticated",
+  "unsupported",
+  "incompatible",
+  "invalid-input",
+  "not-found",
+  "ambiguous",
+  "stale-owner",
+  "stale-context",
+  "conflict",
+  "cancelled",
+  "disposed",
+  "limit-exceeded",
+  "invalid-operation",
+  "expired"
+]);
+var retryKinds2 = new Set(["never", "after-refresh", "after-reconnect", "same-operation"]);
+function isRecord5(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function decodeError3(value) {
+  return isRecord5(value) && typeof value.code === "string" && errorCodes2.has(value.code) && typeof value.message === "string" && typeof value.retry === "string" && retryKinds2.has(value.retry) ? ok({ code: value.code, message: value.message, retry: value.retry }) : err("incompatible", "Malformed identity route error.");
+}
+function decodeResult(value, decode) {
+  if (!isRecord5(value) || typeof value.ok !== "boolean")
+    return err("incompatible", "Malformed identity route Result.");
+  if (!value.ok) {
+    const failure2 = decodeError3(value.error);
+    return failure2.ok ? { ok: false, error: failure2.value } : failure2;
+  }
+  return decode(value.value);
+}
+function unavailable2(connection) {
+  const link = connection.getHealth().identity;
+  if (link.status === "unavailable")
+    return err(link.error.code, link.error.message, link.error.retry);
+  return link.status === "healthy" ? null : err("unavailable", "Identity transport is reconnecting.", "after-reconnect");
+}
+function cancelled2(options) {
+  return options?.signal?.aborted ? err("cancelled", "Identity request was cancelled.") : null;
+}
+function decodePage(value) {
+  if (!isRecord5(value) || !Array.isArray(value.items) || value.nextCursor !== null && typeof value.nextCursor !== "string" || typeof value.revision !== "string") {
+    return err("incompatible", "Malformed directory page.");
+  }
+  const profiles = value.items.map((item) => profileCodec.decode(item));
+  return profiles.every((profile) => profile.ok) ? ok({ items: profiles.map((profile) => profile.value), nextCursor: value.nextCursor, revision: value.revision }) : err("incompatible", "Malformed directory profile.");
+}
+function decodeLookups(value) {
+  if (!Array.isArray(value))
+    return err("incompatible", "Malformed profile lookup list.");
+  const values = [];
+  for (const entry of value) {
+    if (!isRecord5(entry))
+      return err("incompatible", "Malformed profile lookup.");
+    const key = identityKeyCodec.decode(entry.key);
+    if (!key.ok)
+      return err("incompatible", "Malformed profile lookup key.");
+    if (entry.status === "missing")
+      values.push({ key: key.value, status: "missing" });
+    else if (entry.status === "found") {
+      const profile = profileCodec.decode(entry.profile);
+      if (!profile.ok || profile.value.identity.key !== key.value)
+        return err("incompatible", "Malformed profile lookup profile.");
+      values.push({ key: key.value, status: "found", profile: profile.value });
+    } else
+      return err("incompatible", "Malformed profile lookup status.");
+  }
+  return ok(values);
+}
+function decodeParticipant(value) {
+  if (!isRecord5(value) || !Array.isArray(value.roles) || !value.roles.every((role) => role === "author" || role === "editor" || role === "mentioned" || role === "interaction-resolver"))
+    return err("incompatible", "Malformed participant.");
+  const profile = profileCodec.decode({ identity: value.identity, presentation: value.presentation, revision: "participant", status: "current" });
+  return profile.ok ? ok({ identity: profile.value.identity, presentation: profile.value.presentation, roles: [...value.roles] }) : err("incompatible", "Malformed participant identity.");
+}
+function decodeParticipantPage2(value) {
+  if (!isRecord5(value) || !Array.isArray(value.items) || value.nextCursor !== null && typeof value.nextCursor !== "string" || typeof value.revision !== "string" || value.coverage !== "complete-history" && value.coverage !== "partial-history")
+    return err("incompatible", "Malformed participant page.");
+  const items = value.items.map(decodeParticipant);
+  return items.every((item) => item.ok) ? ok({ items: items.map((item) => item.value), nextCursor: value.nextCursor, revision: value.revision, coverage: value.coverage }) : err("incompatible", "Malformed participant item.");
+}
+function decodePreviews(value) {
+  if (!Array.isArray(value))
+    return err("incompatible", "Malformed participant previews.");
+  const result = [];
+  for (const preview of value) {
+    if (!isRecord5(preview) || !Array.isArray(preview.participants) || typeof preview.hasMore !== "boolean" || typeof preview.revision !== "string" || preview.coverage !== "complete-history" && preview.coverage !== "partial-history")
+      return err("incompatible", "Malformed participant preview.");
+    const threadId = idCodec("thread").decode(preview.threadId);
+    const revision = idCodec("revision").decode(preview.revision);
+    if (!threadId.ok || !revision.ok)
+      return err("incompatible", "Malformed participant preview identifiers.");
+    const participants = preview.participants.map(decodeParticipant);
+    if (!participants.every((participant) => participant.ok))
+      return err("incompatible", "Malformed participant preview item.");
+    result.push({ threadId: threadId.value, participants: participants.map((participant) => participant.value), hasMore: preview.hasMore, coverage: preview.coverage, revision: revision.value });
+  }
+  return ok(result);
+}
+function createIdentityClientTransport(connection) {
+  const call = async (method, input, decode, options) => {
+    const stopped = cancelled2(options);
+    if (stopped)
+      return stopped;
+    const failed = unavailable2(connection);
+    if (failed)
+      return failed;
+    try {
+      return decodeResult(await connection.request(method, input, options), decode);
+    } catch {
+      return err("unavailable", "Identity route request failed.", "after-reconnect");
+    }
+  };
+  const directory = {
+    search: (input, options) => call(identityRoutes.search, input, decodePage, options),
+    getMany: (input, options) => call(identityRoutes.profiles, input, decodeLookups, options),
+    subscribe(keys, listener) {
+      return connection.subscribe((event) => {
+        if (event.kind !== "directory")
+          return;
+        if (!keys.length || !event.keys.length || event.keys.some((key) => keys.includes(key)))
+          listener({ keys: event.keys, revision: event.revision });
+      });
+    }
+  };
+  const participants = {
+    list: (input, options) => call(identityRoutes.participants, input, decodeParticipantPage2, options),
+    previews: (input, options) => call(identityRoutes.participantPreviews, input, decodePreviews, options)
+  };
+  return {
+    bootstrap: (options) => call(identityRoutes.bootstrap, {}, serverSessionCodec.decode, options),
+    selfProfile: (options) => call(identityRoutes.selfProfile, {}, profileCodec.decode, options),
+    directory,
+    participants,
+    subscribe(listener) {
+      return connection.subscribe((event) => {
+        if (event.kind !== "state")
+          listener(event);
+      });
+    }
+  };
+}
+
+// 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";
+function isRecord6(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isJson2(value) {
+  return value === null || typeof value === "boolean" || typeof value === "string" || typeof value === "number" && Number.isFinite(value) || Array.isArray(value) && value.every(isJson2) || isRecord6(value) && Object.values(value).every(isJson2);
+}
+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 (!isRecord6(value) || !isJson2(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 (!isJson2(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 (!isRecord6(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" && isRecord6(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) || !isJson2(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);
+}
+
+// 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-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 isJson3(value) {
+  return value === null || typeof value === "string" || typeof value === "boolean" || typeof value === "number" && Number.isFinite(value) || Array.isArray(value) && value.every(isJson3) || isRecord7(value) && Object.values(value).every(isJson3);
+}
+var outputSchema = { "~standard": { version: 1, vendor: "bb-identity", validate: (value) => isJson3(value) ? { value } : { issues: [{ message: "Expected an encoded identity state result." }] } } };
+function isRecord7(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function decodeRequest(input) {
+  if (!isRecord7(input) || !isRecord7(input.address) || !isRecord7(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(isRecord7(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 isRecord8(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isJson4(value) {
+  return value === null || typeof value === "boolean" || typeof value === "string" || typeof value === "number" && Number.isFinite(value) || Array.isArray(value) && value.every(isJson4) || isRecord8(value) && Object.values(value).every(isJson4);
+}
+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) => isJson4(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 isRecord8(value) && Object.keys(value).length === 0 ? ok(undefined) : err("invalid-input", "Endpoint requires an empty input object.");
+}
+function decodeDirectory(value) {
+  if (!isRecord8(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 (!isRecord8(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 (!isRecord8(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 decodePreviews2(value) {
+  if (!isRecord8(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 = decodePreviews2(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 }
+  });
+}
+
+// testing-wire-runtime.ts
+var CHANNEL = "bb-identity/v1";
+var ISSUER = "fixture";
+function gate() {
+  let reach, open;
+  const reached = new Promise((r) => {
+    reach = r;
+  });
+  const released = new Promise((r) => {
+    open = r;
+  });
+  return { reached, reach: () => reach(), wait: () => released, release: () => open() };
+}
+function brand(kind, value) {
+  const decoded = idCodec(kind).decode(value);
+  if (!decoded.ok)
+    throw new TypeError(decoded.error.message);
+  return decoded.value;
+}
+function json(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+function createMultiUserProtocol(instanceId, initial) {
+  let actor = initial;
+  let epoch = 0;
+  let requests = 0;
+  const people = new Map;
+  const scopes = new Set;
+  const listeners = new Set;
+  const session = () => ({
+    status: "ready",
+    instanceId,
+    mode: "multi-user",
+    actor,
+    stamp: brand("server-session", `wire-fake-session-${epoch}`),
+    capabilities: {
+      requestIdentity: "host-resolved",
+      acceptance: "transactional-check",
+      forwarding: "host-bound",
+      directory: { search: true, lookup: true },
+      participants: false,
+      externalSend: "structured",
+      toolProvenance: "causal",
+      operationLookup: true
+    }
+  });
+  const scope = () => {
+    const controller = new AbortController;
+    scopes.add(controller);
+    return {
+      signal: controller.signal,
+      validate: () => controller.signal.aborted ? { ok: false, code: "invalidated" } : { ok: true },
+      release: () => {
+        scopes.delete(controller);
+        controller.abort();
+      }
+    };
+  };
+  const record = (subject) => {
+    const person = people.get(subject);
+    return person ? { issuer: ISSUER, subject, presentation: { displayName: person.name, handle: null, avatarUrl: null }, status: "current" } : null;
+  };
+  const revision = () => `wire-fake-directory-${people.size}`;
+  const directory = {
+    issuers: [ISSUER],
+    generation: brand("provider-generation", "wire-fake-provider"),
+    async directory(input) {
+      const query = input.query.toLowerCase();
+      const records = [...people.keys()].map(record).filter((r) => r !== null && (r.subject.includes(query) || r.presentation.displayName.toLowerCase().includes(query))).slice(0, input.limit);
+      return ok({ records, nextCursor: null, revision: revision() });
+    },
+    async lookup(subjects) {
+      return ok({ revision: revision(), records: subjects.map((s) => ({ issuer: s.issuer, subject: s.subject, record: s.issuer === ISSUER ? record(s.subject) : null })) });
+    },
+    person(issuer, subject) {
+      const key = identityKeyCodec.decode(`${issuer}:${subject}`);
+      return key.ok ? ok({ kind: "person", key: key.value, issuer, subject }) : key;
+    }
+  };
+  const unsupported = async () => err("unsupported", "Not modeled by the identity wire fake.");
+  const protocol = {
+    version: 1,
+    instanceId,
+    bindInvocation({ handler }) {
+      return {
+        registration: { generation: "wire-fake-invocation", status: "active", dispose() {} },
+        handler: (...args) => handler({ request: { id: `wire-fake-request-${++requests}` }, scope: scope() }, ...args)
+      };
+    },
+    async session() {
+      return session();
+    },
+    async selfProfile() {
+      return ok({ identity: actor.identity, presentation: actor.presentation, revision: brand("revision", `wire-fake-profile-${epoch}`), status: "current" });
+    },
+    async openRequest() {
+      const current = session();
+      const controller = new AbortController;
+      const opened = scope();
+      scopes.add(controller);
+      return ok({
+        signal: controller.signal,
+        session: current,
+        scope: opened,
+        validate: (expected) => controller.signal.aborted ? err("expired", "Wire fake request expired.") : expected.actor === current.actor.identity.key && expected.session === current.stamp ? ok(undefined) : err("stale-context", "Wire fake session changed."),
+        release: () => {
+          scopes.delete(controller);
+          controller.abort();
+        }
+      });
+    },
+    async accept() {
+      return { status: "rejected", error: { code: "unsupported", message: "Not modeled by the identity wire fake.", retry: "never" } };
+    },
+    async lookup() {
+      return ok({ status: "unknown", reason: "unsupported" });
+    },
+    async provenance() {
+      return ok({ status: "unknown", correlation: null, reason: "wire-fake" });
+    },
+    async historyContributions() {
+      return ok({ status: "unavailable", reason: "unsupported" });
+    },
+    async historyAttempts() {
+      return ok({ status: "unavailable", reason: "unsupported" });
+    },
+    directorySources: () => [directory],
+    participants: unsupported,
+    async forwardRpc(_scope, _destination, input) {
+      return input;
+    },
+    registerProvider: unsupported,
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    }
+  };
+  return {
+    protocol,
+    get actor() {
+      return actor;
+    },
+    addPerson(subject, name) {
+      people.set(subject, { name });
+    },
+    switchActor(next) {
+      actor = next;
+      epoch++;
+      for (const controller of [...scopes])
+        controller.abort();
+      scopes.clear();
+      for (const listener of [...listeners])
+        listener({ kind: "session", reason: "actor" });
+    }
+  };
+}
+function createIdentityWireFake(options) {
+  const clock = options.clock ?? createManualClock();
+  const harness = createStateStorageHarness({ clock });
+  const host = options.host;
+  const pluginId = host.harness.inspection.pluginId;
+  if (options.resource.pluginId !== pluginId)
+    throw new TypeError("The state resource must belong to the fake host plugin.");
+  const multi = options.mode === "multi-user" ? createMultiUserProtocol(brand("instance", options.instanceId ?? "wire-fake-instance"), personFixture(options.actor ?? { subject: "wire-fake-user", name: "Wire fake user" })) : null;
+  let failLoads = 0;
+  let loadHold = null, saveHold = null, loseSave = false;
+  const storage = {
+    boundary: harness.storage.boundary,
+    get receiptRetentionMs() {
+      return harness.storage.receiptRetentionMs;
+    },
+    async read(address, readOptions) {
+      if (loadHold) {
+        const held = loadHold;
+        held.reach();
+        await held.wait();
+      }
+      if (failLoads > 0) {
+        failLoads--;
+        return err("unavailable", "Controlled state read failure.", "after-reconnect");
+      }
+      return harness.storage.read(address, readOptions);
+    },
+    async commit(input) {
+      if (saveHold) {
+        const held = saveHold;
+        held.reach();
+        await held.wait();
+      }
+      return harness.storage.commit(input);
+    },
+    reconcile: (input) => harness.storage.reconcile(input)
+  };
+  const realtime = new Set;
+  const publish = (channel, payload) => {
+    host.bb.realtime.publish(channel, payload);
+    const wire = json(payload ?? null);
+    for (const listener of [...realtime])
+      listener(channel, wire);
+  };
+  const bb = {
+    pluginId,
+    onDispose: (fn) => host.bb.onDispose(fn),
+    rpc: { register: (contract, handlers) => host.bb.rpc.register(contract, handlers) },
+    realtime: { publish },
+    sdk: host.bb.sdk,
+    ...multi ? { experimental_p6rIdentity: multi.protocol } : {}
+  };
+  const bound = bindBbIdentity(bb, options.instanceId && !multi ? { stateNamespace: options.instanceId } : undefined);
+  if (!bound.ok)
+    throw new Error(`bindBbIdentity failed: ${bound.error.message}`);
+  const binding = bound.value;
+  const registered = binding.state.register({ resource: options.resource, storage, policy: options.policy ?? { kind: "self-only" }, ...options.readPolicy ? { readPolicy: options.readPolicy } : {} });
+  if (!registered.ok)
+    throw new Error(`State registration failed: ${registered.error.message}`);
+  const calls = [];
+  const saveInputs = [];
+  const stateSave = identityRpcMethods["bb-identity/v1/state/save"];
+  const rpc = {};
+  for (const method of Object.values(identityRpcMethods)) {
+    rpc[method] = async (input) => {
+      calls.push(method);
+      if (method === stateSave)
+        saveInputs.push(json(input ?? null));
+      const result = await host.harness.behavior.callRpc(method, input ?? {});
+      if (method === stateSave && loseSave) {
+        loseSave = false;
+        throw new Error("Controlled post-commit response loss.");
+      }
+      return result;
+    };
+  }
+  const nextVersion = (address) => {
+    const current = harness.readCommitted(address);
+    if (!current)
+      throw new Error("No committed state at that address to invalidate.");
+    return current;
+  };
+  return {
+    rpc,
+    channel: CHANNEL,
+    host,
+    storage: harness,
+    get actor() {
+      return multi ? multi.actor : null;
+    },
+    onRealtime(listener) {
+      realtime.add(listener);
+      return () => {
+        realtime.delete(listener);
+      };
+    },
+    switchActor(subject) {
+      if (!multi)
+        throw new Error("switchActor needs mode: multi-user; the singleton actor cannot change.");
+      multi.switchActor(personFixture({ subject, name: subject }));
+    },
+    addPerson(person) {
+      if (!multi)
+        throw new Error("addPerson needs mode: multi-user; the singleton directory is empty.");
+      multi.addPerson(person.subject, person.name);
+    },
+    personKey(subject) {
+      const key = identityKeyCodec.decode(`${ISSUER}:${subject}`);
+      if (!key.ok)
+        throw new TypeError(key.error.message);
+      return key.value;
+    },
+    invalidateExternally(address, value) {
+      const current = nextVersion(address);
+      const envelope = { ...current, version: { epoch: current.version.epoch, sequence: current.version.sequence + 1 }, ...value === undefined ? {} : { value } };
+      harness.seed(envelope);
+      publish(CHANNEL, { kind: "state", event: { address, version: envelope.version, operationId: null } });
+      return envelope;
+    },
+    failNextLoads(count) {
+      failLoads = count;
+    },
+    loseNextSaveResponse() {
+      loseSave = true;
+    },
+    holdLoads() {
+      const held = gate();
+      loadHold = held;
+      const release = held.release;
+      return { reached: held.reached, release() {
+        if (loadHold === held)
+          loadHold = null;
+        release();
+      } };
+    },
+    holdSaves() {
+      const held = gate();
+      saveHold = held;
+      const release = held.release;
+      return { reached: held.reached, release() {
+        if (saveHold === held)
+          saveHold = null;
+        release();
+      } };
+    },
+    calls,
+    saveInputs,
+    committed: (address) => harness.readCommitted(address),
+    dispose() {
+      registered.value.dispose();
+      binding.dispose();
+    }
+  };
+}
+// testing-storage-runtime.ts
+class StorageConformanceError extends Error {
+  check;
+  constructor(check, detail) {
+    super(`[state storage ${check}] ${detail}`);
+    this.name = "StorageConformanceError";
+    this.check = check;
+  }
+}
+function canonical(value) {
+  if (value === null || typeof value !== "object")
+    return JSON.stringify(value) ?? "undefined";
+  if (Array.isArray(value))
+    return "[" + value.map(canonical).join(",") + "]";
+  const record = value;
+  return "{" + Object.keys(record).filter((k) => record[k] !== undefined).sort().map((k) => JSON.stringify(k) + ":" + canonical(record[k])).join(",") + "}";
+}
+function id(kind, value) {
+  const decoded = idCodec(kind).decode(value);
+  if (!decoded.ok)
+    throw new TypeError(decoded.error.message);
+  return decoded.value;
+}
+function defineStateStorageConformance(options) {
+  const actor = options.actor ?? personFixture({ subject: "storage-conformance", name: "Storage conformance" });
+  const schemaVersion = options.schemaVersion ?? 1;
+  const [first, second] = options.values;
+  const prefix = options.prefix ?? "state storage conformance: ";
+  const accepted = () => ({ ok: true, value: actor });
+  const mutation = (input) => {
+    const address = options.address(input.recordId);
+    return {
+      kind: input.kind ?? "replace",
+      address,
+      expectedVersion: input.expectedVersion,
+      expected: { actor: address.owner, session: id("server-session", "storage-conformance-session") },
+      ownerSession: id("owner-session", "storage-conformance-owner"),
+      localGeneration: 1,
+      operationId: id("operation", input.operation),
+      schemaVersion,
+      value: input.value
+    };
+  };
+  const check = (name, condition, detail) => {
+    if (!condition)
+      throw new StorageConformanceError(name, detail);
+  };
+  const same = (name, actual, expected, detail) => check(name, canonical(actual) === canonical(expected), `${detail}
+  expected: ${canonical(expected)}
+  actual:   ${canonical(actual)}`);
+  const value = (name, result) => {
+    if (!result.ok)
+      throw new StorageConformanceError(name, `unexpected error ${result.error.code}: ${result.error.message}`);
+    return result.value;
+  };
+  const code = (name, result, expected) => check(name, !result.ok && result.error.code === expected, `expected error ${expected}, got ${canonical(result)}`);
+  const versionOf = (read) => read.status === "present" ? read.envelope.version : read.status === "empty" ? read.version : null;
+  const outcome = (name, save, status) => {
+    const v = value(name, save);
+    check(name, v.status === status, `expected ${status}, got ${v.status}`);
+    return v;
+  };
+  const noValidation = (name) => () => {
+    throw new StorageConformanceError(name, "validateAtCommit ran for a mutation that must not commit");
+  };
+  async function withStorage(name, body) {
+    let now = 1750000000000;
+    const opened = await options.open({ now: () => now });
+    check(name, opened.storage.boundary === "same-process-synchronous", "storage must declare a same-process-synchronous commit boundary");
+    try {
+      await body(opened.storage, { advance(ms) {
+        now += ms;
+      } }, opened);
+    } finally {
+      await opened.close?.();
+    }
+  }
+  const empty = async (name, storage, recordId) => {
+    const read = value(name, await storage.read(options.address(recordId)));
+    check(name, read.status === "empty", `a fresh record reads as ${read.status}, not empty`);
+    return versionOf(read);
+  };
+  options.test(`${prefix}empty records have a stable version`, () => withStorage("empty-version", async (storage) => {
+    const name = "empty-version";
+    const a = await empty(name, storage, "conformance-empty");
+    same(name, await empty(name, storage, "conformance-empty"), a, "two reads of an empty record disagree on its version");
+  }));
+  options.test(`${prefix}initialize has one winner; unchanged and conflict are reported`, () => withStorage("initialize-winner", async (storage) => {
+    const name = "initialize-winner", version = await empty(name, storage, "conformance-init");
+    const winner = outcome(name, await storage.commit({ mutation: mutation({ recordId: "conformance-init", operation: "init-a", value: first, expectedVersion: version, kind: "initialize" }), validateAtCommit: accepted }), "saved");
+    if (winner.status !== "saved")
+      return;
+    outcome(name, await storage.commit({ mutation: mutation({ recordId: "conformance-init", operation: "init-b", value: second, expectedVersion: version, kind: "initialize" }), validateAtCommit: accepted }), "already-initialized");
+    outcome(name, await storage.commit({ mutation: mutation({ recordId: "conformance-init", operation: "same-value", value: first, expectedVersion: winner.envelope.version }), validateAtCommit: accepted }), "unchanged");
+    outcome(name, await storage.commit({ mutation: mutation({ recordId: "conformance-init", operation: "stale-version", value: second, expectedVersion: version }), validateAtCommit: accepted }), "conflict");
+    same(name, value(name, await storage.read(options.address("conformance-init"))), { status: "present", envelope: winner.envelope }, "losing mutations changed the record");
+  }));
+  options.test(`${prefix}operation ids are immutable, replayed exactly and address scoped`, () => withStorage("operation-ids", async (storage) => {
+    const name = "operation-ids", version = await empty(name, storage, "conformance-replay");
+    const original = mutation({ recordId: "conformance-replay", operation: "shared-operation", value: first, expectedVersion: version, kind: "initialize" });
+    const saved = await storage.commit({ mutation: original, validateAtCommit: accepted });
+    outcome(name, saved, "saved");
+    same(name, await storage.commit({ mutation: structuredClone(original), validateAtCommit: noValidation(name) }), saved, "an exact replay did not return the original outcome");
+    code(name, await storage.commit({ mutation: { ...original, value: second }, validateAtCommit: noValidation(name) }), "invalid-operation");
+    same(name, value(name, await storage.reconcile({ address: original.address, operationId: original.operationId })), { status: "final", outcome: value(name, saved) }, "reconcile does not report the original outcome");
+    const otherVersion = await empty(name, storage, "conformance-replay-other");
+    outcome(name, await storage.commit({ mutation: mutation({ recordId: "conformance-replay-other", operation: "shared-operation", value: second, expectedVersion: otherVersion, kind: "initialize" }), validateAtCommit: accepted }), "saved");
+  }));
+  options.test(`${prefix}expired operation ids stay tombstoned and the record is retained`, () => withStorage("expiry", async (storage, clock) => {
+    const name = "expiry", version = await empty(name, storage, "conformance-expiry");
+    const original = mutation({ recordId: "conformance-expiry", operation: "expiring-operation", value: first, expectedVersion: version, kind: "initialize" });
+    const saved = outcome(name, await storage.commit({ mutation: original, validateAtCommit: accepted }), "saved");
+    clock.advance(storage.receiptRetentionMs + 1);
+    same(name, value(name, await storage.reconcile({ address: original.address, operationId: original.operationId })), { status: "unknown", reason: "expired" }, "an expired operation must reconcile as unknown/expired");
+    code(name, await storage.commit({ mutation: structuredClone(original), validateAtCommit: noValidation(name) }), "expired");
+    code(name, await storage.commit({ mutation: { ...original, value: second }, validateAtCommit: noValidation(name) }), "expired");
+    if (saved.status === "saved")
+      same(name, value(name, await storage.read(original.address)), { status: "present", envelope: saved.envelope }, "expiry changed the record");
+  }));
+  options.test(`${prefix}a commit-time rejection leaves neither record nor operation outcome`, () => withStorage("commit-rejection", async (storage, _clock, opened) => {
+    const name = "commit-rejection", before = value(name, await storage.read(options.address("conformance-rejected")));
+    const rejected = mutation({ recordId: "conformance-rejected", operation: "rejected-operation", value: first, expectedVersion: versionOf(before), kind: before.status === "empty" ? "initialize" : "replace" });
+    let inside = null;
+    const result = await storage.commit({ mutation: rejected, validateAtCommit: () => {
+      inside = opened.insideCommit?.() ?? null;
+      return { ok: false, error: { code: "expired", message: "scope released before commit", retry: "never" } };
+    } });
+    code(name, result, "expired");
+    if (opened.insideCommit)
+      check(name, inside === true, "validateAtCommit ran outside the synchronous commit transaction");
+    same(name, value(name, await storage.read(rejected.address)), before, "a rejected commit changed the record");
+    same(name, value(name, await storage.reconcile({ address: rejected.address, operationId: rejected.operationId })), { status: "absent-final", retry: "same-operation-only" }, "a rejected commit left an operation outcome");
+  }));
+  const restart = `${prefix}records and operation outcomes survive a restart`;
+  const gap = options.skip?.restart;
+  if (gap !== undefined) {
+    const skip = options.test.skip ?? options.test;
+    skip(`${restart} \u2014 gap: ${gap}`, async () => {});
+    return;
+  }
+  options.test(restart, async () => {
+    const name = "restart";
+    await withStorage(name, async (storage, _clock, opened) => {
+      if (!opened.reopen)
+        throw new StorageConformanceError(name, "open() returned no reopen(); supply reopen, or pass skip.restart with the reason restart durability is not checked.");
+      const version = await empty(name, storage, "conformance-restart");
+      const original = mutation({ recordId: "conformance-restart", operation: "durable-operation", value: first, expectedVersion: version, kind: "initialize" });
+      const saved = outcome(name, await storage.commit({ mutation: original, validateAtCommit: accepted }), "saved");
+      const restarted = await opened.reopen();
+      if (saved.status === "saved")
+        same(name, value(name, await restarted.read(original.address)), { status: "present", envelope: saved.envelope }, "the record did not survive a restart");
+      same(name, value(name, await restarted.reconcile({ address: original.address, operationId: original.operationId })), { status: "final", outcome: saved }, "the operation outcome did not survive a restart");
+    });
+  });
+}
+
+// testing-runtime.ts
+var configuration = {
+  version: 1,
+  boundaryId: "fixture-boundary",
+  pluginId: "fixture-plugin",
+  ingressIds: ["local"],
+  credentials: [],
+  resolver: { timeoutMs: 1000 }
+};
+function requiredId(value, kind, fallback) {
+  const decoded = idCodec(kind).decode(value ?? fallback);
+  if (!decoded.ok)
+    throw new TypeError(decoded.error.message);
+  return decoded.value;
+}
+function submitted(input) {
+  return {
+    status: "submitted",
+    receipt: {
+      evidence: "host-accepted",
+      operationId: input.operationId,
+      acceptedAt: new Date(0).toISOString(),
+      references: [],
+      native: { deliveryId: null, queuedMessageId: null, turnId: null },
+      provenance: "structured",
+      deduplication: "guaranteed",
+      retainedUntil: new Date(60000).toISOString()
+    }
+  };
+}
+function wireSubmitted(input) {
+  return {
+    status: "submitted",
+    receipt: {
+      evidence: "host-accepted",
+      operationId: input.operationId,
+      acceptedAt: new Date(0).toISOString(),
+      references: [],
+      native: { deliveryId: null, queuedMessageId: null, turnId: null },
+      provenance: "structured",
+      deduplication: "guaranteed",
+      retainedUntil: new Date(60000).toISOString()
+    }
+  };
+}
+function deferred() {
+  let resolve;
+  let reject;
+  const promise = new Promise((resolvePromise, rejectPromise) => {
+    resolve = resolvePromise;
+    reject = rejectPromise;
+  });
+  return { promise, resolve, reject };
+}
+function createManualClock(initialMilliseconds = 0) {
+  let now = initialMilliseconds;
+  let nextId = 0;
+  const timers = new Map;
+  const runDue = async () => {
+    for (;; ) {
+      const due = [...timers.entries()].filter(([, timer]) => timer.at <= now).sort((left, right) => left[1].at - right[1].at)[0];
+      if (!due)
+        return;
+      timers.delete(due[0]);
+      due[1].callback();
+      await Promise.resolve();
+    }
+  };
+  return {
+    now: () => now,
+    schedule(delayMs, callback) {
+      const id2 = nextId++;
+      timers.set(id2, { at: now + Math.max(0, delayMs), callback });
+      return () => {
+        timers.delete(id2);
+      };
+    },
+    async advance(milliseconds) {
+      now += Math.max(0, milliseconds);
+      await runDue();
+    },
+    flush: runDue,
+    get pendingTimers() {
+      return timers.size;
+    }
+  };
+}
+function personFixture(input) {
+  const key = identityKeyCodec.decode(`fixture:${input.subject}`);
+  if (!key.ok)
+    throw new TypeError(key.error.message);
+  return {
+    identity: { kind: "person", key: key.value, issuer: "fixture", subject: input.subject },
+    presentation: { displayName: input.name, handle: null, avatarUrl: null },
+    evidence: "integration-asserted"
+  };
+}
+function unavailableHistory() {
+  return {
+    contributions: async () => ok({ status: "unavailable", reason: "unsupported" }),
+    attempts: async () => ok({ status: "unavailable", reason: "unsupported" })
+  };
+}
+function unsupportedControl(name) {
+  throw new Error(`AdapterHarness.${name} is unsupported by this fixture; use a core integration fixture for that behavior.`);
+}
+function createAdapterHarness(options) {
+  const clock = options.clock ?? createManualClock();
+  const instanceId = requiredId(options.instanceId, "instance", "fixture-instance");
+  const pluginId = requiredId(options.pluginId, "plugin", "fixture-plugin");
+  const defaultActor = {
+    identity: { kind: "default-user", key: defaultIdentityKey(instanceId), instanceId },
+    presentation: { displayName: "Fixture user", handle: null, avatarUrl: null },
+    evidence: "local-user"
+  };
+  let actor = defaultActor;
+  let sessionEpoch = 0;
+  let identityStatus = "ready";
+  let rawExtension;
+  let providerCounter = 0;
+  let activeProvider = null;
+  let nextProviderResult = "succeed";
+  const hostListeners = new Set;
+  const requestControllers = new Map;
+  const scopeControllers = new Set;
+  const observations = { submissions: 0, rawExtensionReads: 0, profileReads: 0, participantReads: 0, subscriptions: 0 };
+  const invalidateRequests = () => {
+    for (const controller of requestControllers.values())
+      controller.abort();
+    for (const controller of scopeControllers)
+      controller.abort();
+    scopeControllers.clear();
+  };
+  const readySession = () => identityStatus === "ready" ? { status: "ready", instanceId, mode: options.mode, actor, stamp: requiredId(undefined, "server-session", sessionEpoch === 0 ? "fixture-session" : `fixture-session-${sessionEpoch}`), capabilities: {
+    requestIdentity: "host-resolved",
+    acceptance: "transactional-check",
+    forwarding: "host-bound",
+    directory: { search: false, lookup: false },
+    participants: false,
+    externalSend: "structured",
+    toolProvenance: "causal",
+    operationLookup: true
+  } } : { status: identityStatus, instanceId, error: {
+    code: identityStatus === "unauthenticated" ? "unauthenticated" : "unavailable",
+    message: `Fixture identity is ${identityStatus}.`,
+    retry: "after-refresh"
+  } };
+  const profile = () => ({
+    identity: actor.identity,
+    presentation: actor.presentation,
+    revision: requiredId(undefined, "revision", "fixture-profile"),
+    status: "current"
+  });
+  const newScope = () => {
+    const controller = new AbortController;
+    scopeControllers.add(controller);
+    let released = false;
+    return {
+      signal: controller.signal,
+      validate: () => released || controller.signal.aborted ? { ok: false, code: "invalidated" } : { ok: true },
+      release: () => {
+        released = true;
+        scopeControllers.delete(controller);
+        controller.abort();
+      }
+    };
+  };
+  const registerProvider = async (provider) => {
+    if (nextProviderResult === "fail") {
+      nextProviderResult = "succeed";
+      return err("unavailable", "Fixture provider replacement failed.", "after-reconnect");
+    }
+    const generation = `fixture-generation-${++providerCounter}`;
+    const controller = new AbortController;
+    let status = "staged";
+    const listeners = new Set;
+    const publish = (next) => {
+      status = next;
+      for (const listener of listeners)
+        listener(status);
+    };
+    const raw = {
+      generation,
+      configuration,
+      getStatus: () => status,
+      signal: controller.signal,
+      subscribe(listener) {
+        listeners.add(listener);
+        return () => listeners.delete(listener);
+      },
+      invalidate: () => ok(undefined),
+      person(issuer, subject) {
+        const key = identityKeyCodec.decode(`fixture:${issuer}:${subject}`);
+        return key.ok ? ok({ kind: "person", key: key.value, issuer, subject }) : key;
+      },
+      dispose() {
+        if (status !== "retired") {
+          publish("retired");
+          controller.abort();
+        }
+      }
+    };
+    if (provider.validateReadiness) {
+      const readiness = await provider.validateReadiness({
+        generation,
+        configuration,
+        deadlineAt: clock.now() + configuration.resolver.timeoutMs,
+        signal: controller.signal
+      });
+      if (!readiness.ok) {
+        raw.dispose();
+        return readiness;
+      }
+    }
+    const previous = activeProvider;
+    activeProvider = raw;
+    publish("active");
+    previous?.dispose();
+    return ok(raw);
+  };
+  const rawProtocol = {
+    version: 1,
+    instanceId,
+    bindInvocation({ handler }) {
+      return { registration: { generation: "fixture-invocation", status: "active", dispose() {} }, handler: (...args) => handler({ request: { id: "bound", origin: "interactive-user" }, scope: newScope() }, ...args) };
+    },
+    async session() {
+      return readySession();
+    },
+    async selfProfile() {
+      observations.profileReads++;
+      return identityStatus === "ready" ? ok(profile()) : err("unauthenticated", "No fixture identity.");
+    },
+    async openRequest(request) {
+      const session = readySession();
+      if (session.status !== "ready")
+        return err("unauthenticated", "No fixture identity.");
+      const controller = new AbortController;
+      requestControllers.set(request.id, controller);
+      const scope = newScope();
+      return ok({
+        signal: controller.signal,
+        session,
+        validate: (expected) => controller.signal.aborted ? err("expired", "Fixture request expired.") : expected.actor === session.actor.identity.key && expected.session === session.stamp ? ok(undefined) : err("stale-context", "Fixture request changed."),
+        release: () => controller.abort(),
+        scope
+      });
+    },
+    async accept(input) {
+      if (input.source.kind === "scope" && !input.source.scope.validate().ok) {
+        return { status: "rejected", error: { code: "expired", message: "Fixture request context is no longer live.", retry: "never" } };
+      }
+      observations.submissions++;
+      return wireSubmitted(input.input);
+    },
+    async lookup() {
+      return ok({ status: "unknown", reason: "unsupported" });
+    },
+    async provenance() {
+      return ok({ status: "unknown", correlation: null, reason: "fixture" });
+    },
+    historyContributions: unavailableHistory().contributions,
+    historyAttempts: unavailableHistory().attempts,
+    directorySources: () => [],
+    async participants() {
+      observations.participantReads++;
+      return err("unsupported", "Fixture participants are disabled.");
+    },
+    async forwardRpc(_scope, _destination, input) {
+      return input;
+    },
+    registerProvider,
+    subscribe(listener) {
+      observations.subscriptions++;
+      hostListeners.add(listener);
+      return () => hostListeners.delete(listener);
+    }
+  };
+  rawExtension = rawProtocol;
+  const upstream = {
+    instanceId,
+    pluginId,
+    inputCodec: options.inputCodec,
+    scheduler: clock,
+    async session() {
+      return readySession();
+    },
+    async selfProfile() {
+      observations.profileReads++;
+      return identityStatus === "ready" ? ok(profile()) : err("unauthenticated", "No fixture identity.");
+    },
+    async openScope(request) {
+      const session = readySession();
+      if (session.status !== "ready")
+        return err("unauthenticated", "No fixture identity.");
+      const controller = new AbortController;
+      requestControllers.set(request.id, controller);
+      return ok({
+        signal: controller.signal,
+        session,
+        validate: (expected) => controller.signal.aborted ? err("expired", "Fixture request expired.") : expected.actor === session.actor.identity.key && expected.session === session.stamp ? ok(undefined) : err("stale-context", "Fixture request changed."),
+        release: () => controller.abort()
+      });
+    },
+    async submit(input) {
+      observations.submissions++;
+      return submitted(input);
+    },
+    labelExternal: (_author, input) => input,
+    toolCorrelation: () => ({ status: "unknown", correlation: null, reason: "fixture" }),
+    async forward(_context, _plugin, _method, input) {
+      return input;
+    },
+    subscribe(listener) {
+      observations.subscriptions++;
+      hostListeners.add(listener);
+      return () => hostListeners.delete(listener);
+    }
+  };
+  return {
+    upstream,
+    clock,
+    connect() {
+      observations.rawExtensionReads++;
+      return createHostAdapter({ upstream, extension: inspectForkExtension(rawExtension) });
+    },
+    setRawExtension(value) {
+      rawExtension = value;
+    },
+    setLookup() {
+      unsupportedControl("setLookup");
+    },
+    request(origin = "interactive-user") {
+      return { id: `request-${requestControllers.size + 1}`, origin };
+    },
+    setActor(next) {
+      if (options.mode === "single-user")
+        return err("unsupported", "Singleton adapter fixtures cannot replace the reserved default actor.");
+      actor = next;
+      sessionEpoch++;
+      invalidateRequests();
+      for (const listener of hostListeners)
+        listener({ kind: "session", reason: "actor" });
+      return ok(undefined);
+    },
+    setIdentityAvailability(status) {
+      if (identityStatus === status)
+        return;
+      identityStatus = status;
+      invalidateRequests();
+      for (const listener of hostListeners)
+        listener({ kind: "session", reason: "provider" });
+    },
+    settle(request) {
+      requestControllers.get(request.id)?.abort();
+    },
+    constructStreamingResponse() {
+      unsupportedControl("constructStreamingResponse");
+    },
+    finishStream() {
+      unsupportedControl("finishStream");
+    },
+    abort(request) {
+      requestControllers.get(request.id)?.abort();
+    },
+    replaceProvider(result) {
+      nextProviderResult = result;
+    },
+    disconnect() {
+      for (const listener of hostListeners)
+        listener({ kind: "disconnected" });
+    },
+    reconnect() {
+      for (const listener of hostListeners)
+        listener({ kind: "reconnected" });
+    },
+    pauseAcceptance() {
+      return unsupportedControl("pauseAcceptance");
+    },
+    loseNextAcceptanceResponse() {
+      unsupportedControl("loseNextAcceptanceResponse");
+    },
+    beginAttempt() {
+      return unsupportedControl("beginAttempt");
+    },
+    editContribution() {
+      unsupportedControl("editContribution");
+    },
+    continueAttempt() {
+      return unsupportedControl("continueAttempt");
+    },
+    toolCallForAttempt() {
+      return unsupportedControl("toolCallForAttempt");
+    },
+    get accepted() {
+      return unsupportedControl("accepted");
+    },
+    observations,
+    dispose() {
+      invalidateRequests();
+      for (const listener of hostListeners)
+        listener({ kind: "disposed" });
+      hostListeners.clear();
+    }
+  };
+}
+function createPause() {
+  const reached = deferred();
+  const releaseGate = deferred();
+  let reachedOnce = false;
+  let released = false;
+  return {
+    reached: reached.promise,
+    reach() {
+      if (!reachedOnce) {
+        reachedOnce = true;
+        reached.resolve();
+      }
+    },
+    wait: () => releaseGate.promise,
+    release() {
+      if (!released) {
+        released = true;
+        releaseGate.resolve();
+      }
+    }
+  };
+}
+function cloneFixture(value) {
+  return structuredClone(value);
+}
+function fixtureJson(value) {
+  const visit = (current) => {
+    if (current === null || typeof current === "string" || typeof current === "boolean")
+      return current;
+    if (typeof current === "number") {
+      if (!Number.isFinite(current))
+        throw new TypeError("Fixture storage accepts finite JSON numbers only.");
+      return current;
+    }
+    if (Array.isArray(current))
+      return current.map(visit);
+    if (typeof current !== "object")
+      throw new TypeError("Fixture storage accepts JSON values only.");
+    const prototype = Object.getPrototypeOf(current);
+    if (prototype !== Object.prototype && prototype !== null)
+      throw new TypeError("Fixture storage accepts plain JSON objects only.");
+    const output = Object.create(null);
+    for (const key of Object.keys(current).sort()) {
+      const child = current[key];
+      if (child === undefined)
+        throw new TypeError("Fixture storage does not accept undefined values.");
+      output[key] = visit(child);
+    }
+    return output;
+  };
+  return JSON.stringify(visit(value));
+}
+function sameVersion(left, right) {
+  return left.epoch === right.epoch && left.sequence === right.sequence;
+}
+function cloneRead(read) {
+  return cloneFixture(read);
+}
+function createConnectionHarness() {
+  let health = {
+    generation: 0,
+    identity: { status: "healthy" },
+    state: { status: "healthy" }
+  };
+  const replies = new Map;
+  const paused = new Map;
+  const events = new Set;
+  const healthListeners = new Set;
+  const methods2 = [];
+  let disposeCalls = 0;
+  const connection = createIdentityConnection({
+    async request(method) {
+      methods2.push(method);
+      const gate2 = paused.get(method)?.shift();
+      if (gate2) {
+        gate2.reach();
+        await gate2.wait();
+      }
+      const queue = replies.get(method);
+      if (!queue?.length)
+        throw new Error(`No fixture reply queued for ${method}.`);
+      return cloneFixture(queue.shift());
+    },
+    subscribe(listener) {
+      events.add(listener);
+      return () => events.delete(listener);
+    },
+    getHealth: () => cloneFixture(health),
+    subscribeHealth(listener) {
+      healthListeners.add(listener);
+      return () => healthListeners.delete(listener);
+    },
+    async revalidate() {
+      return { ok: true, value: undefined };
+    },
+    dispose() {
+      disposeCalls++;
+    }
+  });
+  return {
+    connection,
+    connect() {
+      return createIdentityClientTransport(connection);
+    },
+    setHealth(next) {
+      health = cloneFixture(next);
+      for (const listener of [...healthListeners])
+        listener();
+    },
+    replyNext(method, payload) {
+      const queue = replies.get(method) ?? [];
+      queue.push(cloneFixture(payload));
+      replies.set(method, queue);
+    },
+    emit(event) {
+      for (const listener of [...events])
+        listener(cloneFixture(event));
+    },
+    pauseNextRequest(method) {
+      const gate2 = createPause();
+      const queue = paused.get(method) ?? [];
+      queue.push(gate2);
+      paused.set(method, queue);
+      return gate2;
+    },
+    observations: {
+      methods: methods2,
+      get disposeCalls() {
+        return disposeCalls;
+      }
+    }
+  };
+}
+function createStateStorageHarness(options) {
+  const records = new Map;
+  const receipts = new Map;
+  const commits = [];
+  let readFailure = null;
+  let readPause = null;
+  let commitPause = null;
+  let loseCommitResponse = false;
+  const key = (address) => fixtureJson([address.instanceId, address.pluginId, address.collection, address.recordId, address.owner]);
+  const receiptKey = (address, operationId) => `${key(address)}\x00${operationId}`;
+  const empty = (address) => ({ status: "empty", address: cloneFixture(address), version: { epoch: "fixture-empty-r1", sequence: 0 } });
+  const current = (address) => cloneRead(records.get(key(address)) ?? empty(address));
+  const storage = {
+    boundary: "same-process-synchronous",
+    receiptRetentionMs: 60000,
+    async read(address) {
+      const paused = readPause;
+      readPause = null;
+      const before = paused?.capture === "before-pause" ? current(address) : null;
+      if (paused) {
+        paused.gate.reach();
+        await paused.gate.wait();
+      }
+      if (readFailure)
+        return { ok: false, error: cloneFixture(readFailure) };
+      return ok(before ?? current(address));
+    },
+    async commit(input) {
+      const gate2 = commitPause;
+      commitPause = null;
+      if (gate2) {
+        gate2.reach();
+        await gate2.wait();
+      }
+      let mutation;
+      let fingerprint;
+      try {
+        mutation = cloneFixture(input.mutation);
+        fingerprint = fixtureJson(mutation);
+      } catch (caught) {
+        return err("invalid-input", caught instanceof Error ? caught.message : "Invalid fixture state mutation.");
+      }
+      const addressKey = key(mutation.address);
+      const existingReceipt = receipts.get(receiptKey(mutation.address, mutation.operationId));
+      if (existingReceipt) {
+        if (existingReceipt.expired || existingReceipt.retainedUntil <= options.clock.now()) {
+          existingReceipt.expired = true;
+          return err("expired", "Fixture operation receipt expired.");
+        }
+        return existingReceipt.mutation === fingerprint ? ok(cloneFixture(existingReceipt.outcome)) : err("invalid-operation", "Operation ID was reused with a different immutable mutation.");
+      }
+      const actor = input.validateAtCommit();
+      if (!actor.ok)
+        return actor;
+      const present = current(mutation.address);
+      const version = present.status === "present" ? present.envelope.version : present.status === "empty" ? present.version : null;
+      const outcome = present.status === "migration-required" ? { status: "conflict", current: present, operationId: mutation.operationId } : mutation.kind === "initialize" && present.status === "present" ? { status: "already-initialized", current: present, operationId: mutation.operationId } : version === null || !sameVersion(version, mutation.expectedVersion) ? { status: "conflict", current: present, operationId: mutation.operationId } : present.status === "present" && fixtureJson(present.envelope.value) === fixtureJson(mutation.value) && present.envelope.schemaVersion === mutation.schemaVersion ? { status: "unchanged", envelope: present.envelope, operationId: mutation.operationId } : (() => {
+        const envelope = {
+          address: cloneFixture(mutation.address),
+          version: { epoch: version.epoch, sequence: version.sequence + 1 },
+          schemaVersion: mutation.schemaVersion,
+          value: cloneFixture(mutation.value),
+          lastEditedBy: cloneFixture(actor.value)
+        };
+        records.set(addressKey, { status: "present", envelope: cloneFixture(envelope) });
+        commits.push({ actor: actor.value.identity.key, address: cloneFixture(envelope.address), version: cloneFixture(envelope.version) });
+        return { status: "saved", envelope, operationId: mutation.operationId };
+      })();
+      receipts.set(receiptKey(mutation.address, mutation.operationId), {
+        mutation: fingerprint,
+        outcome: cloneFixture(outcome),
+        retainedUntil: options.clock.now() + storage.receiptRetentionMs,
+        expired: false
+      });
+      if (loseCommitResponse) {
+        loseCommitResponse = false;
+        return ok({ status: "indeterminate", operationId: mutation.operationId });
+      }
+      return ok(cloneFixture(outcome));
+    },
+    async reconcile({ address, operationId }) {
+      const receipt = receipts.get(receiptKey(address, operationId));
+      if (!receipt)
+        return ok({ status: "absent-final", retry: "same-operation-only" });
+      if (receipt.expired || receipt.retainedUntil <= options.clock.now()) {
+        receipt.expired = true;
+        return ok({ status: "unknown", reason: "expired" });
+      }
+      return ok({ status: "final", outcome: cloneFixture(receipt.outcome) });
+    }
+  };
+  return {
+    storage,
+    seed(envelope) {
+      records.set(key(envelope.address), { status: "present", envelope: cloneFixture(envelope) });
+    },
+    seedEmpty(address, version) {
+      records.set(key(address), { status: "empty", address: cloneFixture(address), version: cloneFixture(version) });
+    },
+    seedReadFailure(error) {
+      readFailure = cloneFixture(error);
+    },
+    seedLegacy(address, schemaVersion) {
+      records.set(key(address), { status: "migration-required", address: cloneFixture(address), storedSchemaVersion: schemaVersion });
+    },
+    readCommitted(address) {
+      const read = records.get(key(address));
+      return read?.status === "present" ? cloneFixture(read.envelope) : null;
+    },
+    pauseNextRead(options2) {
+      const gate2 = createPause();
+      readPause = { capture: options2.capture, gate: gate2 };
+      return gate2;
+    },
+    pauseNextCommit() {
+      const gate2 = createPause();
+      commitPause = gate2;
+      return gate2;
+    },
+    loseNextCommitResponse() {
+      loseCommitResponse = true;
+    },
+    expireReceipt(operationId) {
+      for (const [receiptKeyValue, receipt] of receipts)
+        if (receiptKeyValue.endsWith(`\x00${operationId}`))
+          receipt.expired = true;
+    },
+    commits
+  };
+}
+function consumerProvenanceFixture(provenance) {
+  return { id: provenance.status === "unknown" ? "unknown-provenance" : provenance.correlation?.toolCallId ?? "fixture-tool-call" };
+}
+export {
+  personFixture,
+  defineStateStorageConformance,
+  deferred,
+  createStateStorageHarness,
+  createManualClock,
+  createIdentityWireFake,
+  createConnectionHarness,
+  createAdapterHarness,
+  consumerProvenanceFixture
+};