@super-line/server 0.10.1 → 0.11.0

package/README.md

@@ -76,7 +76,7 @@ replica.delete('title')           // surgical key delete (the only way to remove
 replica.close()
 ```
 
-`open` requires a store with reactive support (throws `UNSUPPORTED` otherwise). CRDT stores (`store-sync`, `store-sync-libsql`, `store-sync-pglite`) and the LWW stores both back it.
+`open` requires a store with reactive support (throws `UNSUPPORTED` otherwise). CRDT stores (`store-sync`, `store-sync-pglite`) and the LWW stores both back it.
 
 ### Control Center inspector
 

package/dist/index.cjs

@@ -205,27 +205,43 @@ var CONN = "c:";
 var USER = "u:";
 var REPLY = "reply:";
 var PLUGIN = "x:";
-var STORE = "s:";
+var CDOC = "d:";
 var SERVER_ORIGIN = "server";
 function createSuperLineServer(contract, opts) {
   const c = contract;
   const serializer = opts.serializer ?? import_core.jsonSerializer;
   const adapter = opts.adapter ?? createInMemoryAdapter();
-  const storeMap = opts.stores ?? {};
   const plugins = opts.plugins ?? [];
   const pluginNames = /* @__PURE__ */ new Set();
   for (const p of plugins) {
     if (pluginNames.has(p.name)) throw new Error(`Duplicate plugin name: ${p.name}`);
     pluginNames.add(p.name);
   }
+  const collectionStore = opts.collections;
+  const collectionDefs = c.collections ?? {};
+  const collectionPolicies = { ...opts.policies };
   for (const p of plugins) {
-    if (!p.stores) continue;
-    for (const [name, store] of Object.entries(p.stores)) {
-      if (name in storeMap)
-        throw new Error(`Plugin '${p.name}' store '${name}' collides with an existing store of that name`);
-      storeMap[name] = store;
+    if (!p.policies) continue;
+    for (const [name, policy] of Object.entries(p.policies)) {
+      if (!(name in collectionDefs))
+        throw new Error(
+          `Plugin '${p.name}' policy references unknown collection '${name}' \u2014 register its contract fragment on defineContract({ plugins })`
+        );
+      if (name in collectionPolicies)
+        throw new Error(`Plugin '${p.name}' policy for collection '${name}' collides with an existing policy`);
+      collectionPolicies[name] = policy;
     }
   }
+  const checkReferences = opts.checkReferences ?? false;
+  const collIsRelay = collectionStore?.clustering === "relay";
+  const crdtStore = opts.crdtCollections;
+  const crdtDefOf = (n) => {
+    const d = collectionDefs[n];
+    return d && (0, import_core.isCrdtCollection)(d) ? d : void 0;
+  };
+  const COLL_CHANNEL = "cbatch";
+  const collSubscribers = /* @__PURE__ */ new Map();
+  const connColl = /* @__PURE__ */ new Map();
   const reserved = [];
   for (const p of plugins) {
     if (!p.connection) continue;
@@ -319,8 +335,12 @@ function createSuperLineServer(contract, opts) {
       handlePersonal(channel, payload);
       return;
     }
-    if (channel.startsWith(STORE)) {
-      handleStoreRelay(channel, payload);
+    if (channel.startsWith(CDOC)) {
+      handleCrdtRelay(channel, payload);
+      return;
+    }
+    if (channel === COLL_CHANNEL) {
+      handleCollectionRelay(payload);
       return;
     }
     if (channel.startsWith(PLUGIN)) {
@@ -333,6 +353,7 @@ function createSuperLineServer(contract, opts) {
     if (busSet) deliverBus(payload, busSet);
   });
   void adapter.subscribe(replyChannel);
+  if (collectionStore && collIsRelay) void adapter.subscribe(COLL_CHANNEL);
   function handlePersonal(channel, payload) {
     const set = members.get(channel);
     if (!set) return;
@@ -566,6 +587,7 @@ function createSuperLineServer(contract, opts) {
     raw.onClose((code) => {
       conns.delete(conn);
       for (const channel of conn.channels) leaveChannel(conn, channel);
+      collUnsubAll(conn);
       void adapter.presence?.del(conn.id);
       const goneUserId = opts.identify?.(conn);
       emitTap({
@@ -600,10 +622,12 @@ function createSuperLineServer(contract, opts) {
     else if (frame.t === "unsub") {
       const ns = topicNamespace(conn.role, frame.c);
       if (ns) leaveChannel(conn, TOPIC + ns + ":" + frame.c);
-    } else if (frame.t === "sopen") await handleStoreOpen(conn, frame);
-    else if (frame.t === "srd") await handleStoreRead(conn, frame);
-    else if (frame.t === "swr") await handleStoreWrite(conn, frame);
-    else if (frame.t === "sclose") handleStoreClose(conn, frame);
+    } else if (frame.t === "csub") await handleCollectionSub(conn, frame);
+    else if (frame.t === "cuns") handleCollectionUnsub(conn, frame);
+    else if (frame.t === "cbat") await handleCollectionBatch(conn, frame);
+    else if (frame.t === "cdopen") await handleCrdtOpen(conn, frame);
+    else if (frame.t === "cdwr") await handleCrdtWrite(conn, frame);
+    else if (frame.t === "cdclose") handleCrdtClose(conn, frame);
     else if (frame.t === "sres") {
       await handleClientReply(conn, frame.i, { ok: true, d: frame.d });
     } else if (frame.t === "serr") {
@@ -696,90 +720,77 @@ function createSuperLineServer(contract, opts) {
       conn.send({ t: "res", i: frame.i, d: null });
     });
   }
-  function storeOrErr(conn, id, name) {
-    const store = storeMap[name];
-    if (!store) conn.send({ t: "err", i: id, code: "NOT_FOUND", m: `Unknown store: ${name}` });
-    return store;
-  }
-  async function handleStoreOpen(conn, frame) {
-    const store = storeOrErr(conn, frame.i, frame.n);
-    if (!store) return;
-    await dispatchOp(conn, frame.i, { kind: "subscribe", name: `store:${frame.n}/${frame.id}`, conn }, async () => {
-      const resource = await store.read(frame.id);
-      if (!resource) throw new import_core.SuperLineError("NOT_FOUND", `No resource: ${frame.n}/${frame.id}`);
+  function crdtMissing(conn, i, n) {
+    if (crdtStore && crdtDefOf(n)) return false;
+    conn.send({ t: "err", i, code: "NOT_FOUND", m: `Unknown CRDT collection: ${n}` });
+    return true;
+  }
+  async function handleCrdtOpen(conn, frame) {
+    if (crdtMissing(conn, frame.i, frame.n)) return;
+    const store = crdtStore;
+    await dispatchOp(conn, frame.i, { kind: "subscribe", name: `collection:${frame.n}/${frame.id}`, conn }, async () => {
+      const state = await store.read(frame.n, frame.id);
+      if (state === void 0) throw new import_core.SuperLineError("NOT_FOUND", `No document: ${frame.n}/${frame.id}`);
       const principal = conn.principal ?? conn.id;
-      if (!resource.accessRules[principal]?.read)
+      const policy = collectionPolicies[frame.n];
+      if (!policy?.read) throw new import_core.SuperLineError("FORBIDDEN", `Read denied: ${frame.n}/${frame.id}`);
+      const replica = store.open(frame.n, frame.id);
+      const snapshot = replica.getSnapshot();
+      replica.close();
+      if (!await policy.read(principal, frame.id, snapshot, conn.ctx))
         throw new import_core.SuperLineError("FORBIDDEN", `Read denied: ${frame.n}/${frame.id}`);
-      await joinChannel(conn, STORE + frame.n + ":" + frame.id);
-      if (taps.length) emitTap({ type: "store.subscribe", connId: conn.id, store: frame.n, id: frame.id });
-      conn.send({ t: "res", i: frame.i, d: resource.data });
+      await joinChannel(conn, CDOC + frame.n + ":" + frame.id);
+      conn.send({ t: "res", i: frame.i, d: state });
     });
   }
-  async function handleStoreRead(conn, frame) {
-    const store = storeOrErr(conn, frame.i, frame.n);
-    if (!store) return;
-    await dispatchOp(conn, frame.i, { kind: "request", name: `store:${frame.n}/${frame.id}`, conn }, async () => {
-      const resource = await store.read(frame.id);
-      if (!resource) throw new import_core.SuperLineError("NOT_FOUND", `No resource: ${frame.n}/${frame.id}`);
+  async function handleCrdtWrite(conn, frame) {
+    if (crdtMissing(conn, frame.i, frame.n)) return;
+    const store = crdtStore;
+    const def = crdtDefOf(frame.n);
+    await dispatchOp(conn, frame.i, { kind: "request", name: `collection:${frame.n}/${frame.id}`, conn }, async () => {
       const principal = conn.principal ?? conn.id;
-      if (!resource.accessRules[principal]?.read)
-        throw new import_core.SuperLineError("FORBIDDEN", `Read denied: ${frame.n}/${frame.id}`);
-      conn.send({ t: "res", i: frame.i, d: resource.data });
-    });
-  }
-  async function handleStoreWrite(conn, frame) {
-    const store = storeOrErr(conn, frame.i, frame.n);
-    if (!store) return;
-    await dispatchOp(conn, frame.i, { kind: "request", name: `store:${frame.n}/${frame.id}`, conn }, async () => {
-      const resource = await store.read(frame.id);
-      if (!resource) throw new import_core.SuperLineError("NOT_FOUND", `No resource: ${frame.n}/${frame.id}`);
-      const principal = conn.principal ?? conn.id;
-      if (!resource.accessRules[principal]?.write)
+      const policy = collectionPolicies[frame.n];
+      if (!policy?.write) throw new import_core.SuperLineError("FORBIDDEN", `Write denied: ${frame.n}/${frame.id}`);
+      if (!await policy.write(principal, frame.id, conn.ctx))
         throw new import_core.SuperLineError("FORBIDDEN", `Write denied: ${frame.n}/${frame.id}`);
-      await store.apply({ id: frame.id, update: frame.u, origin: frame.o });
-      if (taps.length)
-        emitTap({
-          type: "store.write",
-          store: frame.n,
-          id: frame.id,
-          origin: frame.o,
-          connId: conn.id,
-          data: frame.u
-        });
+      await store.apply(
+        { n: frame.n, id: frame.id, update: frame.u, origin: frame.o },
+        def.crdt,
+        (snapshot) => (0, import_core.validateSync)(def.schema, snapshot)
+      );
       conn.send({ t: "res", i: frame.i, d: null });
     });
   }
-  function handleStoreClose(conn, frame) {
-    if (!storeMap[frame.n]) return;
-    leaveChannel(conn, STORE + frame.n + ":" + frame.id);
-    if (taps.length) emitTap({ type: "store.unsubscribe", connId: conn.id, store: frame.n, id: frame.id });
+  function handleCrdtClose(conn, frame) {
+    if (!crdtDefOf(frame.n)) return;
+    leaveChannel(conn, CDOC + frame.n + ":" + frame.id);
   }
-  for (const [name, store] of Object.entries(storeMap)) {
-    const isSelf = store.clustering === "self";
-    store.onChange((change) => {
-      const channel = STORE + name + ":" + change.id;
+  if (crdtStore) {
+    const isSelf = crdtStore.clustering === "self";
+    crdtStore.onChange((change) => {
+      const channel = CDOC + change.n + ":" + change.id;
       if (isSelf) {
         const set = members.get(channel);
         if (!set) return;
-        const payload = serializer.encode({ t: "sch", n: name, id: change.id, u: change.update, o: change.origin });
+        const payload = serializer.encode({ t: "cdchg", n: change.n, id: change.id, u: change.update, o: change.origin });
         for (const conn of set) conn.sendRaw(payload);
         return;
       }
       if (relaying) return;
       void adapter.publish(
         channel,
-        serializer.encode({ t: "sch", n: name, id: change.id, u: change.update, o: change.origin, nd: instanceId })
+        serializer.encode({ t: "cdchg", n: change.n, id: change.id, u: change.update, o: change.origin, nd: instanceId })
       );
     });
     if (isSelf)
-      store.onDelete?.((id) => {
-        const set = members.get(STORE + name + ":" + id);
+      crdtStore.onDelete?.((n, id) => {
+        const set = members.get(CDOC + n + ":" + id);
         if (!set) return;
-        const payload = serializer.encode({ t: "sdel", n: name, id });
+        const payload = serializer.encode({ t: "cddel", n, id });
         for (const conn of set) conn.sendRaw(payload);
       });
   }
-  function handleStoreRelay(channel, payload) {
+  function handleCrdtRelay(channel, payload) {
     const set = members.get(channel);
     if (set) for (const conn of set) conn.sendRaw(payload);
     let frame;
@@ -789,20 +800,153 @@ function createSuperLineServer(contract, opts) {
       return;
     }
     if (frame.nd === instanceId) return;
-    const store = storeMap[frame.n];
-    if (!store || store.clustering !== "relay") return;
-    if (frame.t === "sdel") {
-      void store.delete(frame.id);
+    if (!crdtStore || crdtStore.clustering !== "relay") return;
+    const def = crdtDefOf(frame.n);
+    if (!def) return;
+    if (frame.t === "cddel") {
+      try {
+        void crdtStore.delete(frame.n, frame.id);
+      } catch {
+      }
       return;
     }
     relaying = true;
     try {
-      void store.apply({ id: frame.id, update: frame.u, origin: frame.o });
+      void crdtStore.apply({ n: frame.n, id: frame.id, update: frame.u, origin: frame.o }, def.crdt, () => {
+      });
     } catch {
     } finally {
       relaying = false;
     }
   }
+  const collConnState = (conn) => {
+    let s = connColl.get(conn);
+    if (!s) connColl.set(conn, s = { subs: /* @__PURE__ */ new Map(), policy: /* @__PURE__ */ new Map() });
+    return s;
+  };
+  function collUnsubAll(conn) {
+    connColl.delete(conn);
+    for (const set of collSubscribers.values()) set.delete(conn);
+  }
+  async function handleCollectionSub(conn, frame) {
+    if (!collectionStore || !collectionDefs[frame.n]) {
+      conn.send({ t: "err", i: frame.i, code: "NOT_FOUND", m: `Unknown collection: ${frame.n}` });
+      return;
+    }
+    await dispatchOp(conn, frame.i, { kind: "subscribe", name: `collection:${frame.n}`, conn }, async () => {
+      const principal = conn.principal ?? conn.id;
+      const policy = collectionPolicies[frame.n];
+      if (!policy?.read) throw new import_core.SuperLineError("FORBIDDEN", `Read denied: ${frame.n}`);
+      const policyFilter = await policy.read(principal, conn.ctx);
+      const eff = (0, import_core.andFilters)(policyFilter, frame.q.filter);
+      const rows = await collectionStore.snapshot(frame.n, { ...frame.q, filter: eff });
+      const state = collConnState(conn);
+      let subs = state.subs.get(frame.n);
+      if (!subs) state.subs.set(frame.n, subs = /* @__PURE__ */ new Map());
+      subs.set(frame.s, frame.q);
+      state.policy.set(frame.n, policyFilter);
+      let set = collSubscribers.get(frame.n);
+      if (!set) collSubscribers.set(frame.n, set = /* @__PURE__ */ new Set());
+      set.add(conn);
+      conn.send({ t: "res", i: frame.i, d: rows });
+    });
+  }
+  function handleCollectionUnsub(conn, frame) {
+    const state = connColl.get(conn);
+    const subs = state?.subs.get(frame.n);
+    if (!state || !subs) return;
+    subs.delete(frame.s);
+    if (subs.size === 0) {
+      state.subs.delete(frame.n);
+      state.policy.delete(frame.n);
+      collSubscribers.get(frame.n)?.delete(conn);
+    }
+  }
+  async function resolveCollectionOps(ops, principal, ctx) {
+    const store = collectionStore;
+    if (!store) throw new import_core.SuperLineError("NOT_FOUND", "No collection backend configured");
+    const out = [];
+    for (const op of ops) {
+      const def = collectionDefs[op.n];
+      if (!def) throw new import_core.SuperLineError("NOT_FOUND", `Unknown collection: ${op.n}`);
+      if ((0, import_core.isCrdtCollection)(def)) throw new import_core.SuperLineError("NOT_FOUND", `Collection ${op.n} is a CRDT document collection \u2014 use collection(n).open(id), not a row batch`);
+      const policy = collectionPolicies[op.n];
+      if (!policy?.write) throw new import_core.SuperLineError("FORBIDDEN", `Write denied: ${op.n}`);
+      const prev = await store.read(op.n, op.id);
+      if (op.op === "delete") {
+        if (!await policy.write(principal, "delete", void 0, prev, ctx))
+          throw new import_core.SuperLineError("FORBIDDEN", `Write denied: ${op.n}/${op.id}`);
+        out.push({ op: "delete", n: op.n, id: op.id });
+        continue;
+      }
+      const row = await (0, import_core.validate)(def.schema, op.d);
+      const key = row[def.key];
+      if (typeof key !== "string")
+        throw new import_core.SuperLineError("VALIDATION", `Collection ${op.n} row is missing string key '${def.key}'`);
+      if (key !== op.id) throw new import_core.SuperLineError("VALIDATION", `Row key '${key}' does not match op id '${op.id}'`);
+      if (checkReferences && def.references) {
+        for (const [field, refCollection] of Object.entries(def.references)) {
+          const ref = row[field];
+          if (ref === void 0 || ref === null) continue;
+          if (await store.read(refCollection, String(ref)) === void 0)
+            throw new import_core.SuperLineError("VALIDATION", `Dangling reference: ${op.n}.${field} \u2192 ${refCollection}/${String(ref)} does not exist`);
+        }
+      }
+      const kind = op.op;
+      if (!await policy.write(principal, kind, row, prev, ctx))
+        throw new import_core.SuperLineError("FORBIDDEN", `Write denied: ${op.n}/${op.id}`);
+      out.push({ op: kind, n: op.n, id: op.id, row });
+    }
+    return out;
+  }
+  async function commitCollectionBatch(ops, origin, relay) {
+    if (ops.length === 0 || !collectionStore) return;
+    await collectionStore.apply(ops, origin);
+    if (relay && collIsRelay)
+      void adapter.publish(COLL_CHANNEL, serializer.encode({ ops, origin, nd: instanceId }));
+  }
+  async function handleCollectionBatch(conn, frame) {
+    if (!collectionStore) {
+      conn.send({ t: "err", i: frame.i, code: "NOT_FOUND", m: "No collection backend configured" });
+      return;
+    }
+    await dispatchOp(conn, frame.i, { kind: "request", name: "collection:batch", conn }, async () => {
+      const principal = conn.principal ?? conn.id;
+      const resolved = await resolveCollectionOps(frame.ops, principal, conn.ctx);
+      await commitCollectionBatch(resolved, principal, true);
+      conn.send({ t: "res", i: frame.i, d: null });
+    });
+  }
+  function routeRowChange(change) {
+    const conns2 = collSubscribers.get(change.n);
+    if (!conns2 || conns2.size === 0) return;
+    for (const conn of conns2) {
+      const state = connColl.get(conn);
+      const subs = state?.subs.get(change.n);
+      if (!state || !subs || subs.size === 0) continue;
+      const eff = (0, import_core.andFilters)(state.policy.get(change.n), (0, import_core.orFilters)([...subs.values()].map((q) => q.filter)));
+      const prevlessDelete = change.k === "delete" && change.prev === void 0;
+      const inPrev = prevlessDelete || change.prev !== void 0 && (0, import_core.matchesFilter)(eff, change.prev);
+      const inNext = change.next !== void 0 && (0, import_core.matchesFilter)(eff, change.next);
+      if (!inPrev && !inNext) continue;
+      conn.send({ t: "cchg", n: change.n, k: change.k, id: change.id, d: change.next });
+    }
+  }
+  function handleCollectionRelay(payload) {
+    let env;
+    try {
+      env = serializer.decode(payload);
+    } catch {
+      return;
+    }
+    if (env.nd === instanceId) return;
+    if (!collectionStore || !collIsRelay) return;
+    try {
+      void collectionStore.apply(env.ops, env.origin);
+    } catch {
+    }
+  }
+  if (collectionStore) collectionStore.onChange(routeRowChange);
   function room(name) {
     const channel = ROOM + name;
     return {
@@ -947,78 +1091,6 @@ function createSuperLineServer(contract, opts) {
       void adapter.publish(CONN + id, serializer.encode(env));
     });
   }
-  const storeApi = {};
-  for (const [name, store] of Object.entries(storeMap)) {
-    const readOrThrow = async (id) => {
-      const r = await store.read(id);
-      if (!r) throw new import_core.SuperLineError("NOT_FOUND", `No resource: ${name}/${id}`);
-      return r;
-    };
-    storeApi[name] = {
-      async create(id, data, accessRules) {
-        await store.create(id, data, accessRules);
-        if (taps.length) emitTap({ type: "store.create", store: name, id });
-      },
-      read(id) {
-        return Promise.resolve(store.read(id));
-      },
-      async write(id, data, opts2) {
-        const origin = opts2?.origin ?? SERVER_ORIGIN;
-        await store.apply({ id, update: data, origin });
-        if (taps.length) emitTap({ type: "store.write", store: name, id, origin, data });
-      },
-      async grant(id, principal, perms) {
-        const r = await readOrThrow(id);
-        await store.setAccess(id, { ...r.accessRules, [principal]: perms });
-        if (taps.length) emitTap({ type: "store.grant", store: name, id, principal, perms });
-      },
-      async revoke(id, principal) {
-        const r = await readOrThrow(id);
-        const next = { ...r.accessRules };
-        delete next[principal];
-        await store.setAccess(id, next);
-        if (taps.length) emitTap({ type: "store.revoke", store: name, id, principal });
-      },
-      async delete(id) {
-        await store.delete(id);
-        if (store.clustering !== "self")
-          void adapter.publish(
-            STORE + name + ":" + id,
-            serializer.encode({ t: "sdel", n: name, id, nd: instanceId })
-          );
-        if (taps.length) emitTap({ type: "store.delete", store: name, id });
-      },
-      list(opts2) {
-        return Promise.resolve(store.list(opts2));
-      },
-      searchPrincipals(opts2) {
-        return Promise.resolve(store.searchPrincipals(opts2));
-      },
-      open(id, openOpts) {
-        if (!store.open)
-          throw new import_core.SuperLineError("UNSUPPORTED", `Store ${name} does not support reactive open()`);
-        const replica = store.open(id, openOpts);
-        if (!taps.length) return replica;
-        const origin = openOpts?.origin ?? SERVER_ORIGIN;
-        const emit = (data) => emitTap({ type: "store.write", store: name, id, origin, data });
-        return {
-          ...replica,
-          set: (d) => {
-            replica.set(d);
-            emit(d);
-          },
-          update: (p) => {
-            replica.update(p);
-            emit(p);
-          },
-          delete: (path) => {
-            replica.delete(path);
-            emit({ delete: path });
-          }
-        };
-      }
-    };
-  }
   const pluginDisposers = [];
   const pluginHandlers = {};
   const api = {
@@ -1119,9 +1191,67 @@ function createSuperLineServer(contract, opts) {
         }
       };
     },
-    store(name) {
-      const handle = storeApi[name];
-      if (!handle) throw new import_core.SuperLineError("NOT_FOUND", `Store not configured: ${name}`);
+    collection(name) {
+      const def = collectionDefs[name];
+      if (!def) throw new import_core.SuperLineError("NOT_FOUND", `Collection not declared: ${name}`);
+      if ((0, import_core.isCrdtCollection)(def)) {
+        if (!crdtStore) throw new import_core.SuperLineError("NOT_FOUND", "No CRDT collection backend configured");
+        const cstore = crdtStore;
+        const handle2 = {
+          async create(id, data) {
+            const v = await (0, import_core.validate)(def.schema, data);
+            await cstore.create(name, id, v, def.crdt);
+          },
+          open(id, o) {
+            return cstore.open(name, id, { ...o, doc: def.crdt });
+          },
+          async read(id) {
+            const state = await cstore.read(name, id);
+            if (state === void 0) return void 0;
+            const r = cstore.open(name, id, { doc: def.crdt });
+            const s = r.getSnapshot();
+            r.close();
+            return s;
+          },
+          async delete(id) {
+            await cstore.delete(name, id);
+            if (cstore.clustering !== "self")
+              void adapter.publish(CDOC + name + ":" + id, serializer.encode({ t: "cddel", n: name, id, nd: instanceId }));
+          },
+          list(o) {
+            return Promise.resolve(cstore.list(name, o));
+          }
+        };
+        return handle2;
+      }
+      if (!collectionStore) throw new import_core.SuperLineError("NOT_FOUND", "No collection backend configured");
+      const store = collectionStore;
+      const resolve = async (row) => {
+        const v = await (0, import_core.validate)(def.schema, row);
+        const key = v[def.key];
+        if (typeof key !== "string")
+          throw new import_core.SuperLineError("VALIDATION", `Collection ${name} row is missing string key '${def.key}'`);
+        return { id: key, row: v };
+      };
+      const handle = {
+        async insert(row) {
+          const { id, row: v } = await resolve(row);
+          await commitCollectionBatch([{ op: "insert", n: name, id, row: v }], SERVER_ORIGIN, true);
+        },
+        async update(row) {
+          const { id, row: v } = await resolve(row);
+          await commitCollectionBatch([{ op: "update", n: name, id, row: v }], SERVER_ORIGIN, true);
+        },
+        async delete(id) {
+          await commitCollectionBatch([{ op: "delete", n: name, id }], SERVER_ORIGIN, true);
+        },
+        read(id) {
+          return Promise.resolve(store.read(name, id));
+        },
+        snapshot(query) {
+          return Promise.resolve(store.snapshot(name, query ?? {}));
+        }
+      };
       return handle;
     },
     async close() {
@@ -1180,8 +1310,14 @@ function createSuperLineServer(contract, opts) {
           }
         };
       },
-      store: (name) => api.store(name),
-      storeInfos: () => Object.entries(storeMap).map(([name, store]) => ({ name, model: store.model })),
+      collection: (name) => api.collection(name),
+      collectionInfos: () => (
+        // CRDT document collections surface with a synthetic `id` key + no references — the inspector's
+        // queryCollection synthesizes doc-rows for them (they're open-by-id, not row-queryable).
+        Object.entries(collectionDefs).map(
+          ([name, def]) => (0, import_core.isCrdtCollection)(def) ? { name, key: "id", references: {} } : { name, key: def.key, references: def.references ?? {} }
+        )
+      ),
       describe: (conn) => buildDescriptor(conn),
       connectionById: (id) => Promise.resolve(presenceOrThrow().get(id)),
       channel: (name) => pluginChannel(pluginName, name)