@phosphorco/bb-identity 0.1.0

package/dist/react-entry-runtime.js

@@ -0,0 +1,3324 @@
+// react-runtime.ts
+import * as React from "react";
+import { useRealtime, useRealtimeConnectionState, useRpc } from "@get-bb/plugin-sdk/app";
+
+// 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 newOperationId() {
+  const random = globalThis.crypto?.randomUUID?.() ?? `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
+  return `op-${random}`;
+}
+function newConflictToken() {
+  return `conflict-${globalThis.crypto?.randomUUID?.() ?? Date.now().toString(36)}`;
+}
+
+// state-service-runtime.ts
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function nonEmpty(value) {
+  return typeof value === "string" && value.length > 0;
+}
+function decodeAddress(value) {
+  if (!isRecord2(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 isRecord2(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 (!isRecord2(value) || !isRecord2(value.identity) || !isRecord2(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 decodeEnvelope(value, codec) {
+  if (!isRecord2(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 (!isRecord2(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 (!isRecord2(value) || value.kind !== "initialize" && value.kind !== "replace" || !isRecord2(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 decodeOutcome(value, codec) {
+  if (!isRecord2(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 (isRecord2(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 stateAddressKey(address) {
+  return JSON.stringify([address.instanceId, address.pluginId, address.collection, address.recordId, address.owner]);
+}
+function decodeLookup(value, codec) {
+  if (!isRecord2(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 (!isRecord2(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) => decodeLookup(input, value),
+      encode: (input) => input.status === "final" ? { status: "final", outcome: encodeOutcome(input.outcome, value) } : input
+    }
+  };
+}
+
+// state-controller-runtime.ts
+var defaultScheduler = { now: Date.now, schedule(delay, callback) {
+  const timer = setTimeout(callback, delay);
+  return () => clearTimeout(timer);
+} };
+function frozen(value) {
+  if (value !== null && typeof value === "object") {
+    for (const child of Object.values(value))
+      frozen(child);
+    Object.freeze(value);
+  }
+  return value;
+}
+function valueClone(codec, value) {
+  const result = codec.decode(structuredClone(codec.encode(value)));
+  if (!result.ok)
+    throw new TypeError(result.error.message);
+  return frozen(result.value);
+}
+function version(read) {
+  return read.status === "present" ? read.envelope.version : read.version;
+}
+function sameVersion(a, b) {
+  return a.status === b.status && version(a).epoch === version(b).epoch && version(a).sequence === version(b).sequence;
+}
+function createIdentityState(options) {
+  const address = frozen({ ...options.address });
+  const expected = frozen({ ...options.expected });
+  const definition = options.definition;
+  const codec = definition.codec;
+  const codecs = stateCodecs(codec);
+  const drafts = options.drafts;
+  const initial = valueClone(codec, definition.initialValue());
+  const scheduler = options.scheduler ?? defaultScheduler;
+  const retryLimit = options.retryLimit ?? 3;
+  const debounce = options.debounceMs ?? 300;
+  if (!Number.isSafeInteger(retryLimit) || retryLimit < 0 || !Number.isFinite(debounce) || debounce < 0)
+    throw new TypeError("Invalid state scheduling limits");
+  let lifecycle = "new";
+  let epoch = 0;
+  let loadId = 0;
+  let localGeneration = 0;
+  let base = null;
+  let desired = null;
+  let blocked = null;
+  let pending = null;
+  let networkActive = false;
+  let acknowledgedGeneration = -1;
+  let activeSave = null;
+  let startWork = null;
+  let activeLoad = null;
+  let timer = null;
+  let subscription = null;
+  let remotePending = false;
+  let remoteSerial = 0;
+  let remoteHint = null;
+  let closing = false;
+  let checkpoint = null;
+  let recoverySource = null;
+  let automaticSuspensions = 0;
+  let automaticEpoch = 0;
+  let persistQueue = Promise.resolve();
+  let persistSerial = 0;
+  const abort = new AbortController;
+  const listeners = new Set;
+  let snapshot = { status: "loading", address };
+  const currentValue = (read) => read.status === "present" ? read.envelope.value : initial;
+  const dirty = () => base !== null && desired !== null && !definition.equal(currentValue(base), desired.value);
+  const needsSave = () => dirty() || base?.status === "empty" && options.initializeEmpty;
+  const active = (captured = epoch) => lifecycle === "active" && captured === epoch;
+  const clearTimer = () => {
+    timer?.();
+    timer = null;
+  };
+  const draft = () => base === null || desired === null ? null : frozen({ formatVersion: 1, key: { address, actor: expected.actor, ownerSession: options.ownerSession }, schemaVersion: definition.schemaVersion, acknowledged: base, desired: desired.value, localGeneration, inFlight: pending?.mutation ?? null });
+  function emit() {
+    if (lifecycle === "detached" || lifecycle === "disposed")
+      snapshot = { status: "detached", address, draft: draft() };
+    else if (blocked)
+      snapshot = { status: "blocked", address, ...blocked, draft: draft() };
+    else if (base && desired)
+      snapshot = { status: "ready", address, ownerSession: options.ownerSession, acknowledged: base, desired: desired.value, dirty: dirty(), saving: networkActive, localGeneration, remotePending };
+    else
+      snapshot = { status: "loading", address };
+    for (const listener of listeners) {
+      try {
+        listener();
+      } catch {}
+    }
+  }
+  function block(reason, message, conflict2 = null) {
+    clearTimer();
+    blocked = { reason, message, conflict: conflict2 };
+    emit();
+  }
+  function sessionCheck() {
+    if (!active())
+      return err("disposed", "This state controller is no longer active.");
+    const result = options.currentSession();
+    if (!result.ok) {
+      block("identity-unavailable", result.error.message);
+      return result;
+    }
+    const session = result.value;
+    if (session.status !== "ready") {
+      block("identity-unavailable", session.error.message);
+      return { ok: false, error: session.error };
+    }
+    if (session.instanceId !== address.instanceId || session.actor.identity.key !== expected.actor || session.stamp !== expected.session) {
+      block("owner-changed", "The identity session changed.");
+      return err("stale-context", "The identity session changed.", "after-refresh");
+    }
+    return ok(undefined);
+  }
+  async function safe(run) {
+    try {
+      return await run();
+    } catch (error) {
+      return err("unavailable", error instanceof Error ? error.message : "State operation failed.", "after-reconnect");
+    }
+  }
+  function persist(captured = draft()) {
+    if (!drafts)
+      return Promise.resolve(ok(null));
+    if (!captured)
+      return Promise.resolve(ok(null));
+    const capturedEpoch = epoch;
+    const serial = ++persistSerial;
+    const work = persistQueue.then(async () => {
+      const result = await safe(() => drafts.write(captured, checkpoint?.revision ?? null));
+      if (result.ok)
+        checkpoint = result.value;
+      else if (active(capturedEpoch) && serial === persistSerial)
+        block("storage-error", result.error.message);
+      return result;
+    });
+    persistQueue = work.then(() => {
+      return;
+    });
+    return work;
+  }
+  function schedule() {
+    clearTimer();
+    if (!active() || automaticSuspensions || closing || blocked || pending || !needsSave())
+      return;
+    timer = scheduler.schedule(debounce, () => {
+      timer = null;
+      sendNew(true);
+    });
+  }
+  function readClone(read) {
+    const decoded = codecs.read.decode(structuredClone(codecs.read.encode(read)));
+    if (!decoded.ok)
+      return decoded;
+    const value = decoded.value;
+    const returnedAddress = value.status === "present" ? value.envelope.address : value.address;
+    if (stateAddressKey(returnedAddress) !== stateAddressKey(address) || value.status === "present" && value.envelope.schemaVersion !== definition.schemaVersion)
+      return err("incompatible", "State response does not match this resource.");
+    return ok(frozen(value));
+  }
+  async function applyDecision(context, decision) {
+    if (!active() || blocked?.conflict?.token !== context.token)
+      return err("stale-context", "Conflict decision was superseded.");
+    if (decision.kind === "needs-review") {
+      block("conflict", decision.reason, context);
+      return ok(undefined);
+    }
+    if (context.remote.status === "migration-required") {
+      block("migration-required", "State migration is required.");
+      return err("conflict", "State migration is required.");
+    }
+    base = context.remote;
+    desired = { value: valueClone(codec, decision.kind === "rebase" ? decision.value : currentValue(base)) };
+    localGeneration++;
+    blocked = null;
+    emit();
+    const capturedEpoch = epoch;
+    const saved = await persist();
+    if (!saved.ok)
+      return saved;
+    if (active(capturedEpoch))
+      schedule();
+    return ok(undefined);
+  }
+  async function conflict(cause, remote, original) {
+    if (!desired)
+      return err("unavailable", "State has no local value.");
+    const context = frozen({ cause, token: newConflictToken(), ownerSession: options.ownerSession, base: original, local: desired.value, remote });
+    block("conflict", "Remote state conflicts with local intent.", context);
+    try {
+      return await applyDecision(context, options.onConflict(context));
+    } catch (error) {
+      if (blocked?.conflict?.token !== context.token)
+        return err("stale-context", "Conflict decision was superseded.");
+      block("conflict", error instanceof Error ? error.message : "Conflict policy failed.", context);
+      return err("conflict", "Conflict policy failed.");
+    }
+  }
+  async function applyRemote(read, cause) {
+    if (read.status === "migration-required") {
+      block("migration-required", "State migration is required.");
+      return err("conflict", "State migration is required.");
+    }
+    if (pending) {
+      remotePending = true;
+      emit();
+      return ok(undefined);
+    }
+    if (base && version(base).epoch === version(read).epoch && version(read).sequence < version(base).sequence)
+      return ok(undefined);
+    if (base && dirty()) {
+      if (sameVersion(base, read)) {
+        if (!blocked?.conflict)
+          blocked = null;
+        emit();
+        schedule();
+        return ok(undefined);
+      }
+      return conflict(cause, read, base);
+    }
+    base = read;
+    desired = { value: valueClone(codec, currentValue(read)) };
+    blocked = null;
+    emit();
+    schedule();
+    return ok(undefined);
+  }
+  function queueRemote() {
+    if (!active() || activeLoad || pending)
+      return;
+    reload("reconnect");
+  }
+  function reload(cause) {
+    const valid = sessionCheck();
+    if (!valid.ok)
+      return Promise.resolve(valid);
+    const capturedEpoch = epoch;
+    const id = ++loadId;
+    const serial = remoteSerial;
+    remotePending = false;
+    const work = (async () => {
+      const loaded = await safe(() => options.transport.load({ address, expected }, { signal: abort.signal }));
+      if (!active(capturedEpoch) || id !== loadId || serial !== remoteSerial)
+        return err("cancelled", "State load was superseded.");
+      const live = sessionCheck();
+      if (!live.ok)
+        return live;
+      if (!loaded.ok) {
+        block("storage-error", loaded.error.message);
+        return loaded;
+      }
+      const parsed = readClone(loaded.value);
+      if (!parsed.ok) {
+        block("storage-error", parsed.error.message);
+        return parsed;
+      }
+      return applyRemote(parsed.value, cause);
+    })();
+    activeLoad = work;
+    work.then(() => {
+      if (activeLoad === work) {
+        activeLoad = null;
+        if (active(capturedEpoch) && remoteSerial !== serial)
+          queueRemote();
+      }
+    });
+    return work;
+  }
+  function outcomeCheck(outcome, operationId) {
+    const parsed = codecs.save.decode(structuredClone(codecs.save.encode(outcome)));
+    if (!parsed.ok)
+      return parsed;
+    if (parsed.value.operationId !== operationId || parsed.value.status === "indeterminate")
+      return err("incompatible", "State receipt has a different operation.");
+    const read = "envelope" in parsed.value ? { status: "present", envelope: parsed.value.envelope } : parsed.value.current;
+    const checked = readClone(read);
+    return checked.ok ? ok(frozen(parsed.value)) : checked;
+  }
+  async function applyOutcome(captured, raw) {
+    const checked = outcomeCheck(raw, captured.mutation.operationId);
+    if (!checked.ok) {
+      block("indeterminate", checked.error.message);
+      return checked;
+    }
+    const outcome = checked.value;
+    pending = null;
+    loadId++;
+    blocked = null;
+    if (outcome.status === "saved" || outcome.status === "unchanged") {
+      base = { status: "present", envelope: outcome.envelope };
+      acknowledgedGeneration = Math.max(acknowledgedGeneration, captured.generation);
+      if (localGeneration === captured.generation)
+        desired = { value: valueClone(codec, outcome.envelope.value) };
+      emit();
+    } else if ("current" in outcome) {
+      if (outcome.current.status === "migration-required") {
+        block("migration-required", "State migration is required.");
+        return err("conflict", "State migration is required.");
+      }
+      if (outcome.status === "already-initialized" && localGeneration === captured.generation) {
+        base = outcome.current;
+        desired = { value: valueClone(codec, currentValue(base)) };
+        acknowledgedGeneration = captured.generation;
+        emit();
+      } else {
+        const result = await conflict("save-conflict", outcome.current, captured.base);
+        if (!result.ok)
+          return result;
+      }
+    }
+    const capturedEpoch = epoch;
+    const saved = await persist();
+    if (!saved.ok)
+      return saved;
+    if (active(capturedEpoch)) {
+      if (remotePending)
+        return reload("reconnect");
+      schedule();
+    }
+    return ok(undefined);
+  }
+  function transmit(captured, automatic = false) {
+    const capturedEpoch = epoch;
+    const dispatchEpoch = automaticEpoch;
+    let suppressed = false;
+    const work = (async () => {
+      networkActive = true;
+      emit();
+      const persisted = await persist();
+      if (!active(capturedEpoch))
+        return err("cancelled", "State save was detached.");
+      if (!persisted.ok) {
+        pending = null;
+        networkActive = false;
+        emit();
+        return persisted;
+      }
+      if (automatic && (automaticSuspensions || automaticEpoch !== dispatchEpoch)) {
+        suppressed = true;
+        if (pending === captured)
+          pending = null;
+        networkActive = false;
+        emit();
+        const saved = await persist();
+        return saved.ok ? ok(undefined) : saved;
+      }
+      const valid = sessionCheck();
+      if (!valid.ok) {
+        networkActive = false;
+        return valid;
+      }
+      const response = await safe(() => options.transport.save(captured.mutation, { signal: abort.signal }));
+      if (!active(capturedEpoch) || pending !== captured)
+        return err("cancelled", "State save was detached.");
+      networkActive = false;
+      const live = sessionCheck();
+      if (!live.ok)
+        return live;
+      if (!response.ok) {
+        block("indeterminate", response.error.message);
+        return response;
+      }
+      if (response.value.operationId !== captured.mutation.operationId) {
+        block("indeterminate", "State operation identity changed.");
+        return err("incompatible", "State operation identity changed.");
+      }
+      if (response.value.status === "indeterminate") {
+        block("indeterminate", "State save outcome is unknown.");
+        return err("unavailable", "State save outcome is unknown.", "same-operation");
+      }
+      return applyOutcome(captured, response.value);
+    })();
+    activeSave = work;
+    work.then(() => {
+      if (activeSave === work)
+        activeSave = null;
+      if (suppressed)
+        schedule();
+    });
+    return work;
+  }
+  function sendNew(automatic = false) {
+    if (automatic && automaticSuspensions)
+      return Promise.resolve(ok(undefined));
+    const valid = sessionCheck();
+    if (!valid.ok)
+      return Promise.resolve(valid);
+    if (blocked)
+      return Promise.resolve(err("conflict", blocked.message));
+    if (activeSave)
+      return activeSave;
+    if (pending)
+      return Promise.resolve(err("unavailable", "An earlier save needs reconciliation.", "same-operation"));
+    if (!base || !desired || !needsSave())
+      return Promise.resolve(ok(undefined));
+    const mutation = frozen({ kind: base.status === "empty" ? "initialize" : "replace", address, expectedVersion: { ...version(base) }, expected, ownerSession: options.ownerSession, localGeneration, operationId: newOperationId(), schemaVersion: definition.schemaVersion, value: valueClone(codec, desired.value) });
+    pending = { mutation, base, generation: localGeneration };
+    return transmit(pending, automatic);
+  }
+  let activeReconcile = null;
+  function reconcile(allowReplay) {
+    if (activeReconcile)
+      return activeReconcile;
+    const work = performReconcile(allowReplay);
+    activeReconcile = work;
+    const clear = () => {
+      if (activeReconcile === work)
+        activeReconcile = null;
+    };
+    work.then(clear, clear);
+    return work;
+  }
+  async function performReconcile(allowReplay) {
+    const captured = pending;
+    if (!captured)
+      return ok(undefined);
+    const capturedEpoch = epoch;
+    const valid = sessionCheck();
+    if (!valid.ok)
+      return valid;
+    const result = await safe(() => options.transport.reconcile({ address, expected, operationId: captured.mutation.operationId }, { signal: abort.signal }));
+    if (!active(capturedEpoch) || pending !== captured)
+      return err("cancelled", "State reconciliation was superseded.");
+    const live = sessionCheck();
+    if (!live.ok)
+      return live;
+    if (!result.ok) {
+      block("indeterminate", result.error.message);
+      return result;
+    }
+    if (result.value.status === "final")
+      return applyOutcome(captured, result.value.outcome);
+    if (result.value.status === "absent-final" && allowReplay) {
+      if (captured.mutation.expected.actor !== expected.actor || captured.mutation.expected.session !== expected.session) {
+        block("draft-recovery", "The original operation cannot be re-authored under a new session.");
+        return err("stale-context", "The original operation requires its original session.");
+      }
+      blocked = null;
+      return transmit(captured);
+    }
+    block("indeterminate", "The previous save remains unresolved; no replacement was sent.");
+    return err("unavailable", "The previous save remains unresolved.", "same-operation");
+  }
+  async function performFlush() {
+    clearTimer();
+    const valid = sessionCheck();
+    if (!valid.ok)
+      return valid;
+    const goal = localGeneration;
+    let retries = 0;
+    if (activeSave) {
+      const result = await activeSave;
+      if (!result.ok)
+        return result;
+    }
+    while (active()) {
+      if (pending) {
+        const result2 = await reconcile(retries++ < retryLimit);
+        if (!result2.ok)
+          return result2;
+      }
+      if (blocked)
+        return err("conflict", blocked.message);
+      if (!needsSave() || acknowledgedGeneration >= goal)
+        return ok(undefined);
+      const result = await sendNew();
+      if (!result.ok)
+        return result;
+    }
+    return err("disposed", "The state controller is detached.");
+  }
+  async function flush() {
+    let cancel = () => {};
+    const timeout = new Promise((resolve) => {
+      cancel = scheduler.schedule(30000, () => {
+        if (active())
+          block("indeterminate", "Flush timed out; pending intent is retained.");
+        resolve(err("unavailable", "Flush timed out; pending intent is retained.", "same-operation"));
+      });
+    });
+    try {
+      return await Promise.race([performFlush(), timeout]);
+    } finally {
+      cancel();
+    }
+  }
+  function detach() {
+    if (lifecycle === "detached" || lifecycle === "disposed")
+      return draft();
+    lifecycle = "detached";
+    epoch++;
+    loadId++;
+    clearTimer();
+    abort.abort();
+    subscription?.();
+    subscription = null;
+    emit();
+    return draft();
+  }
+  return {
+    getSnapshot: () => snapshot,
+    subscribe(listener) {
+      if (lifecycle === "disposed")
+        return () => {};
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    start() {
+      if (lifecycle === "detached" || lifecycle === "disposed")
+        return Promise.resolve(err("disposed", "Create a new state controller after detach."));
+      if (startWork)
+        return startWork;
+      lifecycle = "active";
+      subscription = options.transport.subscribe(address, (event) => {
+        if (!active() || stateAddressKey(event.address) !== stateAddressKey(address))
+          return;
+        if (base && event.version.epoch === version(base).epoch && event.version.sequence <= version(base).sequence)
+          return;
+        if (remoteHint && event.version.epoch === remoteHint.epoch && event.version.sequence <= remoteHint.sequence)
+          return;
+        remoteHint = { ...event.version };
+        remotePending = true;
+        remoteSerial++;
+        if (blocked?.conflict)
+          block("conflict", "Refreshing the remote state before reviewing this conflict.");
+        else
+          emit();
+        queueRemote();
+      });
+      startWork = reload("dirty-load");
+      return startWork;
+    },
+    edit(value) {
+      const valid = sessionCheck();
+      if (!valid.ok)
+        return valid;
+      if (closing || blocked || snapshot.status !== "ready")
+        return err("unavailable", "State is not editable.");
+      try {
+        desired = { value: valueClone(codec, value) };
+      } catch (error) {
+        return err("invalid-input", error instanceof Error ? error.message : "Invalid state.");
+      }
+      localGeneration++;
+      emit();
+      schedule();
+      return ok(undefined);
+    },
+    suspendAutomaticDispatch() {
+      automaticSuspensions++;
+      automaticEpoch++;
+      clearTimer();
+      let released = false;
+      return () => {
+        if (released)
+          return;
+        released = true;
+        automaticSuspensions--;
+        if (!automaticSuspensions)
+          schedule();
+      };
+    },
+    flush,
+    async reconnect(input) {
+      const valid = sessionCheck();
+      if (!valid.ok)
+        return valid;
+      const existing = activeSave ?? activeReconcile ?? activeLoad;
+      if (input?.reuseInFlight && existing)
+        return existing;
+      if (activeSave) {
+        const settled = await activeSave;
+        if (!settled.ok && !pending)
+          return settled;
+      }
+      if (pending) {
+        const result = await reconcile(false);
+        if (!result.ok)
+          return result;
+      }
+      return reload("reconnect");
+    },
+    async resolveConflict(token, decision) {
+      const valid = sessionCheck();
+      if (!valid.ok)
+        return valid;
+      const context = blocked?.conflict;
+      if (!context || context.token !== token)
+        return err("stale-context", "Conflict decision was superseded.");
+      return applyDecision(context, decision);
+    },
+    async recover(candidate) {
+      if (!drafts)
+        return err("unsupported", "Draft recovery is disabled for this state.");
+      const valid = sessionCheck();
+      if (!valid.ok)
+        return valid;
+      if (activeSave || pending || dirty())
+        return err("conflict", "Resolve current edits before recovering another draft.");
+      const source = candidate.draft;
+      if (source.formatVersion !== 1 || source.key.actor !== expected.actor || source.schemaVersion !== definition.schemaVersion || stateAddressKey(source.key.address) !== stateAddressKey(address))
+        return err("invalid-input", "Draft does not match this resource and actor.");
+      const parsed = readClone(source.acknowledged);
+      if (!parsed.ok || parsed.value.status === "migration-required")
+        return err("invalid-input", "Draft base is invalid.");
+      let mutation = null;
+      if (source.inFlight) {
+        const result = codecs.mutation.decode(structuredClone(codecs.mutation.encode(source.inFlight)));
+        if (!result.ok || stateAddressKey(result.value.address) !== stateAddressKey(address) || result.value.schemaVersion !== definition.schemaVersion || result.value.expected.actor !== expected.actor || result.value.localGeneration > source.localGeneration)
+          return err("invalid-input", "Draft operation does not match its owner or generation.");
+        mutation = frozen(result.value);
+      }
+      clearTimer();
+      base = parsed.value;
+      desired = { value: valueClone(codec, source.desired) };
+      localGeneration = source.localGeneration;
+      recoverySource = frozen(structuredClone(candidate));
+      checkpoint = source.key.ownerSession === options.ownerSession ? recoverySource : null;
+      if (mutation) {
+        pending = { mutation, base, generation: mutation.localGeneration };
+        block("draft-recovery", "Reconciling the original operation.");
+        const result = await reconcile(false);
+        if (!result.ok)
+          return result;
+      }
+      const capturedEpoch = epoch;
+      const loaded = await reload("draft-recovery");
+      if (!loaded.ok || !active(capturedEpoch))
+        return loaded;
+      return ok(undefined);
+    },
+    async discardRecovery(candidate) {
+      if (!drafts)
+        return err("unsupported", "Draft recovery is disabled for this state.");
+      if (!active())
+        return err("disposed", "This state controller is no longer active.");
+      const source = candidate.draft;
+      if (source.formatVersion !== 1 || source.key.actor !== expected.actor || source.schemaVersion !== definition.schemaVersion || stateAddressKey(source.key.address) !== stateAddressKey(address)) {
+        return err("invalid-input", "Draft does not match this resource and actor.");
+      }
+      const removed = await safe(() => drafts.remove(source.key, candidate.revision));
+      if (!removed.ok || !active())
+        return removed.ok ? err("disposed", "This state controller is no longer active.") : removed;
+      const sameCheckpoint = (entry) => entry !== null && entry.revision === candidate.revision && entry.draft.key.actor === source.key.actor && entry.draft.key.ownerSession === source.key.ownerSession && stateAddressKey(entry.draft.key.address) === stateAddressKey(source.key.address);
+      if (sameCheckpoint(checkpoint))
+        checkpoint = null;
+      if (sameCheckpoint(recoverySource))
+        recoverySource = null;
+      return ok(undefined);
+    },
+    async recoveryCandidates(readOptions) {
+      if (readOptions?.signal?.aborted)
+        return err("cancelled", "Recovery lookup was cancelled.");
+      if (!drafts)
+        return ok([]);
+      const result = await safe(() => drafts.find(address, expected.actor, 20));
+      if (readOptions?.signal?.aborted)
+        return err("cancelled", "Recovery lookup was cancelled.");
+      return result;
+    },
+    checkpoint: () => persist(),
+    detach,
+    async close(input) {
+      if (!drafts) {
+        detach();
+        return ok(undefined);
+      }
+      if (input.pending === "flush") {
+        closing = true;
+        const result = await flush();
+        const retained2 = detach();
+        if (!result.ok) {
+          await persist(retained2);
+          return result;
+        }
+        return ok(undefined);
+      }
+      const retained = detach();
+      if (input.pending === "preserve") {
+        const result = await persist(retained);
+        return result.ok ? ok(undefined) : result;
+      }
+      await persistQueue;
+      const candidates = new Map;
+      for (const entry of [checkpoint, recoverySource])
+        if (entry)
+          candidates.set(JSON.stringify(entry.draft.key), entry);
+      for (const entry of candidates.values()) {
+        const removed = await safe(() => drafts.remove(entry.draft.key, entry.revision));
+        if (!removed.ok)
+          return removed;
+      }
+      return ok(undefined);
+    },
+    dispose() {
+      detach();
+      lifecycle = "disposed";
+      listeners.clear();
+    }
+  };
+}
+
+// rpc-routes-runtime.ts
+var identityRoutes = Object.freeze({
+  bootstrap: "bb-identity/v1/bootstrap",
+  selfProfile: "bb-identity/v1/selfProfile",
+  search: "bb-identity/v1/search",
+  profiles: "bb-identity/v1/profiles",
+  participants: "bb-identity/v1/participants",
+  participantPreviews: "bb-identity/v1/participantPreviews"
+});
+var identityStateRoutes = Object.freeze({
+  load: "bb-identity/v1/state/load",
+  save: "bb-identity/v1/state/save",
+  reconcile: "bb-identity/v1/state/reconcile"
+});
+var identityStateRpcMethods = Object.freeze({
+  [identityStateRoutes.load]: "bb-identity.v1.state.load",
+  [identityStateRoutes.save]: "bb-identity.v1.state.save",
+  [identityStateRoutes.reconcile]: "bb-identity.v1.state.reconcile"
+});
+var identityRpcMethods = Object.freeze({
+  [identityRoutes.bootstrap]: "bb-identity.v1.bootstrap",
+  [identityRoutes.selfProfile]: "bb-identity.v1.selfProfile",
+  [identityRoutes.search]: "bb-identity.v1.search",
+  [identityRoutes.profiles]: "bb-identity.v1.profiles",
+  [identityRoutes.participants]: "bb-identity.v1.participants",
+  [identityRoutes.participantPreviews]: "bb-identity.v1.participantPreviews",
+  ...identityStateRpcMethods
+});
+
+// state-transport-runtime.ts
+function writeUnavailable(connection) {
+  const health = connection.getHealth();
+  if (health.identity.status === "healthy" && health.state.status === "healthy")
+    return null;
+  const failed = health.identity.status === "unavailable" ? health.identity : health.state.status === "unavailable" ? health.state : null;
+  return failed ? err(failed.error.code, failed.error.message, failed.error.retry) : err("unavailable", "Identity and state links must be healthy before writing.", "after-reconnect");
+}
+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 typeof value === "object" && value !== null && typeof value.code === "string" && codes.has(value.code) && typeof value.message === "string" && typeof value.retry === "string" && retries.has(value.retry) ? ok(value) : err("incompatible", "Malformed state route error.");
+}
+function decodeResult(value, decode) {
+  if (!value || typeof value !== "object" || typeof value.ok !== "boolean")
+    return err("incompatible", "Malformed state route Result.");
+  if (!value.ok) {
+    const failure2 = decodeError(value.error);
+    return failure2.ok ? { ok: false, error: failure2.value } : failure2;
+  }
+  return decode(value.value);
+}
+function createStateTransport(options) {
+  const codecs = stateCodecs(options.resource.definition.codec);
+  const request = async (method, payload, decode, readOptions) => {
+    if (readOptions?.signal?.aborted)
+      return err("cancelled", "State request was cancelled.");
+    try {
+      return decodeResult(await options.connection.request(method, payload, readOptions), decode);
+    } catch {
+      return err("unavailable", "State route request failed.", "after-reconnect");
+    }
+  };
+  return {
+    load(input, readOptions) {
+      return request(identityStateRoutes.load, { address: input.address, expected: input.expected }, codecs.read.decode, readOptions);
+    },
+    async save(input, readOptions) {
+      const normalized = codecs.mutation.decode(structuredClone(codecs.mutation.encode(input)));
+      if (!normalized.ok)
+        return normalized;
+      if (normalized.value.address.pluginId !== options.resource.pluginId || normalized.value.address.collection !== options.resource.definition.collection || normalized.value.schemaVersion !== options.resource.definition.schemaVersion) {
+        return err("invalid-input", "State mutation does not match this resource.");
+      }
+      const unavailable = writeUnavailable(options.connection);
+      if (unavailable)
+        return unavailable;
+      const refreshed = await options.connection.revalidate(readOptions);
+      if (!refreshed.ok)
+        return refreshed;
+      const after = writeUnavailable(options.connection);
+      if (after)
+        return after;
+      const response = await request(identityStateRoutes.save, codecs.mutation.encode(normalized.value), codecs.save.decode, readOptions);
+      if (!response.ok)
+        return response;
+      const outcome = response.value;
+      if (outcome.operationId !== normalized.value.operationId)
+        return err("incompatible", "State route returned a different operation.");
+      if (outcome.status === "indeterminate")
+        return response;
+      const read = "envelope" in outcome ? { status: "present", envelope: outcome.envelope } : outcome.current;
+      const actual = read.status === "present" ? read.envelope.address : read.address;
+      if (actual.instanceId !== normalized.value.address.instanceId || actual.pluginId !== normalized.value.address.pluginId || actual.collection !== normalized.value.address.collection || actual.recordId !== normalized.value.address.recordId || actual.owner !== normalized.value.address.owner || read.status === "present" && read.envelope.schemaVersion !== normalized.value.schemaVersion)
+        return err("incompatible", "State route returned a mismatched resource record.");
+      return response;
+    },
+    reconcile(input, readOptions) {
+      return request(identityStateRoutes.reconcile, { address: input.address, expected: input.expected, operationId: input.operationId }, codecs.lookup.decode, readOptions);
+    },
+    subscribe(address, listener) {
+      return options.connection.subscribe((event) => {
+        if (event.kind !== "state")
+          return;
+        const value = codecs.invalidation.decode(event.event);
+        if (value.ok && value.value.address.instanceId === address.instanceId && value.value.address.pluginId === address.pluginId && value.value.address.collection === address.collection && value.value.address.recordId === address.recordId && value.value.address.owner === address.owner)
+          listener(value.value);
+      });
+    }
+  };
+}
+
+// client-state-binding-runtime.ts
+var waiting = Object.freeze({ status: "waiting-for-identity" });
+function bindIdentityState(options, retirementOwner) {
+  let disposed = false;
+  let viewDisposed = false;
+  let current = null;
+  let pause = null;
+  let snapshot = waiting;
+  let stateHealthy = options.client.connection.getHealth().state.status === "healthy";
+  const listeners = new Set;
+  const retirements = new Map;
+  const publish = () => {
+    for (const listener of [...listeners]) {
+      try {
+        listener();
+      } catch {}
+    }
+  };
+  const hasPending = (state) => state.status === "ready" ? state.dirty || state.saving : (state.status === "blocked" || state.status === "detached") && state.draft !== null;
+  const live = () => {
+    if (disposed || viewDisposed)
+      return null;
+    const result = options.client.currentSession();
+    if (!result.ok || result.value.status !== "ready")
+      return null;
+    const session = result.value;
+    const view = options.view.getSnapshot();
+    if (options.target === "viewed-subject" && (view.status !== "ready" || view.session.instanceId !== session.instanceId || view.session.stamp !== session.stamp || view.session.actor.identity.key !== session.actor.identity.key))
+      return null;
+    const subject = options.target === "viewed-subject" && view.status === "ready" ? view.subject : session.actor.identity;
+    return {
+      session,
+      subject,
+      key: JSON.stringify([session.instanceId, session.actor.identity.key, session.stamp, subject.key]),
+      writable: options.editPolicy === "collaborators" || subject.key === session.actor.identity.key
+    };
+  };
+  const valid = (entry) => !disposed && current === entry && live()?.key === entry.key;
+  const failedPreservation = (draft, error) => {
+    if (draft) {
+      try {
+        options.onUnpersistedDraft?.(draft, error);
+      } catch {}
+    }
+  };
+  const retire = (reason, pending = "preserve") => {
+    const entry = current;
+    if (!entry)
+      return;
+    current = null;
+    pause = null;
+    entry.stop();
+    const preserve = hasPending(entry.controller.getSnapshot());
+    const draft = entry.controller.detach(reason);
+    snapshot = entry.controller.getSnapshot();
+    if (!preserve && pending !== "discard") {
+      entry.controller.dispose();
+      publish();
+      return;
+    }
+    const group = retirements.get(entry.recoveryKey) ?? new Set;
+    retirements.set(entry.recoveryKey, group);
+    const task = Promise.resolve().then(() => entry.controller.close({ pending })).then((result) => {
+      if (!result.ok)
+        failedPreservation(draft, result.error);
+      return result;
+    }, () => {
+      const failure2 = err("unavailable", "Draft preservation failed.", "after-refresh");
+      if (!failure2.ok)
+        failedPreservation(draft, failure2.error);
+      return failure2;
+    }).finally(() => {
+      entry.controller.dispose();
+      group.delete(task);
+      if (!group.size)
+        retirements.delete(entry.recoveryKey);
+      if (!disposed)
+        publish();
+    });
+    group.add(task);
+    if (entry.preservation)
+      retirementOwner?.begin(entry.preservation.storage, entry.preservation.scope, task);
+    publish();
+  };
+  let observing = false;
+  let observeAgain = false;
+  const observe = () => {
+    if (disposed || viewDisposed)
+      return;
+    if (observing) {
+      observeAgain = true;
+      return;
+    }
+    observing = true;
+    try {
+      do {
+        observeAgain = false;
+        const next = live();
+        if (!next) {
+          retire("identity-invalidated");
+          return;
+        }
+        if (current?.key === next.key)
+          return;
+        retire("identity-invalidated");
+        if (live()?.key !== next.key) {
+          observeAgain = true;
+          continue;
+        }
+        const owner = idCodec("owner-session").decode(`owner-${newOperationId()}`);
+        if (!owner.ok)
+          throw new Error(owner.error.message);
+        const controller = options.create ? options.create({ session: next.session, subject: next.subject, ownerSession: owner.value }) : createIdentityState({
+          address: {
+            instanceId: next.session.instanceId,
+            pluginId: options.resource.pluginId,
+            collection: options.resource.definition.collection,
+            recordId: options.recordId,
+            owner: next.subject.key
+          },
+          expected: { actor: next.session.actor.identity.key, session: next.session.stamp },
+          ownerSession: owner.value,
+          definition: options.resource.definition,
+          transport: createStateTransport({ connection: options.client.connection, resource: options.resource }),
+          ...options.drafts ? { drafts: options.drafts } : {},
+          onConflict: options.onConflict,
+          initializeEmpty: next.writable && options.initializeEmpty,
+          ...options.scheduler ? { scheduler: options.scheduler } : {},
+          currentSession: () => options.client.currentSession()
+        });
+        if (live()?.key !== next.key) {
+          controller.dispose();
+          observeAgain = true;
+          continue;
+        }
+        const preservation = options.resource && options.drafts ? { storage: options.drafts, scope: {
+          address: controller.getSnapshot().address,
+          actor: next.session.actor.identity.key,
+          schemaVersion: options.resource.definition.schemaVersion
+        } } : null;
+        const entry = { key: next.key, recoveryKey: JSON.stringify([next.session.instanceId, next.session.actor.identity.key, next.subject.key]), owner: owner.value, controller, stop: () => {}, writable: next.writable, reconnect: null, preservation };
+        current = entry;
+        const update = () => {
+          if (valid(entry)) {
+            snapshot = controller.getSnapshot();
+            publish();
+          }
+        };
+        entry.stop = controller.subscribe(update);
+        update();
+        controller.start().then(update, update);
+      } while (observeAgain && !disposed && !viewDisposed);
+    } finally {
+      observing = false;
+    }
+  };
+  const command = async (owner, run, write = false) => {
+    const entry = current;
+    if (!entry || owner !== entry.owner || !valid(entry))
+      return err("stale-context", "State controller ownership changed.");
+    if (write && (!entry.writable || pause))
+      return err("unsupported", "The selected state is not editable during this view or transition.");
+    let result;
+    try {
+      result = await run(entry.controller);
+    } catch {
+      result = err("unavailable", "State operation failed.", "after-refresh");
+    }
+    return valid(entry) ? result : err("stale-context", "State controller ownership changed.");
+  };
+  const reconnect = (owner) => {
+    const entry = current;
+    if (entry === null) {
+      return Promise.resolve(err("stale-context", "State controller ownership changed or is not writable."));
+    }
+    const eligible = () => current === entry && entry.owner === owner && valid(entry) && entry.writable && pause === null;
+    if (!eligible()) {
+      return Promise.resolve(err("stale-context", "State controller ownership changed or is not writable."));
+    }
+    if (entry.reconnect) {
+      return entry.reconnect.then((result) => eligible() ? result : err("stale-context", "State controller ownership changed."));
+    }
+    const work = (async () => {
+      if (!eligible())
+        return err("stale-context", "State controller ownership changed or is not writable.");
+      let verified;
+      try {
+        verified = await options.client.connection.revalidate();
+      } catch {
+        verified = err("unavailable", "State connection revalidation failed.", "after-refresh");
+      }
+      if (!eligible())
+        return err("stale-context", "State controller ownership changed.");
+      if (!verified.ok)
+        return verified;
+      let recovered;
+      try {
+        recovered = await entry.controller.reconnect();
+      } catch {
+        recovered = err("unavailable", "State reconciliation failed.", "after-refresh");
+      }
+      return eligible() ? recovered : err("stale-context", "State controller ownership changed.");
+    })();
+    entry.reconnect = work;
+    work.finally(() => {
+      if (entry.reconnect === work)
+        entry.reconnect = null;
+    });
+    return work;
+  };
+  const guard = {
+    invalidate(reason) {
+      if (reason === "disposed")
+        viewDisposed = true;
+      retire("identity-invalidated");
+    },
+    inspect(transition) {
+      const entry = current;
+      const unaffected = options.target === "actor" || !entry;
+      if (!unaffected && transition.pending === "block" && hasPending(entry.controller.getSnapshot()))
+        return err("conflict", "Resolve or preserve pending edits before changing view.");
+      const token = {};
+      let committed = false;
+      let resume = null;
+      return ok({
+        async prepare() {
+          if (unaffected)
+            return ok(undefined);
+          if (!valid(entry) || transition.signal.aborted)
+            return err("stale-context", "View transition expired.");
+          pause = token;
+          resume = entry.controller.suspendAutomaticDispatch();
+          if (transition.pending === "block" && hasPending(entry.controller.getSnapshot()))
+            return err("conflict", "New edits arrived before the view transition.");
+          const result = transition.pending === "flush" ? await entry.controller.flush() : transition.pending === "preserve" ? await entry.controller.checkpoint() : ok(undefined);
+          if (!result.ok)
+            return result;
+          return valid(entry) && !transition.signal.aborted ? ok(undefined) : err("stale-context", "View transition expired.");
+        },
+        commit() {
+          committed = true;
+          if (!unaffected && current === entry)
+            retire("view-change", transition.pending === "discard" ? "discard" : "preserve");
+          resume?.();
+          resume = null;
+          if (pause === token)
+            pause = null;
+        },
+        cancel() {
+          if (!committed && pause === token)
+            pause = null;
+          resume?.();
+          resume = null;
+        }
+      });
+    }
+  };
+  const stopGuard = options.view.registerGuard(guard);
+  const stopView = options.view.subscribe(observe);
+  const stopClient = options.client.subscribe(observe);
+  const stopHealth = options.client.connection.subscribeHealth(() => {
+    const healthy = options.client.connection.getHealth().state.status === "healthy";
+    const reconnect2 = healthy && !stateHealthy;
+    stateHealthy = healthy;
+    const entry = current;
+    if (reconnect2 && entry && valid(entry))
+      entry.controller.reconnect({ reuseInFlight: true });
+  });
+  observe();
+  return {
+    getSnapshot: () => snapshot,
+    subscribe(listener) {
+      if (disposed)
+        return () => {};
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    currentOwnerSession: () => current?.owner ?? null,
+    edit(value) {
+      const entry = current;
+      if (!entry || !valid(entry))
+        return err("stale-context", "State identity is not ready.");
+      return entry.writable && !pause ? entry.controller.edit(value) : err("unsupported", "The selected state is read-only or changing view.");
+    },
+    flush() {
+      return current ? command(current.owner, (controller) => controller.flush(), true) : Promise.resolve(err("stale-context", "State identity is not ready."));
+    },
+    reconnect(owner) {
+      return reconnect(owner);
+    },
+    recoveryCandidates(owner, readOptions) {
+      const entry = current;
+      return command(owner, async (controller) => {
+        if (!entry)
+          return err("stale-context", "State controller ownership changed.");
+        if (entry.preservation && retirementOwner) {
+          const settled = await retirementOwner.wait(entry.preservation.storage, entry.preservation.scope, readOptions?.signal);
+          if (!settled.ok)
+            return settled;
+        }
+        while (retirements.get(entry.recoveryKey)?.size) {
+          if (!valid(entry))
+            return err("stale-context", "State controller ownership changed.");
+          if (readOptions?.signal?.aborted)
+            return err("cancelled", "Recovery lookup was cancelled.");
+          const pending = Promise.all([...retirements.get(entry.recoveryKey)]);
+          if (readOptions?.signal) {
+            const signal = readOptions.signal;
+            await new Promise((resolve) => {
+              const done = () => {
+                signal.removeEventListener("abort", done);
+                resolve();
+              };
+              signal.addEventListener("abort", done, { once: true });
+              pending.then(done);
+              if (signal.aborted)
+                done();
+            });
+          } else
+            await pending;
+        }
+        if (!valid(entry))
+          return err("stale-context", "State controller ownership changed.");
+        return controller.recoveryCandidates(readOptions);
+      });
+    },
+    checkpoint(owner) {
+      return command(owner, (controller) => controller.checkpoint());
+    },
+    recover(owner, checkpoint) {
+      return command(owner, (controller) => controller.recover(checkpoint), true);
+    },
+    discardRecovery(owner, checkpoint) {
+      return command(owner, (controller) => controller.discardRecovery(checkpoint), true);
+    },
+    resolveConflict(owner, token, decision) {
+      return command(owner, (controller) => controller.resolveConflict(token, decision), true);
+    },
+    dispose() {
+      if (disposed)
+        return;
+      disposed = true;
+      stopGuard();
+      stopView();
+      stopClient();
+      stopHealth();
+      retire("unmount");
+      listeners.clear();
+    }
+  };
+}
+
+// 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 isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function decodeError2(value) {
+  if (!isRecord3(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 isRecord3(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 (!isRecord3(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 (isRecord3(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 (!isRecord3(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?.();
+    }
+  };
+}
+
+// host-runtime.ts
+function isRecord4(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isPresentation(value) {
+  return isRecord4(value) && typeof value.displayName === "string" && (value.handle === null || typeof value.handle === "string") && (value.avatarUrl === null || typeof value.avatarUrl === "string");
+}
+function isPersonIdentity(value) {
+  if (!isRecord4(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 isRecord4(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 isRecord4(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") && isRecord4(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";
+}
+var serverSessionCodec = {
+  decode(input) {
+    if (!isRecord4(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") && isRecord4(input.error)) {
+        return ok(input);
+      }
+      return err("invalid-input", "Invalid unavailable server session.");
+    }
+    if (!isRecord4(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;
+  }
+};
+
+// bb-client-connection-runtime.ts
+var nativeIdentityRealtimeChannel = "bb-identity/v1";
+function unavailable(message) {
+  return { status: "unavailable", error: { code: "unavailable", message, retry: "after-reconnect" } };
+}
+function link(state) {
+  return state === "connected" ? { status: "healthy" } : { status: state };
+}
+function sameLink(left, right) {
+  return left.status === right.status && (left.status !== "unavailable" || right.status === "unavailable" && left.error.code === right.error.code && left.error.message === right.error.message && left.error.retry === right.error.retry);
+}
+function cloneLink(value) {
+  return value.status === "unavailable" ? { status: "unavailable", error: { ...value.error } } : { status: value.status };
+}
+function decodeError3(value) {
+  if (!value || typeof value !== "object")
+    return err("incompatible", "Malformed native identity error.");
+  const error = 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 typeof error.code === "string" && codes.has(error.code) && typeof error.message === "string" && typeof error.retry === "string" && retries.has(error.retry) ? ok({ code: error.code, message: error.message, retry: error.retry }) : err("incompatible", "Malformed native identity error.");
+}
+function decodeBootstrap(value) {
+  if (!value || typeof value !== "object" || typeof value.ok !== "boolean")
+    return err("incompatible", "Malformed bootstrap Result.");
+  if (!value.ok) {
+    const failure2 = decodeError3(value.error);
+    return failure2.ok ? { ok: false, error: failure2.value } : failure2;
+  }
+  return serverSessionCodec.decode(value.value);
+}
+function isStateRoute(route) {
+  return route.includes("/state/");
+}
+function isSessionInvalidation(value) {
+  return !!value && typeof value === "object" && value.kind === "session";
+}
+function waitFor(flight, signal) {
+  if (!signal)
+    return flight;
+  if (signal.aborted)
+    return Promise.resolve(err("cancelled", "Native identity revalidation was cancelled."));
+  return new Promise((resolve) => {
+    const abort = () => {
+      signal.removeEventListener("abort", abort);
+      resolve(err("cancelled", "Native identity revalidation was cancelled."));
+    };
+    signal.addEventListener("abort", abort, { once: true });
+    flight.then((result) => {
+      signal.removeEventListener("abort", abort);
+      resolve(result);
+    });
+  });
+}
+function createNativeIdentityConnection(options) {
+  let disposed = false;
+  let nativeState = options.realtimeState;
+  let health = { generation: 0, identity: link(nativeState), state: link(nativeState) };
+  let verified = null;
+  let authorityEpoch = 0;
+  let bootstrapAttempt = 0;
+  let revalidateFlight = null;
+  const events = new Set;
+  const healthListeners = new Set;
+  const emitHealth = () => {
+    for (const listener of [...healthListeners])
+      try {
+        listener();
+      } catch {}
+  };
+  const emit = (payload) => {
+    for (const listener of [...events])
+      try {
+        listener(payload);
+      } catch {}
+  };
+  const changeHealth = (next) => {
+    if (sameLink(health.identity, next.identity) && sameLink(health.state, next.state))
+      return;
+    health = { generation: health.generation + 1, identity: cloneLink(next.identity), state: cloneLink(next.state) };
+    emitHealth();
+  };
+  const fail = (target, message) => {
+    const next = { identity: health.identity, state: health.state };
+    next[target] = unavailable(message);
+    const lostAuthority = target === "identity" && health.identity.status === "healthy";
+    changeHealth(next);
+    if (lostAuthority)
+      emit({ kind: "disconnected" });
+  };
+  const inputs = {
+    async request(route, input, readOptions) {
+      if (disposed || readOptions?.signal?.aborted)
+        throw new Error("Native identity request was cancelled.");
+      const method = Object.hasOwn(identityRpcMethods, route) ? identityRpcMethods[route] : undefined;
+      if (!method)
+        throw new Error(`Unsupported identity route ${route}.`);
+      const current = authorityEpoch;
+      try {
+        const value = await options.rpc.call(method, input);
+        if (disposed || current !== authorityEpoch || readOptions?.signal?.aborted)
+          throw new Error("Native identity request became stale.");
+        if (route === identityRoutes.bootstrap) {
+          const checked = decodeBootstrap(value);
+          if (checked.ok && checked.value.status === "ready") {
+            const next = { instanceId: checked.value.instanceId, actor: checked.value.actor.identity.key, stamp: checked.value.stamp };
+            const changed = verified !== null && (verified.instanceId !== next.instanceId || verified.actor !== next.actor || verified.stamp !== next.stamp);
+            if (changed) {
+              verified = next;
+              authorityEpoch++;
+              if (disposed || nativeState !== "connected")
+                throw new Error("Native bootstrap became stale.");
+            } else
+              verified = next;
+          }
+        }
+        if (isStateRoute(route) && health.state.status !== "healthy")
+          changeHealth({ identity: health.identity, state: { status: "healthy" } });
+        return value;
+      } catch (cause) {
+        if (disposed || current !== authorityEpoch || readOptions?.signal?.aborted)
+          throw cause;
+        fail(isStateRoute(route) ? "state" : "identity", cause instanceof Error ? cause.message : "Native identity request failed.");
+        throw cause;
+      }
+    },
+    subscribe(listener) {
+      events.add(listener);
+      return () => events.delete(listener);
+    },
+    getHealth: () => health,
+    subscribeHealth(listener) {
+      healthListeners.add(listener);
+      return () => healthListeners.delete(listener);
+    },
+    async revalidate(readOptions) {
+      if (disposed)
+        return err("disposed", "Native identity connection is disposed.");
+      if (readOptions?.signal?.aborted)
+        return err("cancelled", "Native identity revalidation was cancelled.");
+      if (nativeState !== "connected")
+        return err("unavailable", "Native realtime is not connected.", "after-reconnect");
+      if (revalidateFlight)
+        return waitFor(revalidateFlight, readOptions?.signal);
+      const currentAuthority = authorityEpoch;
+      const currentAttempt = ++bootstrapAttempt;
+      const flight = (async () => {
+        try {
+          const response = await options.rpc.call(identityRpcMethods[identityRoutes.bootstrap], {});
+          const checked = decodeBootstrap(response);
+          if (disposed)
+            return err("disposed", "Native identity connection is disposed.");
+          if (currentAuthority !== authorityEpoch || currentAttempt !== bootstrapAttempt || nativeState !== "connected")
+            return err("stale-context", "Native identity authority changed during bootstrap.");
+          if (!checked.ok) {
+            fail("identity", checked.error.message);
+            return checked;
+          }
+          if (checked.value.status !== "ready") {
+            fail("identity", checked.value.error.message);
+            return err(checked.value.error.code, checked.value.error.message, checked.value.error.retry);
+          }
+          const next = { instanceId: checked.value.instanceId, actor: checked.value.actor.identity.key, stamp: checked.value.stamp };
+          const changed = verified !== null && (verified.instanceId !== next.instanceId || verified.actor !== next.actor || verified.stamp !== next.stamp);
+          if (changed) {
+            verified = next;
+            const publishedEpoch = ++authorityEpoch;
+            changeHealth({ identity: { status: "connecting" }, state: health.state });
+            emit({ kind: "session" });
+            if (disposed || publishedEpoch !== authorityEpoch || nativeState !== "connected")
+              return err("stale-context", "Native identity authority changed during session notification.");
+          } else
+            verified = next;
+          changeHealth({ identity: { status: "healthy" }, state: health.state });
+          return ok(undefined);
+        } catch (cause) {
+          if (disposed)
+            return err("disposed", "Native identity connection is disposed.");
+          if (currentAuthority !== authorityEpoch || currentAttempt !== bootstrapAttempt || nativeState !== "connected")
+            return err("stale-context", "Native identity authority changed during bootstrap.");
+          fail("identity", cause instanceof Error ? cause.message : "Native bootstrap failed.");
+          return err("unavailable", "Native bootstrap failed.", "after-reconnect");
+        }
+      })();
+      revalidateFlight = flight;
+      flight.finally(() => {
+        if (revalidateFlight === flight)
+          revalidateFlight = null;
+      });
+      return waitFor(flight, readOptions?.signal);
+    },
+    dispose() {
+      disposed = true;
+      authorityEpoch++;
+      bootstrapAttempt++;
+      revalidateFlight = null;
+      events.clear();
+      healthListeners.clear();
+    }
+  };
+  const connection = createIdentityConnection(inputs);
+  return {
+    connection,
+    acceptRealtime(payload) {
+      if (disposed)
+        return;
+      if (isSessionInvalidation(payload)) {
+        authorityEpoch++;
+        bootstrapAttempt++;
+        revalidateFlight = null;
+        verified = null;
+        changeHealth({ identity: { status: "connecting" }, state: health.state });
+      }
+      emit(payload);
+    },
+    setRealtimeState(state) {
+      if (disposed || state === nativeState)
+        return;
+      const wasConnected = nativeState === "connected";
+      nativeState = state;
+      authorityEpoch++;
+      bootstrapAttempt++;
+      revalidateFlight = null;
+      if (state === "connected") {
+        changeHealth({ identity: { status: "connecting" }, state: health.state.status === "healthy" ? health.state : { status: "reconnecting" } });
+        if (!wasConnected)
+          emit({ kind: "reconnected" });
+      } else {
+        const next = link(state);
+        const lostAuthority = health.identity.status === "healthy";
+        changeHealth({ identity: next, state: next });
+        if (lostAuthority)
+          emit({ kind: "disconnected" });
+      }
+    },
+    dispose() {
+      connection.dispose();
+    }
+  };
+}
+
+// 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 decodeError4(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 decodeResult2(value, decode) {
+  if (!isRecord5(value) || typeof value.ok !== "boolean")
+    return err("incompatible", "Malformed identity route Result.");
+  if (!value.ok) {
+    const failure2 = decodeError4(value.error);
+    return failure2.ok ? { ok: false, error: failure2.value } : failure2;
+  }
+  return decode(value.value);
+}
+function unavailable2(connection) {
+  const link2 = connection.getHealth().identity;
+  if (link2.status === "unavailable")
+    return err(link2.error.code, link2.error.message, link2.error.retry);
+  return link2.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 decodeParticipantPage(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 decodeResult2(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, decodeParticipantPage, 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);
+      });
+    }
+  };
+}
+function waitFor2(promise, signal) {
+  if (!signal)
+    return promise;
+  if (signal.aborted)
+    return Promise.resolve(err("cancelled", "Identity read was cancelled."));
+  return new Promise((resolve) => {
+    const abort = () => {
+      signal.removeEventListener("abort", abort);
+      resolve(err("cancelled", "Identity read was cancelled."));
+    };
+    signal.addEventListener("abort", abort, { once: true });
+    promise.then((result) => {
+      signal.removeEventListener("abort", abort);
+      resolve(result);
+    });
+  });
+}
+function profileKey(query) {
+  return JSON.stringify(query);
+}
+function createIdentityClient(options) {
+  const transport = createIdentityClientTransport(options.connection);
+  const now = () => options.scheduler?.now() ?? Date.now();
+  const cacheMax = options.profileCache?.maxEntries ?? 512;
+  const staleAfter = options.profileCache?.staleAfterMs ?? 60000;
+  if (!Number.isSafeInteger(cacheMax) || cacheMax <= 0 || !Number.isFinite(staleAfter) || staleAfter < 0) {
+    throw new RangeError("profileCache requires a positive finite maxEntries and non-negative finite staleAfterMs.");
+  }
+  let disposed = false;
+  let started = null;
+  let snapshot = { status: "loading" };
+  let generation = 0;
+  let refreshOrder = 0;
+  let cacheEpoch = 0;
+  let requiresBootstrap = true;
+  const listeners = new Set;
+  const profiles = new Map;
+  const searches = new Map;
+  const pending = new Map;
+  const batches = [];
+  const batchControllers = new Set;
+  const batchEntries = new Map;
+  const pendingSearches = new Map;
+  const searchQueue = [];
+  let activeSearches = 0;
+  const scheduledProfileKeys = new Set;
+  let batchScheduled = false;
+  let activeBatches = 0;
+  const notify = () => {
+    for (const listener of [...listeners])
+      listener();
+  };
+  const clearDirectory = (keys) => {
+    cacheEpoch++;
+    for (const entry of pending.values())
+      entry.resolve(err("stale-context", "Directory read was invalidated."));
+    pending.clear();
+    batches.length = 0;
+    scheduledProfileKeys.clear();
+    for (const controller of batchControllers)
+      controller.abort();
+    batchControllers.clear();
+    for (const entry of pendingSearches.values()) {
+      entry.settled = true;
+      entry.controller.abort();
+      entry.resolve(err("stale-context", "Directory search was invalidated."));
+    }
+    pendingSearches.clear();
+    searchQueue.length = 0;
+    if (!keys || !keys.length) {
+      profiles.clear();
+      searches.clear();
+      return;
+    }
+    for (const key of keys)
+      profiles.delete(key);
+    searches.clear();
+  };
+  const queueProfiles = () => {
+    if (batchScheduled)
+      return;
+    batchScheduled = true;
+    queueMicrotask(() => {
+      batchScheduled = false;
+      if (disposed)
+        return;
+      const keys = [...pending.keys()].filter((key) => !scheduledProfileKeys.has(key));
+      for (let index = 0;index < keys.length; index += 64) {
+        const batch = keys.slice(index, index + 64);
+        batch.forEach((key) => scheduledProfileKeys.add(key));
+        batches.push(batch);
+      }
+      runBatches();
+    });
+  };
+  const runBatches = () => {
+    while (activeBatches < 4 && batches.length) {
+      const keys = batches.shift().filter((key) => (pending.get(key)?.waiters ?? 0) > 0);
+      if (!keys.length)
+        continue;
+      activeBatches++;
+      const entries = new Map(keys.map((key) => [key, pending.get(key)]));
+      const controller = new AbortController;
+      const epoch = cacheEpoch;
+      batchControllers.add(controller);
+      batchEntries.set(controller, entries);
+      transport.directory.getMany({ keys }, { signal: controller.signal }).then((result) => {
+        if (disposed || epoch !== cacheEpoch)
+          return;
+        if (result.ok) {
+          const seen = new Set;
+          if (result.value.length !== keys.length || result.value.some((value) => !keys.includes(value.key) || seen.has(value.key) || (seen.add(value.key), false)))
+            result = err("incompatible", "Profile batch did not return exactly the requested keys.");
+        }
+        const byKey = new Map(result.ok ? result.value.map((value) => [value.key, value]) : []);
+        for (const key of keys) {
+          const observer = entries.get(key);
+          if (!observer || pending.get(key) !== observer)
+            continue;
+          const value = result.ok ? byKey.get(key) ?? { key, status: "missing" } : result;
+          const normalized = "ok" in value ? value : ok(value);
+          if (normalized.ok) {
+            profiles.set(key, { value: normalized.value, at: now() });
+            while (profiles.size > cacheMax)
+              profiles.delete(profiles.keys().next().value);
+          }
+          pending.delete(key);
+          observer.resolve(normalized);
+        }
+      }, () => {
+        for (const key of keys) {
+          const observer = entries.get(key);
+          if (observer && pending.get(key) === observer) {
+            pending.delete(key);
+            observer.resolve(err("unavailable", "Profile batch failed.", "after-reconnect"));
+          }
+        }
+      }).finally(() => {
+        batchControllers.delete(controller);
+        batchEntries.delete(controller);
+        keys.forEach((key) => scheduledProfileKeys.delete(key));
+        activeBatches--;
+        queueProfiles();
+        runBatches();
+      });
+    }
+  };
+  const profileRead = (key) => {
+    if (disposed)
+      return Promise.resolve(err("disposed", "Identity client is disposed."));
+    const fresh = profiles.get(key);
+    if (fresh && now() - fresh.at <= staleAfter)
+      return Promise.resolve(ok(fresh.value));
+    const existing = pending.get(key);
+    if (existing)
+      return existing.promise;
+    let resolve;
+    const promise = new Promise((done) => {
+      resolve = done;
+    });
+    pending.set(key, { promise, resolve, waiters: 0 });
+    queueProfiles();
+    return promise;
+  };
+  const observeProfile = (key, signal) => {
+    if (signal?.aborted)
+      return Promise.resolve(err("cancelled", "Identity read was cancelled."));
+    const promise = profileRead(key);
+    const entry = pending.get(key);
+    if (!entry)
+      return waitFor2(promise, signal);
+    entry.waiters++;
+    return new Promise((resolve) => {
+      let done = false;
+      const release = (value) => {
+        if (done)
+          return;
+        done = true;
+        signal?.removeEventListener("abort", abort);
+        const left = Math.max(0, entry.waiters - 1);
+        entry.waiters = left;
+        if (!left) {
+          if (pending.get(key) === entry) {
+            pending.delete(key);
+            entry.resolve(err("cancelled", "All profile readers cancelled."));
+          }
+          for (const [controller, entries] of batchEntries)
+            if ([...entries.values()].every((item) => item.waiters === 0))
+              controller.abort();
+        }
+        resolve(value);
+      };
+      const abort = () => release(err("cancelled", "Identity read was cancelled."));
+      signal?.addEventListener("abort", abort, { once: true });
+      promise.then(release);
+    });
+  };
+  const runSearches = () => {
+    while (!disposed && activeSearches < 4 && searchQueue.length) {
+      const entry = searchQueue.shift();
+      if (entry.settled || entry.waiters === 0 || entry.epoch !== cacheEpoch)
+        continue;
+      activeSearches++;
+      transport.directory.search(entry.input, { signal: entry.controller.signal }).then((result) => {
+        if (!entry.settled) {
+          entry.settled = true;
+          pendingSearches.delete(profileKey(entry.input));
+          if (disposed)
+            entry.resolve(err("disposed", "Identity client is disposed."));
+          else if (entry.epoch !== cacheEpoch)
+            entry.resolve(err("stale-context", "Directory search was invalidated."));
+          else {
+            if (result.ok) {
+              searches.set(profileKey(entry.input), { value: result.value, at: now() });
+              while (searches.size > 64)
+                searches.delete(searches.keys().next().value);
+            }
+            entry.resolve(result);
+          }
+        }
+      }).finally(() => {
+        activeSearches--;
+        runSearches();
+      });
+    }
+  };
+  const observeSearch = (input, signal) => {
+    if (signal?.aborted)
+      return Promise.resolve(err("cancelled", "Identity read was cancelled."));
+    const key = profileKey(input);
+    let entry = pendingSearches.get(key);
+    if (!entry) {
+      let resolve;
+      const promise = new Promise((done) => {
+        resolve = done;
+      });
+      entry = { promise, resolve, controller: new AbortController, epoch: cacheEpoch, input: structuredClone(input), waiters: 1, settled: false };
+      pendingSearches.set(key, entry);
+      searchQueue.push(entry);
+      runSearches();
+    } else
+      entry.waiters++;
+    return new Promise((resolve) => {
+      let done = false;
+      const release = (value) => {
+        if (done)
+          return;
+        done = true;
+        signal?.removeEventListener("abort", abort);
+        entry.waiters--;
+        if (entry.waiters === 0 && !entry.settled) {
+          entry.settled = true;
+          pendingSearches.delete(key);
+          entry.controller.abort();
+          entry.resolve(err("cancelled", "All directory search readers cancelled."));
+        }
+        resolve(value);
+      };
+      const abort = () => release(err("cancelled", "Identity read was cancelled."));
+      signal?.addEventListener("abort", abort, { once: true });
+      entry.promise.then(release);
+    });
+  };
+  const directory = {
+    async search(input, readOptions) {
+      if (disposed)
+        return err("disposed", "Identity client is disposed.");
+      const key = profileKey(input);
+      const cached = searches.get(key);
+      if (cached && now() - cached.at <= staleAfter)
+        return ok(cached.value);
+      return observeSearch(input, readOptions?.signal);
+    },
+    async getMany(input, readOptions) {
+      if (disposed)
+        return err("disposed", "Identity client is disposed.");
+      const unique = [...new Set(input.keys)];
+      const results = await Promise.all(unique.map((key) => observeProfile(key, readOptions?.signal)));
+      const failed = results.find((result) => !result.ok);
+      return failed && !failed.ok ? failed : ok(results.map((result) => result.value));
+    },
+    subscribe(keys, listener) {
+      return transport.directory.subscribe(keys, listener);
+    }
+  };
+  const subscription = transport.subscribe((event) => {
+    if (disposed)
+      return;
+    if (event.kind === "directory")
+      clearDirectory(event.revision === null ? undefined : event.keys);
+    if (event.kind === "session") {
+      clearDirectory();
+      refreshInternal(undefined, event.reason !== "provider");
+    }
+    if (event.kind === "reconnected") {
+      refresh();
+    }
+    if (event.kind === "disconnected")
+      suspendAuthority();
+  });
+  const suspendAuthority = () => {
+    if (disposed)
+      return;
+    generation++;
+    requiresBootstrap = true;
+    snapshot = { status: "loading" };
+    notify();
+  };
+  let previousIdentity = options.connection.getHealth().identity;
+  let revalidating = false;
+  const stopHealth = options.connection.subscribeHealth(() => {
+    if (disposed)
+      return;
+    const next = options.connection.getHealth();
+    const identity = next.identity;
+    const changed = identity.status !== previousIdentity.status || identity.status === "unavailable" && previousIdentity.status === "unavailable" && (identity.error.code !== previousIdentity.error.code || identity.error.message !== previousIdentity.error.message || identity.error.retry !== previousIdentity.error.retry);
+    const wasUnhealthy = previousIdentity.status !== "healthy";
+    previousIdentity = identity;
+    if (!changed || revalidating)
+      return;
+    suspendAuthority();
+    if (identity.status === "healthy" && wasUnhealthy)
+      refresh();
+  });
+  const refreshInternal = async (readOptions, suspend = true) => {
+    if (disposed)
+      return err("disposed", "Identity client is disposed.");
+    const requestOrder = ++refreshOrder;
+    if (suspend)
+      suspendAuthority();
+    const requestGeneration = generation;
+    revalidating = true;
+    const revalidated = await options.connection.revalidate(readOptions);
+    revalidating = false;
+    if (!revalidated.ok) {
+      if (requestOrder === refreshOrder && requestGeneration === generation && suspend) {
+        snapshot = { status: "loading" };
+        notify();
+      }
+      return revalidated;
+    }
+    const session = await transport.bootstrap(readOptions);
+    if (requestOrder !== refreshOrder || requestGeneration !== generation || disposed)
+      return session.ok ? err("stale-context", "Superseded identity refresh.") : session;
+    if (!session.ok) {
+      if (requestOrder === refreshOrder && suspend) {
+        snapshot = { status: "loading" };
+        notify();
+      }
+      return session;
+    }
+    snapshot = session.value;
+    requiresBootstrap = false;
+    notify();
+    return ok(undefined);
+  };
+  const refresh = (readOptions) => refreshInternal(readOptions, true);
+  return {
+    connection: options.connection,
+    getSnapshot: () => snapshot,
+    currentSession() {
+      if (disposed)
+        return err("disposed", "Identity client is disposed.");
+      const health = options.connection.getHealth().identity;
+      if (health.status === "unavailable")
+        return err(health.error.code, health.error.message, health.error.retry);
+      if (snapshot.status === "ready" && health.status === "healthy" && !requiresBootstrap)
+        return ok(snapshot);
+      if (snapshot.status === "unauthenticated" || snapshot.status === "unavailable" || snapshot.status === "incompatible")
+        return err(snapshot.error.code, snapshot.error.message, snapshot.error.retry);
+      return err("unavailable", "Identity session is not live.", "after-reconnect");
+    },
+    subscribe(listener) {
+      if (disposed)
+        return () => {};
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    start() {
+      if (disposed)
+        return Promise.resolve(err("disposed", "Identity client is disposed."));
+      return started ??= refresh();
+    },
+    refresh,
+    selfProfile: (readOptions) => transport.selfProfile(readOptions),
+    directory,
+    participants: transport.participants,
+    dispose() {
+      if (disposed)
+        return;
+      disposed = true;
+      generation++;
+      requiresBootstrap = true;
+      subscription();
+      stopHealth();
+      listeners.clear();
+      profiles.clear();
+      searches.clear();
+      batches.length = 0;
+      for (const controller of batchControllers)
+        controller.abort();
+      batchControllers.clear();
+      for (const entry of pendingSearches.values()) {
+        entry.settled = true;
+        entry.controller.abort();
+        entry.resolve(err("disposed", "Identity client is disposed."));
+      }
+      pendingSearches.clear();
+      searchQueue.length = 0;
+      for (const entry of pending.values())
+        entry.resolve(err("disposed", "Identity client is disposed."));
+      pending.clear();
+      snapshot = { status: "disposed" };
+    }
+  };
+}
+
+// client-view-runtime.ts
+function ready(client, selection, subject, generation) {
+  const session = client.currentSession();
+  if (!session.ok)
+    return session;
+  if (session.value.status !== "ready")
+    return err(session.value.error.code, session.value.error.message, session.value.error.retry);
+  if (selection.kind === "person" && session.value.capabilities.requestIdentity === "singleton")
+    return err("unsupported", "View-as is unavailable on the singleton host.");
+  const resolved = selection.kind === "self" ? session.value.actor.identity : subject;
+  return resolved ? ok({ status: "ready", session: session.value, subject: resolved, overriding: selection.kind === "person", viewGeneration: generation }) : err("unavailable", "Selected person is not resolved.", "after-refresh");
+}
+function createIdentityView(options) {
+  let disposed = false;
+  let generation = 0;
+  let serial = 0;
+  let selection = { kind: "self" };
+  let selectedSubject = null;
+  let snapshot = { status: "loading" };
+  let lastReady = null;
+  let initial = options.initialSelection;
+  const guards = new Set;
+  const listeners = new Set;
+  let active = null;
+  let finalizing = false;
+  const safe = (callback) => {
+    try {
+      callback();
+    } catch {}
+  };
+  const publish = () => {
+    for (const listener of [...listeners])
+      safe(listener);
+  };
+  const cancel = (work) => {
+    if (work.cancelled)
+      return;
+    work.cancelled = true;
+    work.controller.abort();
+    for (const item of work.prepared)
+      safe(() => item.cancel());
+    if (active === work)
+      active = null;
+  };
+  const refresh = () => {
+    const value = ready(options.client, selection, selectedSubject, generation);
+    if (value.ok) {
+      snapshot = value.value;
+      lastReady = snapshot;
+    } else
+      snapshot = { status: "blocked", session: options.client.getSnapshot(), requestedSubject: selection.kind === "person" ? selection.key : null, lastReady, error: value.error };
+    publish();
+  };
+  const invalidate = (reason) => {
+    if (active)
+      cancel(active);
+    generation++;
+    for (const guard of [...guards])
+      safe(() => guard.invalidate(reason));
+  };
+  const select = async (input, pending = options.pendingEdits ?? "block") => {
+    if (disposed)
+      return err("disposed", "Identity view is disposed.");
+    if (finalizing)
+      return Promise.resolve().then(() => select(input, pending));
+    if (active)
+      cancel(active);
+    const live = options.client.currentSession();
+    if (!live.ok || live.value.status !== "ready")
+      return live.ok ? err("unavailable", "Identity is unavailable.") : live;
+    const next = input.kind === "self" || input.key === live.value.actor.identity.key ? { kind: "self" } : { kind: "person", key: input.key };
+    if (next.kind === selection.kind && (next.kind === "self" || selection.kind === "person" && next.key === selection.key))
+      return ok(undefined);
+    if (next.kind === "person" && live.value.capabilities.requestIdentity === "singleton")
+      return err("unsupported", "View-as is unavailable on the singleton host.");
+    const expected = JSON.stringify([live.value.instanceId, live.value.actor.identity.key, live.value.stamp]);
+    const from = snapshot;
+    const work = { controller: new AbortController, prepared: [], cancelled: false };
+    active = work;
+    const valid = () => {
+      const current = options.client.currentSession();
+      return !disposed && active === work && !work.controller.signal.aborted && current.ok && current.value.status === "ready" && JSON.stringify([current.value.instanceId, current.value.actor.identity.key, current.value.stamp]) === expected;
+    };
+    const awaited = (promise) => new Promise((resolve) => {
+      const abort = () => {
+        work.controller.signal.removeEventListener("abort", abort);
+        resolve(err("stale-context", "View transition was superseded."));
+      };
+      if (work.controller.signal.aborted) {
+        abort();
+        return;
+      }
+      work.controller.signal.addEventListener("abort", abort, { once: true });
+      promise.then((value) => {
+        work.controller.signal.removeEventListener("abort", abort);
+        resolve(value);
+      }, () => {
+        work.controller.signal.removeEventListener("abort", abort);
+        resolve(err("unavailable", "View preparation failed.", "after-refresh"));
+      });
+    });
+    try {
+      let resolved = null;
+      if (next.kind === "person") {
+        const lookup = await awaited(options.client.directory.getMany({ keys: [next.key] }, { signal: work.controller.signal }));
+        if (!valid())
+          return err("stale-context", "View transition was superseded.");
+        if (!lookup.ok)
+          return lookup;
+        const found = lookup.value[0];
+        if (lookup.value.length !== 1 || !found || found.key !== next.key || found.status !== "found" || found.profile.identity.kind !== "person" || found.profile.identity.key !== next.key)
+          return err(found?.status === "missing" ? "not-found" : "incompatible", "Selected identity is not a resolvable person.");
+        resolved = Object.freeze({ ...found.profile.identity });
+      }
+      const transition = { id: String(++serial), from, selection: next, pending, signal: work.controller.signal };
+      for (const guard of [...guards]) {
+        if (!valid())
+          return err("stale-context", "View transition was superseded.");
+        const result = guard.inspect(transition);
+        if (!result.ok)
+          return result;
+        work.prepared.push(result.value);
+      }
+      for (const item of work.prepared) {
+        if (!valid())
+          return err("stale-context", "View transition was superseded.");
+        const value = await awaited(item.prepare());
+        if (!valid())
+          return err("stale-context", "View transition was superseded.");
+        if (!value.ok)
+          return value;
+      }
+      const candidate = ready(options.client, next, resolved, generation + 1);
+      if (!candidate.ok)
+        return candidate;
+      finalizing = true;
+      for (const item of work.prepared) {
+        if (!valid())
+          return err("stale-context", "View transition was superseded.");
+        item.commit();
+      }
+      if (!valid())
+        return err("stale-context", "View transition was superseded.");
+      selection = next;
+      selectedSubject = resolved;
+      generation++;
+      snapshot = candidate.value;
+      lastReady = snapshot;
+      active = null;
+      publish();
+      return ok(undefined);
+    } catch {
+      return err("unavailable", "View guard or identity lookup failed.", "after-refresh");
+    } finally {
+      finalizing = false;
+      if (active === work || work.cancelled)
+        cancel(work);
+    }
+  };
+  let lastStamp = null;
+  let lastActor = null;
+  const observeClient = () => {
+    if (disposed)
+      return;
+    const live = options.client.currentSession();
+    if (!live.ok || live.value.status !== "ready") {
+      invalidate("disconnected");
+      lastStamp = null;
+      lastActor = null;
+      refresh();
+      return;
+    }
+    const actor = live.value.actor.identity.key;
+    if (lastActor !== null && lastActor !== actor)
+      invalidate("actor");
+    else if (lastStamp !== null && lastStamp !== live.value.stamp)
+      invalidate("session");
+    lastStamp = live.value.stamp;
+    lastActor = actor;
+    refresh();
+    if (initial) {
+      const next = initial;
+      initial = undefined;
+      select(next);
+    }
+  };
+  const stop = options.client.subscribe(observeClient);
+  observeClient();
+  return {
+    getSnapshot: () => snapshot,
+    subscribe(listener) {
+      if (disposed)
+        return () => {};
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    select(next, input) {
+      return select(next, input?.pendingEdits);
+    },
+    reset(input) {
+      return select({ kind: "self" }, input?.pendingEdits);
+    },
+    registerGuard(guard) {
+      if (disposed)
+        return () => {};
+      guards.add(guard);
+      return () => {
+        guards.delete(guard);
+        if (active)
+          cancel(active);
+      };
+    },
+    dispose() {
+      if (disposed)
+        return;
+      disposed = true;
+      invalidate("disposed");
+      stop();
+      guards.clear();
+      listeners.clear();
+    }
+  };
+}
+
+// draft-retirement-runtime.ts
+var scopeKey = ({ address: a, actor, schemaVersion }) => JSON.stringify([a.instanceId, a.pluginId, a.collection, a.recordId, a.owner, actor, schemaVersion]);
+function createDraftRetirementOwner() {
+  let partitions = new WeakMap;
+  const lifetime = new AbortController;
+  const terminal = (signal) => lifetime.signal.aborted ? err("disposed", "Draft preservation owner is disposed.") : signal?.aborted ? err("cancelled", "Draft preservation lookup was cancelled.") : null;
+  const awaitPending = (tasks, signal) => new Promise((resolve) => {
+    const finish = (result) => {
+      lifetime.signal.removeEventListener("abort", abort);
+      signal?.removeEventListener("abort", abort);
+      resolve(result);
+    };
+    const abort = () => finish(terminal(signal) ?? err("cancelled", "Draft preservation lookup was cancelled."));
+    lifetime.signal.addEventListener("abort", abort, { once: true });
+    signal?.addEventListener("abort", abort, { once: true });
+    const stopped = terminal(signal);
+    if (stopped) {
+      finish(stopped);
+      return;
+    }
+    Promise.all(tasks).then(() => finish(terminal(signal) ?? ok(undefined)));
+  });
+  return {
+    begin(storage, scope, task) {
+      if (lifetime.signal.aborted)
+        return;
+      const key = scopeKey(scope);
+      const scopes = partitions.get(storage) ?? new Map;
+      partitions.set(storage, scopes);
+      const pending = scopes.get(key) ?? new Set;
+      scopes.set(key, pending);
+      const work = task.catch(() => err("unavailable", "Draft preservation failed.", "after-refresh"));
+      pending.add(work);
+      work.then(() => {
+        pending.delete(work);
+        if (!pending.size)
+          scopes.delete(key);
+        if (!scopes.size)
+          partitions.delete(storage);
+      });
+    },
+    async wait(storage, scope, signal) {
+      const key = scopeKey(scope);
+      while (true) {
+        const stopped = terminal(signal);
+        if (stopped)
+          return stopped;
+        const pending = partitions.get(storage)?.get(key);
+        if (!pending?.size)
+          return ok(undefined);
+        const result = await awaitPending([...pending], signal);
+        if (!result.ok)
+          return result;
+      }
+    },
+    dispose() {
+      if (lifetime.signal.aborted)
+        return;
+      lifetime.abort();
+      partitions = new WeakMap;
+    }
+  };
+}
+
+// react-runtime.ts
+var waitingForBinding = Object.freeze({ status: "waiting-for-identity" });
+function safeAvatarUrl(value) {
+  if (value === null)
+    return null;
+  try {
+    const url = new URL(value);
+    return url.protocol === "https:" ? url.href : null;
+  } catch {
+    return null;
+  }
+}
+function avatarInitials(label) {
+  const words = label.trim().split(/\s+/u).filter(Boolean);
+  return `${words[0]?.[0] ?? "?"}${words.length > 1 ? words.at(-1)?.[0] ?? "" : ""}`.toLocaleUpperCase();
+}
+function selectableProfile(profile) {
+  return profile.identity.kind === "person" || profile.identity.kind === "default-user";
+}
+function createFailureSink() {
+  let disposed = false;
+  const listeners = new Set;
+  const entries = new Map;
+  let current = Object.freeze([]);
+  let nextGeneration = 0;
+  const keyFor = (draft) => JSON.stringify([
+    draft.key.address.instanceId,
+    draft.key.address.pluginId,
+    draft.key.address.collection,
+    draft.key.address.recordId,
+    draft.key.address.owner,
+    draft.key.actor,
+    draft.key.ownerSession,
+    draft.schemaVersion
+  ]);
+  const emit = () => {
+    for (const listener of [...listeners])
+      try {
+        listener();
+      } catch {}
+  };
+  return {
+    report(draft, error) {
+      if (disposed)
+        return;
+      const key = keyFor(draft);
+      entries.delete(key);
+      entries.set(key, Object.freeze({ generation: ++nextGeneration, draft, error }));
+      while (entries.size > 16)
+        entries.delete(entries.keys().next().value);
+      current = Object.freeze([...entries.values()]);
+      emit();
+    },
+    acknowledge(generation) {
+      if (disposed)
+        return false;
+      const entry = [...entries.entries()].find(([, failure2]) => failure2.generation === generation);
+      if (!entry)
+        return false;
+      entries.delete(entry[0]);
+      current = Object.freeze([...entries.values()]);
+      emit();
+      return true;
+    },
+    snapshot: () => current,
+    subscribe(listener) {
+      if (disposed)
+        return () => {};
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    dispose() {
+      if (disposed)
+        return;
+      disposed = true;
+      entries.clear();
+      current = Object.freeze([]);
+      listeners.clear();
+    }
+  };
+}
+function createProviderRoot() {
+  const retirements = createDraftRetirementOwner();
+  const failures = createFailureSink();
+  let disposed = false;
+  return {
+    retirements,
+    failures,
+    dispose() {
+      if (disposed)
+        return;
+      disposed = true;
+      retirements.dispose();
+      failures.dispose();
+    }
+  };
+}
+function useCommittedResource(key, create, dispose) {
+  const [entry, setEntry] = React.useState(null);
+  const epoch = React.useRef(0);
+  React.useLayoutEffect(() => {
+    const current = ++epoch.current;
+    const value = create();
+    setEntry({ key, epoch: current, value });
+    return () => {
+      try {
+        dispose(value);
+      } catch {}
+    };
+  }, [key]);
+  return entry !== null && entry.epoch === epoch.current && Object.is(entry.key, key) ? entry.value : null;
+}
+function requireContext(value, name) {
+  if (value === null)
+    throw new Error(`${name} requires an enclosing BbIdentity Provider.`);
+  return value;
+}
+function createIdentityReactRuntime(native) {
+  const ProviderContext = React.createContext(null);
+  const ViewContext = React.createContext(null);
+  const Provider = ({ client, children, fallback }) => {
+    const root = useCommittedResource("provider-root", createProviderRoot, (value) => value.dispose());
+    const context = React.useMemo(() => root === null || client === null ? null : { root, client }, [root, client]);
+    if (context === null)
+      return fallback ?? null;
+    return React.createElement(ProviderContext.Provider, { value: context }, children);
+  };
+  const Context = (props) => {
+    const provider = requireContext(React.useContext(ProviderContext), "BbIdentity.Context");
+    const viewKey = React.useMemo(() => ({ client: provider.client, supplied: props.view ?? null, pending: props.pendingEdits ?? null }), [provider.client, props.view, props.pendingEdits]);
+    const view = useCommittedResource(viewKey, () => props.view ?? createIdentityView({
+      client: provider.client,
+      ...props.pendingEdits ? { pendingEdits: props.pendingEdits } : {}
+    }), (value) => {
+      if (!props.view)
+        value.dispose();
+    });
+    const root = React.useMemo(() => view === null ? null : { ...provider, view }, [provider, view]);
+    if (root === null)
+      return null;
+    return React.createElement(ViewContext.Provider, { value: root }, props.children);
+  };
+  const useBorrowedIdentityClient = () => requireContext(React.useContext(ProviderContext), "useBorrowedIdentityClient").client;
+  const useIdentitySession = () => {
+    const client = useBorrowedIdentityClient();
+    return React.useSyncExternalStore(React.useCallback((listener) => client.subscribe(listener), [client]), React.useCallback(() => client.getSnapshot(), [client]), React.useCallback(() => client.getSnapshot(), [client]));
+  };
+  const useNativeIdentityConnection = () => {
+    const rpc = native.useRpc();
+    const realtimeState = native.useRealtimeConnectionState();
+    const adapter = useCommittedResource(rpc, () => createNativeIdentityConnection({ rpc, realtimeState }), (value) => value.dispose());
+    const receive = React.useCallback((payload) => {
+      adapter?.acceptRealtime(payload);
+    }, [adapter]);
+    native.useRealtime(nativeIdentityRealtimeChannel, receive);
+    React.useEffect(() => {
+      adapter?.setRealtimeState(realtimeState);
+    }, [adapter, realtimeState]);
+    return adapter?.connection ?? null;
+  };
+  const useNativeIdentityClient = () => {
+    const connection = useNativeIdentityConnection();
+    const client = useCommittedResource(connection, () => connection === null ? null : createIdentityClient({ connection }), (value) => value?.dispose());
+    React.useEffect(() => {
+      if (client !== null)
+        client.start();
+    }, [client]);
+    return client;
+  };
+  const useIdentityStateSnapshot = (binding) => React.useSyncExternalStore(React.useCallback((listener) => binding?.subscribe(listener) ?? (() => {}), [binding]), React.useCallback(() => binding?.getSnapshot() ?? waitingForBinding, [binding]), React.useCallback(() => binding?.getSnapshot() ?? waitingForBinding, [binding]));
+  const useBoundIdentityState = (options) => {
+    const root = requireContext(React.useContext(ViewContext), "useBoundIdentityState");
+    const suppliedConflict = "resource" in options && options.resource !== undefined ? options.onConflict : null;
+    const callbacks = React.useRef({ failure: options.onUnpersistedDraft, conflict: suppliedConflict });
+    React.useLayoutEffect(() => {
+      callbacks.current = { failure: options.onUnpersistedDraft, conflict: suppliedConflict };
+    }, [options.onUnpersistedDraft, suppliedConflict]);
+    const sourceKey = React.useMemo(() => {
+      if ("resource" in options && options.resource !== undefined)
+        return {
+          kind: "resource",
+          resource: options.resource,
+          recordId: options.recordId,
+          drafts: options.drafts,
+          initializeEmpty: options.initializeEmpty,
+          scheduler: options.scheduler ?? null
+        };
+      return { kind: "custom", create: options.create };
+    }, [
+      "create" in options ? options.create : null,
+      "resource" in options ? options.resource : null,
+      "recordId" in options ? options.recordId : null,
+      "drafts" in options ? options.drafts : null,
+      "initializeEmpty" in options ? options.initializeEmpty : null,
+      "scheduler" in options ? options.scheduler : null
+    ]);
+    const key = React.useMemo(() => ({ root, source: sourceKey, target: options.target, editPolicy: options.editPolicy }), [root, sourceKey, options.target, options.editPolicy]);
+    const binding = useCommittedResource(key, () => {
+      const onUnpersistedDraft = (draft, error) => {
+        if ("resource" in options && options.resource !== undefined && options.drafts)
+          root.root.failures.report(draft, error);
+        try {
+          callbacks.current.failure?.(draft, error);
+        } catch {}
+      };
+      if ("resource" in options && options.resource !== undefined) {
+        return bindIdentityState({
+          ...options,
+          client: root.client,
+          view: root.view,
+          onUnpersistedDraft,
+          onConflict(context) {
+            return callbacks.current.conflict?.(context) ?? { kind: "needs-review", reason: "Committed conflict callback is unavailable." };
+          }
+        }, root.root.retirements);
+      }
+      return bindIdentityState({ ...options, client: root.client, view: root.view, onUnpersistedDraft }, root.root.retirements);
+    }, (value) => value.dispose());
+    useIdentityStateSnapshot(binding);
+    return binding;
+  };
+  const useIdentityViewSnapshot = () => {
+    const root = requireContext(React.useContext(ViewContext), "useIdentityViewSnapshot");
+    return React.useSyncExternalStore(React.useCallback((listener) => root.view.subscribe(listener), [root.view]), React.useCallback(() => root.view.getSnapshot(), [root.view]), React.useCallback(() => root.view.getSnapshot(), [root.view]));
+  };
+  const useIdentityViewActions = () => {
+    const root = requireContext(React.useContext(ViewContext), "useIdentityViewActions");
+    return React.useMemo(() => ({ select: root.view.select.bind(root.view), reset: root.view.reset.bind(root.view) }), [root.view]);
+  };
+  const IdentityAvatar = ({ presentation, label, className }) => {
+    const imageUrl = React.useMemo(() => safeAvatarUrl(presentation?.avatarUrl ?? null), [presentation?.avatarUrl]);
+    const [failedImageUrl, setFailedImageUrl] = React.useState(null);
+    React.useEffect(() => {
+      setFailedImageUrl(null);
+    }, [imageUrl]);
+    const accessibleLabel = presentation?.displayName || label;
+    if (imageUrl !== null && failedImageUrl !== imageUrl) {
+      return React.createElement("img", {
+        className,
+        src: imageUrl,
+        alt: accessibleLabel,
+        crossOrigin: "anonymous",
+        referrerPolicy: "no-referrer",
+        onError: () => setFailedImageUrl(imageUrl)
+      });
+    }
+    return React.createElement("span", { className, role: "img", "aria-label": accessibleLabel }, avatarInitials(accessibleLabel));
+  };
+  const IdentityLabel = ({ profile, fallback, className, primaryClassName, secondaryClassName }) => {
+    const displayName = profile?.presentation.displayName || fallback;
+    const handle = profile?.presentation.handle ?? null;
+    return React.createElement("span", { className }, React.createElement("strong", { className: primaryClassName }, displayName), handle === null ? null : React.createElement("small", { className: secondaryClassName }, handle));
+  };
+  const IdentityViewPicker = (props) => {
+    const client = useBorrowedIdentityClient();
+    const view = useIdentityViewSnapshot();
+    const actions = useIdentityViewActions();
+    const [open, setOpen] = React.useState(false);
+    const [query, setQuery] = React.useState("");
+    const [results, setResults] = React.useState([]);
+    const [loading, setLoading] = React.useState(false);
+    const [error, setError] = React.useState(null);
+    const searchGeneration = React.useRef(0);
+    const actionGeneration = React.useRef(0);
+    const shellRef = React.useRef(null);
+    const triggerRef = React.useRef(null);
+    const popupRef = React.useRef(null);
+    const inputRef = React.useRef(null);
+    const active = view.status === "ready" ? view : view.status === "blocked" ? view.lastReady : null;
+    const canSearch = active !== null && active.session.mode === "multi-user" && active.session.capabilities.directory.search;
+    const scope = active === null ? null : `${active.session.instanceId}:${active.session.stamp}:${active.subject.key}:${active.viewGeneration}`;
+    const selectedKey = active?.subject.key ?? null;
+    const close = React.useCallback(() => {
+      setOpen(false);
+      setQuery("");
+      queueMicrotask(() => triggerRef.current?.focus());
+    }, []);
+    React.useEffect(() => {
+      const current = ++searchGeneration.current;
+      setResults([]);
+      setError(null);
+      if (!open || !canSearch || props.selectionDisabled || scope === null)
+        return;
+      const timer = window.setTimeout(() => {
+        setLoading(true);
+        client.directory.search({
+          query,
+          kinds: ["person", "default-user"],
+          history: "current",
+          limit: 20
+        }).then((result) => {
+          if (searchGeneration.current !== current)
+            return;
+          if (result.ok)
+            setResults(result.value.items.filter(selectableProfile));
+          else
+            setError(result.error.message);
+        }, () => {
+          if (searchGeneration.current === current)
+            setError(props.labels.searchUnavailable);
+        }).finally(() => {
+          if (searchGeneration.current === current)
+            setLoading(false);
+        });
+      }, query ? 150 : 0);
+      return () => window.clearTimeout(timer);
+    }, [canSearch, client, open, props.labels.searchUnavailable, props.selectionDisabled, query, scope]);
+    React.useLayoutEffect(() => {
+      if (!open || !canSearch)
+        return;
+      const popup = popupRef.current;
+      const trigger = triggerRef.current;
+      if (popup === null || trigger === null)
+        return;
+      const position = () => {
+        const viewport = window.visualViewport;
+        const left = viewport?.offsetLeft ?? 0;
+        const top = viewport?.offsetTop ?? 0;
+        const width = viewport?.width ?? window.innerWidth;
+        const height = viewport?.height ?? window.innerHeight;
+        const anchor = trigger.getBoundingClientRect();
+        popup.style.maxWidth = `${Math.max(0, width - 24)}px`;
+        popup.style.maxHeight = `${Math.max(0, height - 24)}px`;
+        const bounds = popup.getBoundingClientRect();
+        const x = Math.max(left + 12, Math.min(anchor.left, left + width - bounds.width - 12));
+        const below = anchor.bottom + 8;
+        const y = below + bounds.height <= top + height - 12 ? below : Math.max(top + 12, anchor.top - bounds.height - 8);
+        popup.style.left = `${x}px`;
+        popup.style.top = `${y}px`;
+      };
+      popup.showPopover?.();
+      position();
+      inputRef.current?.focus({ preventScroll: true });
+      const onPointerDown = (event) => {
+        if (event.target instanceof Node && !shellRef.current?.contains(event.target))
+          close();
+      };
+      const observer = new ResizeObserver(position);
+      observer.observe(popup);
+      window.addEventListener("resize", position);
+      window.addEventListener("scroll", position, true);
+      window.visualViewport?.addEventListener("resize", position);
+      window.visualViewport?.addEventListener("scroll", position);
+      document.addEventListener("pointerdown", onPointerDown);
+      return () => {
+        observer.disconnect();
+        window.removeEventListener("resize", position);
+        window.removeEventListener("scroll", position, true);
+        window.visualViewport?.removeEventListener("resize", position);
+        window.visualViewport?.removeEventListener("scroll", position);
+        document.removeEventListener("pointerdown", onPointerDown);
+      };
+    }, [canSearch, close, open]);
+    const profiles = React.useMemo(() => {
+      const byKey = new Map;
+      if (props.selectedProfile !== undefined && props.selectedProfile !== null && selectableProfile(props.selectedProfile)) {
+        byKey.set(props.selectedProfile.identity.key, props.selectedProfile);
+      }
+      for (const profile of results)
+        byKey.set(profile.identity.key, profile);
+      return [...byKey.values()];
+    }, [props.selectedProfile, results]);
+    const select = React.useCallback(async (profile) => {
+      const current = ++actionGeneration.current;
+      const result = profile === null || profile.identity.kind === "default-user" ? await actions.reset() : profile.identity.kind === "person" ? await actions.select({ kind: "person", key: profile.identity.key }) : { ok: false, error: { code: "unsupported", message: "This identity cannot be selected as a view.", retry: "never" } };
+      if (actionGeneration.current !== current)
+        return;
+      props.onResult?.(result);
+      if (result.ok)
+        close();
+      else
+        setError(result.error.message);
+    }, [actions, close, props]);
+    const onKeyDown = React.useCallback((event) => {
+      if (event.key !== "Escape")
+        return;
+      event.preventDefault();
+      close();
+    }, [close]);
+    if (!canSearch)
+      return null;
+    const triggerLabel = active?.overriding ? props.selectedProfile?.presentation.displayName ?? props.labels.viewingFallback : props.labels.trigger;
+    return React.createElement("div", { ref: shellRef, style: { position: "relative" } }, React.createElement("button", {
+      ref: triggerRef,
+      type: "button",
+      className: props.className,
+      disabled: props.selectionDisabled === true,
+      "aria-label": props.labels.trigger,
+      title: props.labels.trigger,
+      "aria-haspopup": "dialog",
+      "aria-expanded": open,
+      "data-bb-identity-view-picker": "",
+      onClick: () => {
+        setError(null);
+        setOpen(true);
+      }
+    }, props.selectedProfile === undefined || props.selectedProfile === null ? React.createElement("svg", { "aria-hidden": true, width: 16, height: 16, viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: 1.75 }, React.createElement("circle", { cx: 12, cy: 8, r: 4 }), React.createElement("path", { d: "M4 21v-2a8 8 0 0 1 16 0v2" })) : React.createElement(IdentityAvatar, {
+      presentation: props.selectedProfile.presentation,
+      label: triggerLabel,
+      ...props.avatarClassName ? { className: props.avatarClassName } : {}
+    }), React.createElement("span", null, triggerLabel)), !open ? null : React.createElement("div", {
+      ref: popupRef,
+      popover: "manual",
+      role: "dialog",
+      "aria-label": props.labels.dialog,
+      className: props.contentClassName,
+      style: { position: "fixed", margin: 0, padding: 0, inset: "auto", overflowY: "auto" },
+      onKeyDown
+    }, React.createElement("label", { className: props.searchClassName }, React.createElement("span", null, props.labels.search), React.createElement("input", {
+      ref: inputRef,
+      value: query,
+      onChange: (event) => setQuery(event.currentTarget.value),
+      placeholder: props.labels.search,
+      "aria-label": props.labels.search,
+      "data-bb-identity-view-search": ""
+    })), React.createElement("div", { className: props.resultsClassName, role: "listbox" }, active?.overriding ? React.createElement("button", {
+      type: "button",
+      role: "option",
+      "aria-selected": false,
+      onClick: () => {
+        select(null);
+      }
+    }, props.labels.self) : null, profiles.map((profile) => React.createElement("button", {
+      type: "button",
+      role: "option",
+      key: profile.identity.key,
+      "aria-selected": profile.identity.key === selectedKey,
+      "data-bb-identity-view-option": "",
+      disabled: props.selectionDisabled === true,
+      onClick: () => {
+        select(profile);
+      }
+    }, React.createElement(IdentityAvatar, {
+      presentation: profile.presentation,
+      label: props.labels.viewingFallback,
+      ...props.avatarClassName ? { className: props.avatarClassName } : {}
+    }), React.createElement(IdentityLabel, { profile, fallback: props.labels.viewingFallback }), profile.identity.key === selectedKey ? React.createElement("span", { "aria-hidden": true }, "✓") : null)), !loading && error !== null ? React.createElement("p", { role: "alert" }, error) : null, !loading && error === null && profiles.length === 0 ? React.createElement("p", null, props.labels.noResults) : null, loading ? React.createElement("p", { role: "status" }, "Searching…") : null)));
+  };
+  const IdentityViewStatus = (props) => {
+    const view = useIdentityViewSnapshot();
+    const actions = useIdentityViewActions();
+    const [error, setError] = React.useState(null);
+    const active = view.status === "ready" ? view : view.status === "blocked" ? view.lastReady : null;
+    if (active?.overriding !== true)
+      return null;
+    const reset = async () => {
+      const result = await actions.reset();
+      props.onResult?.(result);
+      if (!result.ok)
+        setError(result.error.message);
+    };
+    return React.createElement("span", { className: props.className }, React.createElement("span", null, props.labels.viewing), React.createElement("button", {
+      type: "button",
+      ...props.returnSelfAttributes,
+      "data-bb-identity-return-self": "",
+      onClick: () => {
+        reset();
+      }
+    }, props.labels.returnSelf), error === null ? null : React.createElement("span", { role: "alert" }, error));
+  };
+  const usePreservationFailures = () => {
+    const root = requireContext(React.useContext(ProviderContext), "usePreservationFailures");
+    return React.useSyncExternalStore(React.useCallback((listener) => root.root.failures.subscribe(listener), [root.root]), React.useCallback(() => root.root.failures.snapshot(), [root.root]), React.useCallback(() => root.root.failures.snapshot(), [root.root]));
+  };
+  const useAcknowledgePreservationFailure = () => {
+    const root = requireContext(React.useContext(ProviderContext), "useAcknowledgePreservationFailure");
+    return React.useCallback((generation) => root.root.failures.acknowledge(generation), [root.root]);
+  };
+  return {
+    Provider,
+    Context,
+    IdentityAvatar,
+    IdentityLabel,
+    IdentityViewPicker,
+    IdentityViewStatus,
+    useBorrowedIdentityClient,
+    useIdentitySession,
+    useNativeIdentityConnection,
+    useNativeIdentityClient,
+    useBoundIdentityState,
+    useIdentityStateSnapshot,
+    useIdentityViewSnapshot,
+    useIdentityViewActions,
+    usePreservationFailures,
+    useAcknowledgePreservationFailure
+  };
+}
+var BbIdentityReact = createIdentityReactRuntime({
+  useRpc: () => useRpc(),
+  useRealtime,
+  useRealtimeConnectionState
+});
+
+// react-entry-runtime.ts
+var BbIdentity = {
+  Provider: BbIdentityReact.Provider,
+  Context: BbIdentityReact.Context
+};
+var IdentityAvatar = BbIdentityReact.IdentityAvatar;
+var IdentityLabel = BbIdentityReact.IdentityLabel;
+var IdentityViewPicker = BbIdentityReact.IdentityViewPicker;
+var IdentityViewStatus = BbIdentityReact.IdentityViewStatus;
+var useBbIdentityConnection = () => BbIdentityReact.useNativeIdentityConnection();
+var useBbIdentityClient = () => BbIdentityReact.useNativeIdentityClient();
+var useBorrowedIdentityClient = () => BbIdentityReact.useBorrowedIdentityClient();
+var useIdentitySession = () => BbIdentityReact.useIdentitySession();
+var useIdentityStateBinding = BbIdentityReact.useBoundIdentityState;
+var useIdentityStateSnapshot = BbIdentityReact.useIdentityStateSnapshot;
+var useIdentityViewSnapshot = () => BbIdentityReact.useIdentityViewSnapshot();
+var useIdentityViewActions = () => BbIdentityReact.useIdentityViewActions();
+var useIdentityPreservationFailures = () => BbIdentityReact.usePreservationFailures();
+var useAcknowledgeIdentityPreservationFailure = () => BbIdentityReact.useAcknowledgePreservationFailure();
+export {
+  useIdentityViewSnapshot,
+  useIdentityViewActions,
+  useIdentityStateSnapshot,
+  useIdentityStateBinding,
+  useIdentitySession,
+  useIdentityPreservationFailures,
+  useBorrowedIdentityClient,
+  useBbIdentityConnection,
+  useBbIdentityClient,
+  useAcknowledgeIdentityPreservationFailure,
+  IdentityViewStatus,
+  IdentityViewPicker,
+  IdentityLabel,
+  IdentityAvatar,
+  BbIdentity
+};