@brightbeamai/chap-coordinator 0.3.1 → 0.3.3

package/dist/index.js

@@ -654,21 +654,211 @@ function diffJsonPatch(from, to, basePath = "") {
 }
 
 // src/storage/store.ts
+var COLLECTIONS = [
+  "members",
+  "tasks",
+  "overrides",
+  "whispers",
+  "deliberations",
+  "handoffs",
+  "snapshots",
+  "route_decisions"
+];
+var IDEMPOTENCY_KEYS = "idempotency_keys";
+var StoreConflictError = class extends Error {
+  workspace;
+  /** Audit entries the store holds. */
+  held;
+  /** Audit entries the change expected. */
+  base;
+  constructor(workspace, held, base) {
+    super(
+      `The store holds ${held} audit entries for workspace ${workspace} and this write expected ${base}, so nothing was written. Another coordinator may be writing to this workspace, the store may have been changed outside this coordinator, or this coordinator could not load the workspace when it started. Restart this coordinator to reload.`
+    );
+    this.name = "StoreConflictError";
+    this.workspace = workspace;
+    this.held = held;
+    this.base = base;
+  }
+  /**
+   * Matched by name, so `instanceof` holds across the package's entry points,
+   * each of which is bundled with its own copy of this class.
+   */
+  static [Symbol.hasInstance](value) {
+    return value instanceof Error && value.name === "StoreConflictError";
+  }
+};
+function isCollection(name) {
+  return COLLECTIONS.includes(name);
+}
+function objectKey(collection, item) {
+  if (item === null || typeof item !== "object") return void 0;
+  const o = item;
+  const key = collection === "members" ? o.uri ?? o.id : o.id ?? o.uri;
+  return typeof key === "string" ? key : void 0;
+}
+function keyed(collection, value) {
+  const out = {};
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      const key = objectKey(collection, item);
+      if (key !== void 0) out[key] = item;
+    }
+  } else if (value !== null && typeof value === "object") {
+    Object.assign(out, value);
+  }
+  return out;
+}
+function changeFromRecord(record) {
+  const data = record.data !== null && typeof record.data === "object" ? record.data : {};
+  const meta = {};
+  const objects = {};
+  let entries = [];
+  for (const [name, value] of Object.entries(data)) {
+    if (name === "audit") entries = Array.isArray(value) ? value : [];
+    else if (name === IDEMPOTENCY_KEYS || isCollection(name)) objects[name] = keyed(name, value);
+    else meta[name] = value;
+  }
+  if (meta.id === void 0) meta.id = record.id;
+  return {
+    id: record.id,
+    base: 0,
+    version: record.version,
+    updated_at: record.updated_at,
+    meta,
+    entries,
+    objects,
+    replace: true
+  };
+}
+function assembleSnapshot(meta, entries, objects) {
+  const data = { ...meta };
+  for (const name of COLLECTIONS) data[name] = [];
+  const keys = {};
+  data[IDEMPOTENCY_KEYS] = keys;
+  for (const [collection, key, value] of objects) {
+    if (collection === IDEMPOTENCY_KEYS) {
+      keys[key] = value;
+    } else {
+      const list = Array.isArray(data[collection]) ? data[collection] : data[collection] = [];
+      list.push(value);
+    }
+  }
+  data.audit = entries;
+  return data;
+}
 var MemoryStore = class {
-  records = /* @__PURE__ */ new Map();
+  held = /* @__PURE__ */ new Map();
   load() {
-    return Array.from(this.records.values());
+    const out = [];
+    for (const [id, h] of this.held) {
+      const objects = [];
+      for (const [collection, items] of h.objects) {
+        for (const [key, value] of items) objects.push([collection, key, JSON.parse(value)]);
+      }
+      out.push({
+        id,
+        data: assembleSnapshot(JSON.parse(h.meta), h.entries.map((e) => JSON.parse(e)), objects),
+        version: h.version,
+        updated_at: h.updated_at
+      });
+    }
+    return out;
   }
   save(record) {
-    this.records.set(record.id, record);
+    this.apply(changeFromRecord(record));
+  }
+  apply(change) {
+    const meta = JSON.stringify(change.meta);
+    const entries = change.entries.map((e) => JSON.stringify(e));
+    const objects = Object.entries(change.objects).map(([collection, items]) => [collection, Object.entries(items).map(([key, value]) => [key, value === null || value === void 0 ? null : JSON.stringify(value)])]);
+    let h = this.held.get(change.id);
+    if (!change.replace) {
+      const holds = h ? h.entries.length : 0;
+      if (holds !== change.base) throw new StoreConflictError(change.id, holds, change.base);
+    }
+    if (!h || change.replace) {
+      h = { meta: "{}", version: 0, updated_at: "", entries: [], objects: /* @__PURE__ */ new Map() };
+    }
+    for (const entry of entries) h.entries.push(entry);
+    for (const [collection, items] of objects) {
+      let held = h.objects.get(collection);
+      if (!held) h.objects.set(collection, held = /* @__PURE__ */ new Map());
+      for (const [key, value] of items) {
+        if (value === null) held.delete(key);
+        else held.set(key, value);
+      }
+    }
+    h.meta = meta;
+    h.version = change.version;
+    h.updated_at = change.updated_at;
+    this.held.set(change.id, h);
   }
   delete(id) {
-    this.records.delete(id);
+    this.held.delete(id);
   }
-  close() {
-    this.records.clear();
+};
+
+// src/tracked.ts
+var TrackedMap = class extends Map {
+  /** Keys whose objects may have changed since the last write. */
+  dirty = /* @__PURE__ */ new Set();
+  tracker;
+  constructor(tracker) {
+    super();
+    this.tracker = tracker;
+  }
+  reading() {
+    return this.tracker.enabled && this.tracker.depth > 0;
+  }
+  touchAll() {
+    if (this.reading()) for (const key of super.keys()) this.dirty.add(key);
+  }
+  get(key) {
+    const value = super.get(key);
+    if (value !== void 0 && this.reading()) this.dirty.add(key);
+    return value;
+  }
+  set(key, value) {
+    if (this.tracker.enabled) this.dirty.add(key);
+    return super.set(key, value);
+  }
+  delete(key) {
+    const had = super.delete(key);
+    if (had && this.tracker.enabled) this.dirty.add(key);
+    return had;
+  }
+  clear() {
+    if (this.tracker.enabled) for (const key of super.keys()) this.dirty.add(key);
+    super.clear();
+  }
+  values() {
+    this.touchAll();
+    return super.values();
+  }
+  entries() {
+    this.touchAll();
+    return super.entries();
+  }
+  [Symbol.iterator]() {
+    this.touchAll();
+    return super[Symbol.iterator]();
+  }
+  forEach(callback, thisArg) {
+    this.touchAll();
+    super.forEach(callback, thisArg);
+  }
+  /** Read one value without recording it. */
+  peek(key) {
+    return super.get(key);
   }
 };
+function rawValues(map) {
+  return Map.prototype.values.call(map);
+}
+function rawEntries(map) {
+  return Map.prototype.entries.call(map);
+}
 
 // src/api.ts
 var CoordinatorError = class extends Error {
@@ -994,7 +1184,7 @@ function registerControl(coord) {
     const include = Array.isArray(p.include) ? [...p.include] : ["members", "open_tasks", "mode_ceiling"];
     const state = {};
     if (include.includes("members")) {
-      const members = Array.from(ws.members.values()).map((m) => ({
+      const members = Array.from(rawValues(ws.members)).map((m) => ({
         uri: m.uri,
         type: m.type,
         ...m.role ? { role: m.role } : {},
@@ -1003,7 +1193,7 @@ function registerControl(coord) {
       if (members.length) state.members = members;
     }
     if (include.includes("open_tasks")) {
-      const tasks = Array.from(ws.tasks.values()).filter((t) => t.state !== "completed" && t.state !== "declined" && t.state !== "cancelled" && t.state !== "superseded").map((t) => ({
+      const tasks = Array.from(rawValues(ws.tasks)).filter((t) => t.state !== "completed" && t.state !== "declined" && t.state !== "cancelled" && t.state !== "superseded").map((t) => ({
         id: t.id,
         kind: t.kind,
         state: t.state,
@@ -1872,6 +2062,7 @@ function registerWhisper(coord) {
       if (cutoff < deadline) continue;
       prompt.state = "lapsed";
       prompt.default_applied = prompt.default_if_lapsed;
+      ws.whispers.set(prompt.id, prompt);
       const notify = {
         jsonrpc: "2.0",
         method: "notify.message",
@@ -1994,6 +2185,16 @@ function indexSigned(index, entry) {
   if (entry.outcome != null) index.refused.set(digest, { seq: entry.seq, code: entry.outcome.code });
   else index.accepted.add(digest);
 }
+function isThenable(value) {
+  return typeof value?.then === "function";
+}
+function ownCopy(value) {
+  try {
+    return structuredClone(value);
+  } catch {
+    return value;
+  }
+}
 var REVIEW_REQUEST_STOPPED = ["cancelled", "superseded", "paused"];
 var Coordinator = class {
   workspaces = /* @__PURE__ */ new Map();
@@ -2002,6 +2203,14 @@ var Coordinator = class {
   store;
   wsVersions = /* @__PURE__ */ new Map();
   saveChains = /* @__PURE__ */ new Map();
+  /** Records which objects change, for stores that implement `apply`. */
+  tracker;
+  /** What the store holds of each workspace, as far as this instance knows. */
+  persisted = /* @__PURE__ */ new WeakMap();
+  /** Workspaces with entries not yet written in the call being handled. */
+  unflushed = /* @__PURE__ */ new Set();
+  /** Workspaces with a write queued behind an async write in flight. */
+  flushQueued = /* @__PURE__ */ new Set();
   clockMs;
   frozenNow;
   auditListeners = [];
@@ -2022,6 +2231,7 @@ var Coordinator = class {
   constructor(options = {}) {
     this.options = options;
     this.store = options.store ?? new MemoryStore();
+    this.tracker = { enabled: typeof this.store.apply === "function", depth: 0 };
     this.ids = new IdFactory(!!options.deterministicIds, 0n, 17e11);
     if (options.deterministicClock) this.clockMs = 17e11;
     if (options.onAudit) this.auditListeners.push(options.onAudit);
@@ -2037,7 +2247,7 @@ var Coordinator = class {
     });
     try {
       const loaded = this.store.load();
-      if (!(loaded instanceof Promise)) {
+      if (!isThenable(loaded)) {
         this.applyRecords(loaded);
       }
     } catch {
@@ -2055,18 +2265,181 @@ var Coordinator = class {
     this.wsVersions.clear();
     this.restore(records.map((r) => r.data));
     for (const r of records) this.wsVersions.set(r.id, r.version);
+    for (const ws of this.workspaces.values()) this.markWritten(ws);
   }
-  /** Persist the current snapshot of one workspace to the store. */
+  /** A map for a workspace collection, tracked for stores that implement `apply`. */
+  newMap() {
+    return new TrackedMap(this.tracker);
+  }
+  /** Record that the store holds this workspace exactly as it is in memory. */
+  markWritten(ws) {
+    for (const name of COLLECTIONS) {
+      const map = ws[name];
+      if (map instanceof TrackedMap) map.dirty.clear();
+    }
+    this.persisted.set(ws, { seq: ws.audit.length, replace: false, keys: /* @__PURE__ */ new Set() });
+  }
+  /**
+   * What the store holds of a workspace. A workspace this instance did not
+   * create or load, such as one an application put in `workspaces` itself,
+   * or one whose maps an application replaced, is tracked from here on and
+   * written whole once.
+   */
+  persistedOf(ws) {
+    let p = this.persisted.get(ws);
+    let untracked = false;
+    for (const name of COLLECTIONS) {
+      const map = ws[name];
+      if (map instanceof TrackedMap && map.tracker === this.tracker) continue;
+      untracked = true;
+      const tracked = new TrackedMap(this.tracker);
+      for (const [key, value] of Map.prototype.entries.call(map)) {
+        tracked.set(key, value);
+      }
+      ws[name] = tracked;
+    }
+    if (!p || untracked) {
+      p = { seq: p?.seq ?? 0, replace: true, keys: /* @__PURE__ */ new Set(), updatedAt: p?.updatedAt };
+      this.persisted.set(ws, p);
+    }
+    return p;
+  }
+  /** Record that a task.create idempotency key was written or removed. */
+  markKey(ws, key) {
+    if (this.tracker.enabled) this.persistedOf(ws).keys.add(key);
+  }
+  /** After an entry is appended: write now, or when the call being handled ends. */
   persist(ws) {
+    if (!this.tracker.enabled) {
+      this.persistSnapshot(ws);
+      return;
+    }
+    this.persistedOf(ws).updatedAt = this.now();
+    if (this.tracker.depth > 0) this.unflushed.add(ws);
+    else this.flush(ws);
+  }
+  flushUnflushed() {
+    if (!this.unflushed.size) return;
+    const list = [...this.unflushed];
+    this.unflushed.clear();
+    for (const ws of list) this.flush(ws);
+  }
+  /** Write what changed in one workspace since its last write. */
+  flush(ws) {
+    const pending = this.saveChains.get(ws.id);
+    if (pending) {
+      if (this.flushQueued.has(ws)) return;
+      this.flushQueued.add(ws);
+      this.chainWrite(ws.id, pending.then(() => {
+        this.flushQueued.delete(ws);
+        return this.writeChange(ws);
+      }));
+      return;
+    }
+    const result = this.writeChange(ws);
+    if (result) this.chainWrite(ws.id, result);
+  }
+  chainWrite(id, work) {
+    const guarded = work.catch(() => void 0);
+    this.saveChains.set(id, guarded);
+    void guarded.then(() => {
+      if (this.saveChains.get(id) === guarded) this.saveChains.delete(id);
+    });
+  }
+  writeChange(ws) {
+    const p = this.persistedOf(ws);
+    let change;
+    try {
+      change = this.takeChange(ws, p);
+    } catch (err) {
+      p.replace = true;
+      this.reportStoreError(err, { id: ws.id, version: ws.audit.length });
+      return;
+    }
+    if (!change) return;
+    const taken = change;
+    const done = () => {
+      p.seq = taken.version;
+      if (taken.replace) p.replace = false;
+    };
+    const failed = (err) => {
+      this.giveBack(ws, p, taken);
+      this.reportStoreError(err, { id: taken.id, version: taken.version });
+    };
+    let result;
+    try {
+      result = this.store.apply(taken);
+    } catch (err) {
+      failed(err);
+      return;
+    }
+    if (isThenable(result)) return Promise.resolve(result).then(done, failed);
+    done();
+  }
+  /** The change since the last write, taking the recorded keys with it. */
+  takeChange(ws, p) {
+    const replace = p.replace;
+    const objects = {};
+    for (const name of COLLECTIONS) {
+      const map = ws[name];
+      if (replace) {
+        const all = {};
+        for (const [key, value] of Map.prototype.entries.call(map)) {
+          all[key] = value;
+        }
+        objects[name] = all;
+      } else if (map.dirty.size) {
+        const changed = {};
+        for (const key of map.dirty) changed[key] = map.peek(key) ?? null;
+        objects[name] = changed;
+      }
+      map.dirty.clear();
+    }
+    if (replace) {
+      objects[IDEMPOTENCY_KEYS] = { ...ws.idempotency_keys };
+    } else if (p.keys.size) {
+      const changed = {};
+      for (const key of p.keys) changed[key] = ws.idempotency_keys[key] ?? null;
+      objects[IDEMPOTENCY_KEYS] = changed;
+    }
+    p.keys.clear();
+    const entries = ws.audit.slice(replace ? 0 : p.seq);
+    if (!replace && !entries.length && !Object.keys(objects).length) return void 0;
+    return {
+      id: ws.id,
+      base: replace ? 0 : p.seq,
+      version: ws.audit.length,
+      updated_at: p.updatedAt ?? ws.audit[ws.audit.length - 1]?.arrived ?? ws.created,
+      meta: this.metaOf(ws),
+      entries,
+      objects,
+      ...replace ? { replace: true } : {}
+    };
+  }
+  /** A failed write's keys go back, so the next write carries them again. */
+  giveBack(ws, p, change) {
+    if (change.replace) {
+      p.replace = true;
+      return;
+    }
+    for (const [name, items] of Object.entries(change.objects)) {
+      if (name === IDEMPOTENCY_KEYS) {
+        for (const key of Object.keys(items)) p.keys.add(key);
+        continue;
+      }
+      const map = ws[name];
+      if (map instanceof TrackedMap) for (const key of Object.keys(items)) map.dirty.add(key);
+    }
+  }
+  /** Persist the whole workspace, for a store that implements only `save`. */
+  persistSnapshot(ws) {
     const next = (this.wsVersions.get(ws.id) ?? 0) + 1;
     this.wsVersions.set(ws.id, next);
     let record;
     try {
-      const all = this.snapshot();
-      const data = all.find((w) => w.id === ws.id);
-      if (!data) return;
-      record = { id: ws.id, data, version: next, updated_at: this.now() };
-    } catch {
+      record = { id: ws.id, data: this.snapshotOf(ws), version: next, updated_at: this.now() };
+    } catch (err) {
+      this.reportStoreError(err, { id: ws.id, version: next });
       return;
     }
     const pending = this.saveChains.get(ws.id);
@@ -2081,8 +2454,8 @@ var Coordinator = class {
       this.reportStoreError(err, record);
       return;
     }
-    if (result instanceof Promise) {
-      this.trackSave(result, record);
+    if (isThenable(result)) {
+      this.trackSave(Promise.resolve(result), record);
     }
   }
   trackSave(save, record) {
@@ -2100,7 +2473,10 @@ var Coordinator = class {
         this.options.onStoreError(err, { id: record.id, version: record.version });
       } catch {
       }
+      return;
     }
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(`chap coordinator: writing workspace ${record.id} to the store failed: ${message}`);
   }
   async drainSaves() {
     while (this.saveChains.size) {
@@ -2174,122 +2550,150 @@ var Coordinator = class {
   /** Serialise all workspaces to a JSON-safe structure for persistence. */
   snapshot() {
     const out = [];
-    for (const ws of this.workspaces.values()) {
-      out.push({
-        id: ws.id,
-        created: ws.created,
-        state: ws.state,
-        profiles: ws.profiles,
-        mode: ws.mode,
-        mode_ceiling: ws.mode_ceiling,
-        routing_policy_uri: ws.routing_policy_uri,
-        step_up_window_sec: ws.step_up_window_sec,
-        min_acr: ws.min_acr,
-        members: Array.from(ws.members.values()),
-        tasks: Array.from(ws.tasks.values()),
-        overrides: Array.from(ws.overrides.values()),
-        whispers: Array.from(ws.whispers.values()),
-        deliberations: Array.from(ws.deliberations.values()),
-        handoffs: Array.from(ws.handoffs.values()),
-        snapshots: Array.from(ws.snapshots.values()),
-        route_decisions: Array.from(ws.route_decisions.values()),
-        idempotency_keys: ws.idempotency_keys,
-        audit: ws.audit,
-        chain_head: ws.chain_head,
-        chain_enabled: ws.chain_enabled
-      });
-    }
+    for (const ws of this.workspaces.values()) out.push(this.snapshotOf(ws));
     return out;
   }
+  /** The workspace's own fields: everything except its collections and log. */
+  metaOf(ws) {
+    return {
+      id: ws.id,
+      created: ws.created,
+      state: ws.state,
+      profiles: ws.profiles,
+      mode: ws.mode,
+      mode_ceiling: ws.mode_ceiling,
+      routing_policy_uri: ws.routing_policy_uri,
+      step_up_window_sec: ws.step_up_window_sec,
+      min_acr: ws.min_acr,
+      chain_head: ws.chain_head,
+      chain_enabled: ws.chain_enabled
+    };
+  }
+  /** One workspace as `snapshot()` holds it. Reads nothing as a change. */
+  snapshotOf(ws) {
+    const { chain_head, chain_enabled, ...own } = this.metaOf(ws);
+    return {
+      ...own,
+      members: Array.from(rawValues(ws.members)),
+      tasks: Array.from(rawValues(ws.tasks)),
+      overrides: Array.from(rawValues(ws.overrides)),
+      whispers: Array.from(rawValues(ws.whispers)),
+      deliberations: Array.from(rawValues(ws.deliberations)),
+      handoffs: Array.from(rawValues(ws.handoffs)),
+      snapshots: Array.from(rawValues(ws.snapshots)),
+      route_decisions: Array.from(rawValues(ws.route_decisions)),
+      idempotency_keys: { ...ws.idempotency_keys },
+      audit: ws.audit,
+      chain_head,
+      chain_enabled
+    };
+  }
   /** Restore from a snapshot produced by ``snapshot()``. Replaces
    *  any existing in-memory workspaces. */
   restore(data) {
     this.workspaces.clear();
+    this.unflushed.clear();
     if (!Array.isArray(data)) return;
     for (const w of data) {
-      const ws = {
-        id: w.id,
-        created: w.created,
-        state: w.state ?? "active",
-        profiles: w.profiles ?? [],
-        mode: w.mode ?? "trial",
-        mode_ceiling: w.mode_ceiling ?? "production",
-        routing_policy_uri: w.routing_policy_uri,
-        step_up_window_sec: w.step_up_window_sec ?? 300,
-        min_acr: w.min_acr,
-        members: /* @__PURE__ */ new Map(),
-        tasks: /* @__PURE__ */ new Map(),
-        overrides: /* @__PURE__ */ new Map(),
-        whispers: /* @__PURE__ */ new Map(),
-        deliberations: /* @__PURE__ */ new Map(),
-        handoffs: /* @__PURE__ */ new Map(),
-        snapshots: /* @__PURE__ */ new Map(),
-        route_decisions: /* @__PURE__ */ new Map(),
-        idempotency_keys: w.idempotency_keys ?? {},
-        audit: w.audit ?? [],
-        chain_head: w.chain_head,
-        chain_enabled: !!w.chain_enabled
-      };
-      for (const m of w.members ?? []) {
-        if (!Array.isArray(m.keys)) m.keys = [];
-        if (m.paused === void 0) m.paused = false;
-        ws.members.set(m.uri, m);
-      }
-      for (const t of w.tasks ?? []) ws.tasks.set(t.id, t);
-      for (const o of w.overrides ?? []) ws.overrides.set(o.id, o);
-      for (const x of w.whispers ?? [])
-        ws.whispers.set(x.id, x);
-      for (const x of w.deliberations ?? [])
-        ws.deliberations.set(x.id, x);
-      for (const x of w.handoffs ?? [])
-        ws.handoffs.set(x.id, x);
-      for (const x of w.snapshots ?? []) {
-        const content = structuredClone(x.content ?? {
-          workspace: x.workspace,
-          audit_seq: x.audit_seq,
-          include: x.include,
-          state: x.state,
-          ...x.label ? { label: x.label } : {}
-        });
-        if (!x.content) {
-          const oldState = content.state;
-          const state = {};
-          for (const key of ["mode_ceiling", "routing_policy_uri", "audit_seq"]) {
-            if (oldState[key] != null && oldState[key] !== "") state[key] = oldState[key];
-          }
-          for (const [key, fields] of [
-            ["members", ["uri", "type", "role", "scopes"]],
-            ["open_tasks", ["id", "kind", "state", "assignee"]]
-          ]) {
-            const items = oldState[key];
-            if (Array.isArray(items) && items.length) {
-              state[key] = items.map((item) => Object.fromEntries(fields.filter((field) => item[field] != null && item[field] !== "" && (!Array.isArray(item[field]) || item[field].length > 0)).map((field) => [field, item[field]])));
-            }
+      let ws;
+      try {
+        ws = this.rebuild(w);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        console.warn(`chap coordinator: workspace ${String(w?.id)} could not be restored: ${message}`);
+        continue;
+      }
+      this.workspaces.set(ws.id, ws);
+      for (const name of COLLECTIONS) ws[name].dirty.clear();
+      this.persisted.set(ws, { seq: 0, replace: true, keys: /* @__PURE__ */ new Set() });
+    }
+  }
+  /** One workspace from a snapshot entry, its maps tracked. */
+  rebuild(w) {
+    const ws = {
+      id: w.id,
+      created: w.created,
+      state: w.state ?? "active",
+      profiles: w.profiles ?? [],
+      mode: w.mode ?? "trial",
+      mode_ceiling: w.mode_ceiling ?? "production",
+      routing_policy_uri: w.routing_policy_uri,
+      step_up_window_sec: w.step_up_window_sec ?? 300,
+      min_acr: w.min_acr,
+      members: this.newMap(),
+      tasks: this.newMap(),
+      overrides: this.newMap(),
+      whispers: this.newMap(),
+      deliberations: this.newMap(),
+      handoffs: this.newMap(),
+      snapshots: this.newMap(),
+      route_decisions: this.newMap(),
+      idempotency_keys: w.idempotency_keys ?? {},
+      audit: w.audit ?? [],
+      chain_head: w.chain_head,
+      chain_enabled: !!w.chain_enabled
+    };
+    for (const m of w.members ?? []) {
+      if (!Array.isArray(m.keys)) m.keys = [];
+      if (m.paused === void 0) m.paused = false;
+      ws.members.set(m.uri, m);
+    }
+    for (const t of w.tasks ?? []) ws.tasks.set(t.id, t);
+    for (const o of w.overrides ?? []) ws.overrides.set(o.id, o);
+    for (const x of w.whispers ?? [])
+      ws.whispers.set(x.id, x);
+    for (const x of w.deliberations ?? [])
+      ws.deliberations.set(x.id, x);
+    for (const x of w.handoffs ?? [])
+      ws.handoffs.set(x.id, x);
+    for (const x of w.snapshots ?? []) {
+      const content = structuredClone(x.content ?? {
+        workspace: x.workspace,
+        audit_seq: x.audit_seq,
+        include: x.include,
+        state: x.state,
+        ...x.label ? { label: x.label } : {}
+      });
+      if (!x.content) {
+        const oldState = content.state;
+        const state = {};
+        for (const key of ["mode_ceiling", "routing_policy_uri", "audit_seq"]) {
+          if (oldState[key] != null && oldState[key] !== "") state[key] = oldState[key];
+        }
+        for (const [key, fields] of [
+          ["members", ["uri", "type", "role", "scopes"]],
+          ["open_tasks", ["id", "kind", "state", "assignee"]]
+        ]) {
+          const items = oldState[key];
+          if (Array.isArray(items) && items.length) {
+            state[key] = items.map((item) => Object.fromEntries(fields.filter((field) => item[field] != null && item[field] !== "" && (!Array.isArray(item[field]) || item[field].length > 0)).map((field) => [field, item[field]])));
           }
-          content.state = state;
         }
-        ws.snapshots.set(x.id, {
-          id: x.id,
-          kind: "snapshot",
-          produced_by: x.produced_by ?? x.by,
-          produced_at: x.produced_at ?? x.ts,
-          content_hash: x.content_hash ?? contentHash(content),
-          content
-        });
-      }
-      for (const x of w.route_decisions ?? [])
-        ws.route_decisions.set(x.id, x);
-      this.workspaces.set(ws.id, ws);
+        content.state = state;
+      }
+      ws.snapshots.set(x.id, {
+        id: x.id,
+        kind: "snapshot",
+        produced_by: x.produced_by ?? x.by,
+        produced_at: x.produced_at ?? x.ts,
+        content_hash: x.content_hash ?? contentHash(content),
+        content
+      });
     }
+    for (const x of w.route_decisions ?? [])
+      ws.route_decisions.set(x.id, x);
+    return ws;
   }
   // -- dispatch ------------------------------------------------------
   dispatch(envelope) {
     this.frozenNow = this.advanceClock();
+    this.tracker.depth++;
     try {
       const response = this._dispatch(envelope);
       if (response.error) this.recordRefusal(envelope, response.error);
       return response;
     } finally {
+      if (--this.tracker.depth === 0) this.flushUnflushed();
       this.frozenNow = void 0;
     }
   }
@@ -2401,7 +2805,7 @@ var Coordinator = class {
     }
     let out;
     try {
-      out = handler(params);
+      out = handler(ownCopy(params));
     } catch (e) {
       const msg = e instanceof Error ? e.message : String(e);
       return reply(envelope, { error: rpcError(E.INTERNAL, "Internal error", { detail: msg }) });
@@ -2412,7 +2816,7 @@ var Coordinator = class {
       const ws = this.workspaces.get(wsId);
       if (ws) this.recordAudit(ws, envelope);
     }
-    return reply(envelope, { result: out.result });
+    return reply(envelope, { result: ownCopy(out.result) });
   }
   // -- audit ---------------------------------------------------------
   recordAudit(ws, envelope) {
@@ -2656,20 +3060,21 @@ var Coordinator = class {
       routing_policy_uri: p.routing_policy_uri,
       step_up_window_sec: typeof p.step_up_window_sec === "number" ? p.step_up_window_sec : 300,
       min_acr: p.min_acr,
-      members: /* @__PURE__ */ new Map(),
-      tasks: /* @__PURE__ */ new Map(),
-      overrides: /* @__PURE__ */ new Map(),
-      whispers: /* @__PURE__ */ new Map(),
-      deliberations: /* @__PURE__ */ new Map(),
-      handoffs: /* @__PURE__ */ new Map(),
-      snapshots: /* @__PURE__ */ new Map(),
-      route_decisions: /* @__PURE__ */ new Map(),
+      members: this.newMap(),
+      tasks: this.newMap(),
+      overrides: this.newMap(),
+      whispers: this.newMap(),
+      deliberations: this.newMap(),
+      handoffs: this.newMap(),
+      snapshots: this.newMap(),
+      route_decisions: this.newMap(),
       idempotency_keys: {},
       audit: [],
       chain_enabled: chainEnabled,
       chain_head: chainEnabled ? ZERO_HASH : void 0
     };
     this.workspaces.set(id, ws);
+    this.persisted.set(ws, { seq: 0, replace: false, keys: /* @__PURE__ */ new Set() });
     return { result: { workspace: id, created: ws.created } };
   }
   opWorkspaceDescribe(p) {
@@ -2690,7 +3095,7 @@ var Coordinator = class {
       max_envelope_bytes: this.options.maxEnvelopeBytes ?? DEFAULT_MAX_ENVELOPE_BYTES,
       step_up_window_sec: ws.step_up_window_sec,
       profiles: ws.profiles,
-      members: Array.from(ws.members.values()).map(memberToDict),
+      members: Array.from(rawValues(ws.members)).map(memberToDict),
       audit_count: ws.audit.length,
       task_count: ws.tasks.size,
       override_count: ws.overrides.size,
@@ -2865,8 +3270,12 @@ var Coordinator = class {
     ws.tasks.set(taskId, task);
     if (typeof p.idempotency_key === "string") {
       ws.idempotency_keys[p.idempotency_key] = taskId;
+      this.markKey(ws, p.idempotency_key);
       const keys = Object.keys(ws.idempotency_keys);
-      if (keys.length > MAX_IDEMPOTENCY_KEYS) delete ws.idempotency_keys[keys[0]];
+      if (keys.length > MAX_IDEMPOTENCY_KEYS) {
+        delete ws.idempotency_keys[keys[0]];
+        this.markKey(ws, keys[0]);
+      }
     }
     return { result: { task_id: taskId, state: "created" } };
   }
@@ -2917,7 +3326,7 @@ var Coordinator = class {
       const now = this.now();
       if (!task.review) {
         const producer = p.from;
-        const eligible = [...ws.members.entries()].filter(([uri, member]) => uri !== producer && uri !== task.assignee && member.type === "human").map(([uri]) => uri);
+        const eligible = [...rawEntries(ws.members)].filter(([uri, member]) => uri !== producer && uri !== task.assignee && member.type === "human").map(([uri]) => uri);
         if (eligible.length === 0) {
           return { error: rpcError(
             E.NOT_AUTHORISED,
@@ -3481,6 +3890,7 @@ export {
   MemoryStore,
   PRIVILEGED_METHODS,
   PatchError,
+  StoreConflictError,
   ZERO_HASH,
   applyJsonPatch,
   call,