@phosphorco/bb-identity 0.3.0 → 0.4.0

package/dist/editing-runtime.js

@@ -0,0 +1,1845 @@
+// 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 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 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 isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function nonEmpty(value) {
+  return typeof value === "string" && value.length > 0;
+}
+function decodeAddress(value) {
+  if (!isRecord(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 isRecord(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 (!isRecord(value) || !isRecord(value.identity) || !isRecord(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 (!isRecord(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 (!isRecord(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 (!isRecord(value) || value.kind !== "initialize" && value.kind !== "replace" || !isRecord(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 (!isRecord(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 (isRecord(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 (!isRecord(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 (!isRecord(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 createStateController(options, editing = false) {
+  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 checkpointError = null;
+  let checkpointWriting = 0;
+  let lastRejection = null;
+  let rejectedGeneration = -1;
+  let ownerFenced = false;
+  let loadFailed = false;
+  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, ...editing ? { rejection: lastRejection, rejectedGeneration } : {} });
+  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.");
+    if (editing && ownerFenced)
+      return err("stale-context", "This editing owner was retired.");
+    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) {
+      if (editing)
+        ownerFenced = true;
+      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 () => {
+      checkpointWriting++;
+      if (editing)
+        emit();
+      const result = await safe(() => drafts.write(captured, checkpoint?.revision ?? null));
+      checkpointWriting--;
+      if (result.ok) {
+        checkpoint = result.value;
+        if (editing)
+          checkpointError = null;
+      } else if (active(capturedEpoch) && serial === persistSerial) {
+        if (editing)
+          checkpointError = result.error;
+        else
+          block("storage-error", result.error.message);
+      }
+      if (editing)
+        emit();
+      return result;
+    });
+    persistQueue = work.then(() => {
+      return;
+    });
+    return work;
+  }
+  function schedule() {
+    clearTimer();
+    if (editing || !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 && (!editing || blocked?.reason !== "rejected"))
+          blocked = null;
+        emit();
+        schedule();
+        return ok(undefined);
+      }
+      return conflict(cause, read, base);
+    }
+    base = read;
+    desired = { value: valueClone(codec, currentValue(read)) };
+    if (!editing || blocked?.reason !== "rejected")
+      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) {
+        loadFailed = true;
+        block("storage-error", loaded.error.message);
+        return loaded;
+      }
+      const parsed = readClone(loaded.value);
+      if (!parsed.ok) {
+        loadFailed = true;
+        block("storage-error", parsed.error.message);
+        return parsed;
+      }
+      loadFailed = false;
+      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) {
+    if (editing && outcome.status === "rejected")
+      return outcome.operationId === operationId ? ok(frozen(outcome)) : err("incompatible", "Rejected receipt has another operation.");
+    if (outcome.status === "rejected")
+      return err("incompatible", "Rejection is not a legacy state outcome.");
+    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 === "rejected") {
+      lastRejection = outcome.evidence;
+      rejectedGeneration = captured.generation;
+      block("rejected", "The submitted edit was definitively rejected.");
+      const saved2 = await persist();
+      return saved2.ok ? err("invalid-input", "The submitted edit was definitively rejected.") : saved2;
+    }
+    if (editing && (outcome.status === "saved" || outcome.status === "unchanged")) {
+      lastRejection = null;
+      rejectedGeneration = -1;
+    }
+    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();
+    }
+    if (editing && snapshot.status === "blocked" && snapshot.reason === "conflict")
+      return err("conflict", snapshot.message);
+    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 (editing && lastRejection && localGeneration <= rejectedGeneration)
+      return Promise.resolve(err("invalid-input", "Correct the rejected draft before submitting a new operation."));
+    if (blocked && !(editing && blocked.reason === "rejected" && localGeneration > rejectedGeneration))
+      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) });
+    if (editing && blocked?.reason === "rejected")
+      blocked = null;
+    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, mutation: captured.mutation }, { 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 && !editing) {
+      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;
+    if (editing) {
+      if (activeSave)
+        return activeSave;
+      if (pending)
+        return reconcile(false);
+      return sendNew();
+    }
+    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,
+    inspect() {
+      const retained = draft();
+      const checkpointMatches = checkpoint !== null && retained !== null && checkpoint.draft.localGeneration === retained.localGeneration && JSON.stringify(checkpoint.draft.inFlight ? codecs.mutation.encode(checkpoint.draft.inFlight) : null) === JSON.stringify(retained.inFlight ? codecs.mutation.encode(retained.inFlight) : null) && JSON.stringify(checkpoint.draft.rejection ?? null) === JSON.stringify(retained.rejection ?? null) && JSON.stringify(codecs.read.encode(checkpoint.draft.acknowledged)) === JSON.stringify(codecs.read.encode(retained.acknowledged));
+      return {
+        draft: retained,
+        base,
+        desired: desired?.value,
+        generation: localGeneration,
+        pending: pending?.mutation ?? null,
+        saving: networkActive,
+        dirty: dirty(),
+        saveEligible: needsSave() && (!lastRejection || localGeneration > rejectedGeneration),
+        editable: active() && !closing && !ownerFenced && !loadFailed && base !== null && desired !== null && (!blocked || ["conflict", "indeterminate", "rejected", "draft-recovery"].includes(blocked.reason)),
+        checkpoint: {
+          status: !drafts ? "disabled" : checkpointWriting ? "writing" : checkpointError ? "failed" : checkpointMatches ? "backed-up" : "local-only",
+          generation: checkpoint?.draft.localGeneration ?? null,
+          revision: checkpoint?.revision ?? null,
+          error: checkpointError
+        }
+      };
+    },
+    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 || (editing ? ownerFenced || loadFailed || !base || !desired || !!blocked && !["conflict", "indeterminate", "rejected", "draft-recovery"].includes(blocked.reason) : 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++;
+      if (editing && blocked?.conflict)
+        blocked = { ...blocked, conflict: frozen({ ...blocked.conflict, token: newConflictToken(), local: desired.value }) };
+      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);
+      }
+      if (editing) {
+        lastRejection = source.rejection ?? null;
+        rejectedGeneration = source.rejectedGeneration ?? -1;
+      }
+      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
+});
+
+// client-state-binding-runtime.ts
+var waiting = Object.freeze({ status: "waiting-for-identity" });
+function bindOwnedIdentityController(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 = options.hasPending;
+  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({ session: next.session, subject: next.subject, ownerSession: owner.value });
+        if (live()?.key !== next.key) {
+          controller.dispose();
+          observeAgain = true;
+          continue;
+        }
+        const preservation = options.preservation?.(controller, next.session) ?? 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();
+    }
+  };
+}
+
+// editing-codecs-runtime.ts
+var EDITING_PROTOCOL = "bb-identity.editing/v1";
+var EDITING_LIMITS = Object.freeze({ bytes: 4 * 1024 * 1024, diagnostics: 64, message: 4096, code: 128, path: 32 });
+var record = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+function bounded(input) {
+  try {
+    return new TextEncoder().encode(JSON.stringify(input)).byteLength <= EDITING_LIMITS.bytes;
+  } catch {
+    return false;
+  }
+}
+function keys(input, allowed) {
+  return Object.keys(input).every((key) => allowed.includes(key));
+}
+function canonicalEditingJson(value) {
+  if (value === null || typeof value !== "object")
+    return JSON.stringify(value);
+  if (Array.isArray(value))
+    return `[${value.map(canonicalEditingJson).join(",")}]`;
+  return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${canonicalEditingJson(value[key])}`).join(",")}}`;
+}
+function editingCodecs(value, target) {
+  const state = stateCodecs(value);
+  const invalid = () => err("invalid-input", "Malformed editing/v1 data.");
+  const scope = {
+    decode(input) {
+      if (!bounded(input) || !record(input) || !keys(input, ["draftAddress", "schemaVersion", "target", "expected"]) || !record(input.draftAddress) || !keys(input.draftAddress, ["instanceId", "pluginId", "collection", "recordId", "owner"]) || !record(input.expected) || !keys(input.expected, ["actor", "session"]) || !Number.isSafeInteger(input.schemaVersion) || Number(input.schemaVersion) < 0)
+        return invalid();
+      const address = input.draftAddress;
+      if (typeof address.collection !== "string" || !address.collection.length || typeof address.recordId !== "string" || !address.recordId.length)
+        return invalid();
+      const instanceId = idCodec("instance").decode(address.instanceId);
+      const pluginId = idCodec("plugin").decode(address.pluginId);
+      const owner = identityKeyCodec.decode(address.owner);
+      const actor = identityKeyCodec.decode(input.expected.actor);
+      const session = idCodec("server-session").decode(input.expected.session);
+      const selected = target.decode(input.target);
+      if (!instanceId.ok || !pluginId.ok || !owner.ok || !actor.ok || !session.ok || !selected.ok || owner.value !== actor.value)
+        return invalid();
+      return ok({
+        draftAddress: { instanceId: instanceId.value, pluginId: pluginId.value, collection: address.collection, recordId: address.recordId, owner: owner.value },
+        schemaVersion: Number(input.schemaVersion),
+        target: selected.value,
+        expected: { actor: actor.value, session: session.value }
+      });
+    },
+    encode(input) {
+      return {
+        draftAddress: {
+          instanceId: idCodec("instance").encode(input.draftAddress.instanceId),
+          pluginId: idCodec("plugin").encode(input.draftAddress.pluginId),
+          collection: input.draftAddress.collection,
+          recordId: input.draftAddress.recordId,
+          owner: identityKeyCodec.encode(input.draftAddress.owner)
+        },
+        schemaVersion: input.schemaVersion,
+        target: target.encode(input.target),
+        expected: { actor: identityKeyCodec.encode(input.expected.actor), session: idCodec("server-session").encode(input.expected.session) }
+      };
+    }
+  };
+  const request = {
+    decode(input) {
+      if (!bounded(input) || !record(input) || !keys(input, ["protocol", "target", "mutation"]) || input.protocol !== EDITING_PROTOCOL)
+        return invalid();
+      if (!record(input.mutation) || !keys(input.mutation, ["kind", "address", "expectedVersion", "expected", "ownerSession", "localGeneration", "operationId", "schemaVersion", "value"]))
+        return invalid();
+      const selected = target.decode(input.target);
+      const mutation = state.mutation.decode(input.mutation);
+      if (!selected.ok || !mutation.ok || mutation.value.address.owner !== mutation.value.expected.actor)
+        return invalid();
+      return ok({ protocol: EDITING_PROTOCOL, target: selected.value, mutation: mutation.value });
+    },
+    encode(input) {
+      return { protocol: input.protocol, target: target.encode(input.target), mutation: state.mutation.encode(input.mutation) };
+    }
+  };
+  const receipt = {
+    decode(input) {
+      if (!bounded(input) || !record(input) || input.protocol !== EDITING_PROTOCOL)
+        return invalid();
+      const submitted = request.decode(input.request);
+      if (!submitted.ok || !record(input.outcome))
+        return invalid();
+      const outcome = input.outcome;
+      if (outcome.status === "rejected") {
+        const operation = idCodec("operation").decode(outcome.operationId);
+        if (!operation.ok || operation.value !== submitted.value.mutation.operationId || !Array.isArray(outcome.diagnostics) || !outcome.diagnostics.length || outcome.diagnostics.length > EDITING_LIMITS.diagnostics)
+          return invalid();
+        const diagnostics = [];
+        for (const diagnostic of outcome.diagnostics) {
+          if (!record(diagnostic) || typeof diagnostic.code !== "string" || !diagnostic.code.length || diagnostic.code.length > EDITING_LIMITS.code || typeof diagnostic.message !== "string" || !diagnostic.message.length || diagnostic.message.length > EDITING_LIMITS.message)
+            return invalid();
+          if (diagnostic.path !== undefined && (!Array.isArray(diagnostic.path) || diagnostic.path.length > EDITING_LIMITS.path || diagnostic.path.some((part) => typeof part !== "string" && !(typeof part === "number" && Number.isSafeInteger(part) && part >= 0)) || diagnostic.path.some((part) => typeof part === "string" && part.length > EDITING_LIMITS.message)))
+            return invalid();
+          diagnostics.push({ code: diagnostic.code, message: diagnostic.message, ...diagnostic.path !== undefined ? { path: diagnostic.path } : {} });
+        }
+        return ok({ protocol: EDITING_PROTOCOL, request: submitted.value, outcome: { status: "rejected", operationId: operation.value, diagnostics } });
+      }
+      const parsed = state.save.decode(outcome);
+      if (!parsed.ok || parsed.value.status === "indeterminate" || parsed.value.operationId !== submitted.value.mutation.operationId)
+        return invalid();
+      const read = "envelope" in parsed.value ? { status: "present", envelope: parsed.value.envelope } : parsed.value.current;
+      const address = read.status === "present" ? read.envelope.address : read.address;
+      if (stateAddressKey(address) !== stateAddressKey(submitted.value.mutation.address) || read.status === "present" && read.envelope.schemaVersion !== submitted.value.mutation.schemaVersion)
+        return invalid();
+      return ok({ protocol: EDITING_PROTOCOL, request: submitted.value, outcome: parsed.value });
+    },
+    encode(input) {
+      return { protocol: input.protocol, request: request.encode(input.request), outcome: input.outcome.status === "rejected" ? { status: "rejected", operationId: input.outcome.operationId, diagnostics: input.outcome.diagnostics } : state.save.encode(input.outcome) };
+    }
+  };
+  const save = {
+    decode(input) {
+      if (record(input) && input.protocol === EDITING_PROTOCOL && input.status === "indeterminate") {
+        const operation = idCodec("operation").decode(input.operationId);
+        return operation.ok ? ok({ protocol: EDITING_PROTOCOL, status: "indeterminate", operationId: operation.value }) : invalid();
+      }
+      return receipt.decode(input);
+    },
+    encode(input) {
+      return "status" in input ? { protocol: input.protocol, status: input.status, operationId: input.operationId } : receipt.encode(input);
+    }
+  };
+  const lookup = {
+    decode(input) {
+      if (!bounded(input) || !record(input))
+        return invalid();
+      if (input.status === "final") {
+        const parsed = receipt.decode(input.outcome);
+        return parsed.ok ? ok({ status: "final", outcome: parsed.value }) : parsed;
+      }
+      if (input.status === "pending")
+        return ok({ status: "pending" });
+      if (input.status === "absent-final" && input.retry === "same-operation-only")
+        return ok({ status: "absent-final", retry: "same-operation-only" });
+      if (input.status === "unknown" && ["unsupported", "expired", "unavailable"].includes(String(input.reason)))
+        return ok({ status: "unknown", reason: input.reason });
+      return invalid();
+    },
+    encode(input) {
+      return input.status === "final" ? { status: "final", outcome: receipt.encode(input.outcome) } : { ...input };
+    }
+  };
+  const draft = {
+    decode(input) {
+      if (!bounded(input) || !record(input) || input.protocol !== EDITING_PROTOCOL || !record(input.draft))
+        return invalid();
+      const selected = target.decode(input.target);
+      const raw = input.draft;
+      if (!selected.ok || raw.formatVersion !== 1 || !record(raw.key) || !Number.isSafeInteger(raw.schemaVersion) || Number(raw.schemaVersion) < 0 || !Number.isSafeInteger(raw.localGeneration) || Number(raw.localGeneration) < 0)
+        return invalid();
+      const acknowledged = state.read.decode(raw.acknowledged);
+      const desired = value.decode(raw.desired);
+      const actor = identityKeyCodec.decode(raw.key.actor);
+      const ownerSession = idCodec("owner-session").decode(raw.key.ownerSession);
+      if (!acknowledged.ok || acknowledged.value.status === "migration-required" || !desired.ok || !actor.ok || !ownerSession.ok)
+        return invalid();
+      const readAddress = acknowledged.value.status === "present" ? acknowledged.value.envelope.address : acknowledged.value.address;
+      if (!record(raw.key.address) || canonicalEditingJson(raw.key.address) !== canonicalEditingJson(readAddress) || readAddress.owner !== actor.value || acknowledged.value.status === "present" && acknowledged.value.envelope.schemaVersion !== raw.schemaVersion)
+        return invalid();
+      const inFlight = raw.inFlight === null ? ok(null) : state.mutation.decode(raw.inFlight);
+      if (!inFlight.ok || inFlight.value && (stateAddressKey(inFlight.value.address) !== stateAddressKey(readAddress) || inFlight.value.expected.actor !== actor.value || inFlight.value.schemaVersion !== raw.schemaVersion || inFlight.value.localGeneration > Number(raw.localGeneration)))
+        return invalid();
+      const rejection = input.rejection === null ? ok(null) : receipt.decode(input.rejection);
+      if (!rejection.ok || rejection.value && (rejection.value.outcome.status !== "rejected" || stateAddressKey(rejection.value.request.mutation.address) !== stateAddressKey(readAddress) || rejection.value.request.mutation.schemaVersion !== raw.schemaVersion || rejection.value.request.mutation.localGeneration > Number(raw.localGeneration) || inFlight.value !== null && (rejection.value.request.mutation.operationId === inFlight.value.operationId || rejection.value.request.mutation.localGeneration >= inFlight.value.localGeneration) || canonicalEditingJson(target.encode(rejection.value.request.target)) !== canonicalEditingJson(target.encode(selected.value))))
+        return invalid();
+      return ok({
+        protocol: EDITING_PROTOCOL,
+        target: selected.value,
+        rejection: rejection.value,
+        draft: {
+          formatVersion: 1,
+          key: { address: readAddress, actor: actor.value, ownerSession: ownerSession.value },
+          schemaVersion: Number(raw.schemaVersion),
+          acknowledged: acknowledged.value,
+          desired: desired.value,
+          localGeneration: Number(raw.localGeneration),
+          inFlight: inFlight.value
+        }
+      });
+    },
+    encode(input) {
+      const raw = input.draft;
+      return {
+        protocol: input.protocol,
+        target: target.encode(input.target),
+        rejection: input.rejection ? receipt.encode(input.rejection) : null,
+        draft: {
+          formatVersion: 1,
+          key: raw.key,
+          schemaVersion: raw.schemaVersion,
+          acknowledged: state.read.encode(raw.acknowledged),
+          desired: value.encode(raw.desired),
+          localGeneration: raw.localGeneration,
+          inFlight: raw.inFlight ? state.mutation.encode(raw.inFlight) : null
+        }
+      };
+    }
+  };
+  return { scope, request, receipt, save, lookup, draft };
+}
+
+// editing-runtime.ts
+function frozen2(value) {
+  if (value && typeof value === "object") {
+    for (const child of Object.values(value))
+      frozen2(child);
+    Object.freeze(value);
+  }
+  return value;
+}
+function clone(codec, value) {
+  const result = codec.decode(structuredClone(codec.encode(value)));
+  if (!result.ok)
+    throw new TypeError(result.error.message);
+  return frozen2(result.value);
+}
+function createIdentityEditingState(options) {
+  if (options.transport.protocol !== EDITING_PROTOCOL)
+    throw new TypeError("Editing transport requires explicit editing/v1 negotiation.");
+  if (options.draftAddress.owner !== options.expected.actor)
+    throw new TypeError("Draft ownership must be the actual actor, distinct from the shared target.");
+  const target = clone(options.targetCodec, options.target);
+  const scope = frozen2({ draftAddress: { ...options.draftAddress }, target, schemaVersion: options.definition.schemaVersion, expected: { ...options.expected } });
+  const codecs = editingCodecs(options.definition.codec, options.targetCodec);
+  const stateWire = stateCodecs(options.definition.codec);
+  const sameTarget = (candidate) => canonicalEditingJson(options.targetCodec.encode(candidate)) === canonicalEditingJson(options.targetCodec.encode(target));
+  const normalize = (codec, value) => {
+    try {
+      const parsed = codec.decode(structuredClone(codec.encode(value)));
+      return parsed.ok ? ok(frozen2(parsed.value)) : parsed;
+    } catch {
+      return err("incompatible", "Editing response failed codec validation.");
+    }
+  };
+  const request = (mutation) => clone(codecs.request, { protocol: EDITING_PROTOCOL, target, mutation });
+  const checkReceipt = (receipt, submitted) => {
+    if (canonicalEditingJson(codecs.request.encode(receipt.request)) !== canonicalEditingJson(codecs.request.encode(submitted)))
+      return err("invalid-operation", "Editing receipt does not bind the exact immutable request.");
+    return receipt.outcome.status === "rejected" ? ok({ status: "rejected", operationId: receipt.outcome.operationId, evidence: codecs.receipt.encode(receipt) }) : ok(receipt.outcome);
+  };
+  const transport = {
+    async load(_input, readOptions) {
+      const response = await options.transport.load(scope, readOptions);
+      return response.ok ? normalize(stateWire.read, response.value) : response;
+    },
+    async save(mutation, readOptions) {
+      const submitted = request(mutation);
+      const response = await options.transport.save(submitted, readOptions);
+      if (!response.ok)
+        return response;
+      const parsed = normalize(codecs.save, response.value);
+      if (!parsed.ok)
+        return parsed;
+      if ("status" in parsed.value)
+        return parsed.value.operationId === mutation.operationId ? ok({ status: "indeterminate", operationId: mutation.operationId }) : err("invalid-operation", "Unknown outcome names another operation.");
+      return checkReceipt(parsed.value, submitted);
+    },
+    async reconcile(input, readOptions) {
+      const submitted = request(input.mutation);
+      const response = await options.transport.reconcile(submitted, readOptions);
+      if (!response.ok)
+        return response;
+      const parsed = normalize(codecs.lookup, response.value);
+      if (!parsed.ok)
+        return parsed;
+      if (parsed.value.status !== "final")
+        return ok(parsed.value);
+      const checked = checkReceipt(parsed.value.outcome, submitted);
+      return checked.ok ? ok({ status: "final", outcome: checked.value }) : checked;
+    },
+    subscribe: (_address, listener) => options.transport.subscribe(scope, (event) => {
+      const parsed = normalize(stateWire.invalidation, event);
+      if (parsed.ok)
+        listener(parsed.value);
+    })
+  };
+  const toDraft = (draft) => {
+    const rejection = draft.rejection ? codecs.receipt.decode(draft.rejection) : ok(null);
+    if (!rejection.ok)
+      throw new TypeError(rejection.error.message);
+    return clone(codecs.draft, { protocol: EDITING_PROTOCOL, target, draft, rejection: rejection.value });
+  };
+  const fromDraft = (draft) => {
+    const parsed = normalize(codecs.draft, draft);
+    if (!parsed.ok)
+      return parsed;
+    if (!sameTarget(parsed.value.target) || stateAddressKey(parsed.value.draft.key.address) !== stateAddressKey(scope.draftAddress))
+      return err("invalid-input", "Checkpoint belongs to another publication target or draft address.");
+    return ok(frozen2({ ...parsed.value.draft, rejection: parsed.value.rejection ? codecs.receipt.encode(parsed.value.rejection) : null, rejectedGeneration: parsed.value.rejection?.request.mutation.localGeneration ?? -1 }));
+  };
+  const fromCheckpoint = (checkpoint) => {
+    if (!Number.isSafeInteger(checkpoint.revision) || checkpoint.revision < 0)
+      return err("invalid-input", "Invalid checkpoint revision.");
+    const parsed = fromDraft(checkpoint.draft);
+    return parsed.ok ? ok({ revision: checkpoint.revision, draft: parsed.value }) : parsed;
+  };
+  const toCheckpoint = (checkpoint) => frozen2({ revision: checkpoint.revision, draft: toDraft(checkpoint.draft) });
+  const storage = options.drafts ? {
+    async find(_address, _actor, limit) {
+      const found = await options.drafts.find(scope, limit);
+      if (!found.ok)
+        return found;
+      if (found.value.length > limit)
+        return err("limit-exceeded", "Too many editing checkpoints.");
+      const results = [];
+      for (const entry of found.value) {
+        const parsed = fromCheckpoint(entry);
+        if (!parsed.ok)
+          return parsed;
+        results.push(parsed.value);
+      }
+      return ok(results);
+    },
+    async write(draft, revision) {
+      const captured = toDraft(draft);
+      const saved = await options.drafts.write(captured, revision);
+      if (!saved.ok)
+        return saved;
+      if (saved.value.revision <= (revision ?? -1))
+        return err("incompatible", "Checkpoint storage did not advance its conditional revision.");
+      const parsed = fromCheckpoint(saved.value);
+      if (!parsed.ok)
+        return parsed;
+      if (canonicalEditingJson(codecs.draft.encode(saved.value.draft)) !== canonicalEditingJson(codecs.draft.encode(captured)))
+        return err("incompatible", "Checkpoint storage returned different draft content.");
+      return parsed;
+    },
+    remove(key, revision) {
+      return options.drafts.remove({ target, draftKey: key }, revision);
+    }
+  } : undefined;
+  const core = createStateController({
+    address: scope.draftAddress,
+    expected: scope.expected,
+    ownerSession: options.ownerSession,
+    definition: options.definition,
+    transport,
+    ...storage ? { drafts: storage } : {},
+    ...options.scheduler ? { scheduler: options.scheduler } : {},
+    retryLimit: 0,
+    onConflict: options.onConflict,
+    initializeEmpty: options.initializeEmpty,
+    currentSession: options.currentSession
+  }, true);
+  let snapshot;
+  const update = () => {
+    const state = core.getSnapshot();
+    const detail = core.inspect();
+    const blocked = state.status === "blocked" ? state : null;
+    const status = state.status === "detached" ? "detached" : state.status === "loading" ? "loading" : detail.editable ? "loaded" : "fenced";
+    const retained = detail.draft ? toDraft(detail.draft) : null;
+    const reason = blocked?.reason;
+    const publication = status === "fenced" || status === "detached" ? "fenced" : detail.saving ? "saving" : detail.pending ? "unknown" : reason === "conflict" ? "conflict" : reason === "rejected" || retained?.rejection ? "rejected" : "idle";
+    snapshot = frozen2({
+      protocol: EDITING_PROTOCOL,
+      status,
+      scope,
+      ownerSession: options.ownerSession,
+      desired: detail.desired,
+      localGeneration: detail.generation,
+      acknowledged: detail.base,
+      dirty: detail.dirty,
+      editable: detail.editable,
+      submitted: detail.pending ? request(detail.pending) : null,
+      publication: {
+        eligible: detail.saveEligible && detail.editable && !detail.pending && !detail.saving && reason !== "conflict" && detail.checkpoint.status !== "failed",
+        status: publication,
+        message: blocked?.message ?? null,
+        rejection: retained?.rejection ?? null,
+        conflict: blocked?.conflict ?? null
+      },
+      checkpoint: detail.checkpoint,
+      draft: retained
+    });
+  };
+  update();
+  const stop = core.subscribe(update);
+  return {
+    draftStorage: options.drafts ?? null,
+    getSnapshot: () => snapshot,
+    subscribe: (listener) => core.subscribe(listener),
+    start: () => core.start(),
+    edit: (value) => core.edit(value),
+    flush: () => core.flush(),
+    reconnect: (input) => core.reconnect(input),
+    resolveConflict: (token, decision) => core.resolveConflict(token, decision),
+    async checkpoint() {
+      const saved = await core.checkpoint();
+      return saved.ok ? ok(saved.value ? toCheckpoint(saved.value) : null) : saved;
+    },
+    async recoveryCandidates(readOptions) {
+      const found = await core.recoveryCandidates(readOptions);
+      return found.ok ? ok(found.value.map(toCheckpoint)) : found;
+    },
+    recover(candidate) {
+      const parsed = fromCheckpoint(candidate);
+      return parsed.ok ? core.recover(parsed.value) : Promise.resolve(parsed);
+    },
+    discardRecovery(candidate) {
+      const parsed = fromCheckpoint(candidate);
+      return parsed.ok ? core.discardRecovery(parsed.value) : Promise.resolve(parsed);
+    },
+    detach(reason) {
+      const retained = core.detach(reason);
+      return retained ? toDraft(retained) : null;
+    },
+    close: (input) => core.close(input),
+    dispose() {
+      core.dispose();
+      stop();
+    }
+  };
+}
+function bindIdentityEditingState(options, retirementOwner) {
+  if (!options.resourceKey || options.resourceKey.length > 1024)
+    throw new TypeError("Editing binding requires a bounded semantic resource key.");
+  const target = clone(options.targetCodec, options.target);
+  const targetKey = canonicalEditingJson(options.targetCodec.encode(target));
+  let currentController = null;
+  return bindOwnedIdentityController({
+    client: options.client,
+    view: options.view,
+    target: "actor",
+    editPolicy: "actor-only",
+    ...options.onUnpersistedDraft ? { onUnpersistedDraft: options.onUnpersistedDraft } : {},
+    hasPending: (state) => state.dirty || state.submitted !== null || state.checkpoint.status === "failed" || state.publication.rejection !== null,
+    create(input) {
+      const controller = options.create(input);
+      const state = controller.getSnapshot();
+      if (canonicalEditingJson(options.targetCodec.encode(state.scope.target)) !== targetKey || state.scope.expected.actor !== input.session.actor.identity.key || state.scope.expected.session !== input.session.stamp || state.scope.draftAddress.owner !== input.session.actor.identity.key || state.ownerSession !== input.ownerSession) {
+        controller.dispose();
+        throw new TypeError("Editing binding factory returned another target or owner.");
+      }
+      currentController = controller;
+      return controller;
+    },
+    preservation(controller, session) {
+      const actual = currentController;
+      const state = controller.getSnapshot();
+      return actual?.draftStorage ? { storage: actual.draftStorage, scope: {
+        address: state.scope.draftAddress,
+        actor: session.actor.identity.key,
+        schemaVersion: state.scope.schemaVersion,
+        targetKey
+      } } : null;
+    }
+  }, retirementOwner);
+}
+export {
+  editingCodecs,
+  createIdentityEditingState,
+  bindIdentityEditingState,
+  EDITING_PROTOCOL,
+  EDITING_LIMITS
+};