@xnetjs/data 1.0.0 → 2.0.0

package/dist/auth/index.d.ts

@@ -1,12 +1,12 @@
 import { AllowExpr, DenyExpr, AuthExpression, AndExpr, OrExpr, NotExpr, PublicExpr, AuthenticatedExpr, CreatorRoleResolver, PropertyRoleResolver, RelationRoleResolver, MembershipRoleResolver, AuthorizationDefinition, SerializedAuthorization, SerializedAuthExpression, DID } from '@xnetjs/core';
 export { AUTH_ACTIONS, AllowExpr, AndExpr, AuthAction, AuthCheckInput, AuthDecision, AuthDenyReason, AuthExpression, AuthTrace, AuthTraceStep, AuthenticatedExpr, AuthorizationDefinition, CreatorRoleResolver, DenyExpr, MembershipRoleResolver, NotExpr, OrExpr, PolicyEvaluator, PropertyRoleResolver, PublicExpr, RelationRoleResolver, RoleRefExpr, RoleResolver, SerializedAuthExpression, SerializedAuthorization, SerializedRoleResolver } from '@xnetjs/core';
-import { E as PropertyDefinition, a as Schema, h as NodeState, S as SchemaIRI } from '../types-B5rrBwRI.js';
-export { aX as DEFAULT_OFFLINE_POLICY, aV as GRANT_SCHEMA_IRI, b1 as Grant, w as GrantIndex, b6 as GrantIndexOptions, b5 as GrantIndexStore, b0 as GrantInput, b4 as GrantNode, aU as GrantRateLimiter, b9 as GrantRateLimiterOptions, O as OfflineAuthPolicy, b8 as RevocationConfig, b7 as RevocationConsistency, aT as StoreAuth, e as StoreAuthAPI, b2 as StoreAuthError, b3 as StoreAuthErrorCode, a$ as StoreAuthKeyManager, aZ as StoreAuthOptions, a_ as StoreAuthStore, aW as isGrantActive, aY as mergeOfflinePolicy } from '../types-B5rrBwRI.js';
-export { A as ActionPermission, m as AuthDecisionEvent, b as DecisionCache, g as DecisionCacheOptions, D as DefaultPolicyEvaluator, j as DefaultPolicyEvaluatorOptions, a as DefaultRoleResolver, i as DefaultRoleResolverOptions, k as DefinedSchemaLike, G as GrantExpirationCleaner, o as GrantExpirationCleanerOptions, n as GrantExpirationStore, H as HubPolicy, N as NodeStoreReader, P as PermissionMatrix, l as RevalidationEvent, R as RoleSummary, S as SchemaRegistryReader, c as buildPermissionMatrix, f as createPolicyEvaluator, d as describeRoleResolver, e as evaluateExpression, h as hubActionsForSpaceRole, s as schemaToHubPolicy } from '../grant-expiration-cleaner-BrMW0ffX.js';
+import { F as PropertyDefinition, a as Schema, h as NodeState, S as SchemaIRI } from '../types-C64g-IXg.js';
+export { a_ as DEFAULT_OFFLINE_POLICY, aY as GRANT_SCHEMA_IRI, b4 as Grant, x as GrantIndex, b9 as GrantIndexOptions, b8 as GrantIndexStore, b3 as GrantInput, b7 as GrantNode, aX as GrantRateLimiter, bc as GrantRateLimiterOptions, O as OfflineAuthPolicy, bb as RevocationConfig, ba as RevocationConsistency, aW as StoreAuth, e as StoreAuthAPI, b5 as StoreAuthError, b6 as StoreAuthErrorCode, b2 as StoreAuthKeyManager, b0 as StoreAuthOptions, b1 as StoreAuthStore, aZ as isGrantActive, a$ as mergeOfflinePolicy } from '../types-C64g-IXg.js';
+export { A as ActionPermission, m as AuthDecisionEvent, b as DecisionCache, g as DecisionCacheOptions, D as DefaultPolicyEvaluator, j as DefaultPolicyEvaluatorOptions, a as DefaultRoleResolver, i as DefaultRoleResolverOptions, k as DefinedSchemaLike, G as GrantExpirationCleaner, o as GrantExpirationCleanerOptions, n as GrantExpirationStore, H as HubPolicy, N as NodeStoreReader, P as PermissionMatrix, l as RevalidationEvent, R as RoleSummary, S as SchemaRegistryReader, c as buildPermissionMatrix, f as createPolicyEvaluator, d as describeRoleResolver, e as evaluateExpression, h as hubActionsForSpaceRole, s as schemaToHubPolicy } from '../grant-expiration-cleaner-1by9wRlb.js';
 import { PublicKeyResolver } from '@xnetjs/crypto';
 import '@xnetjs/sqlite';
 import '@xnetjs/sync';
-import '../registry-BGD80QCd.js';
+import '../registry-s1fYgCSj.js';
 
 /**
  * Authorization expression builders for schema definitions.

package/dist/checkpoint-MZHJ7PCZ.js

@@ -0,0 +1,12 @@
+import {
+  CHECKPOINT_SCHEMA_IRI,
+  CheckpointSchema
+} from "./chunk-6ZUJID52.js";
+import "./chunk-JA56EQJO.js";
+import "./chunk-LK5ZIAIE.js";
+import "./chunk-RRXJNZX5.js";
+import "./chunk-D4LUUZYD.js";
+export {
+  CHECKPOINT_SCHEMA_IRI,
+  CheckpointSchema
+};

package/dist/{chunk-CARPMPXV.js → chunk-4S73XDWH.js}

@@ -1,14 +1,14 @@
-import {
-  SYSTEM_SCHEMA_BASE_IRIS,
-  isSystemNamespaceResource,
-  isSystemSchemaIri
-} from "./chunk-XJBDESCX.js";
 import {
   applyNodeQueryDescriptor,
   getNodeQuerySearchTokens,
   withoutNodeQueryMaterializedView,
   withoutNodeQueryPagination
 } from "./chunk-S5RP5RKY.js";
+import {
+  SYSTEM_SCHEMA_BASE_IRIS,
+  isSystemNamespaceResource,
+  isSystemSchemaIri
+} from "./chunk-XJBDESCX.js";
 import {
   createNodeId,
   getBaseSchemaIRI
@@ -1393,6 +1393,14 @@ var NodeStore = class {
   listeners = /* @__PURE__ */ new Set();
   nodeListeners = /* @__PURE__ */ new Map();
   batchListeners = /* @__PURE__ */ new Set();
+  // Draft overlay (exploration 0329)
+  checkedOutDraft = null;
+  cloneToOriginal = /* @__PURE__ */ new Map();
+  draftMemberSet = /* @__PURE__ */ new Set();
+  draftDynamicMembers = false;
+  /** null = conservative "all schemas" (memberSchemaIds omitted). */
+  draftMemberSchemaSet = null;
+  draftOverlayListeners = /* @__PURE__ */ new Set();
   schemaLookup;
   propertyLookup;
   lensRegistry;
@@ -1472,6 +1480,7 @@ var NodeStore = class {
         });
         this.emit(change2, node2, null, false);
         this.authEvaluator?.invalidate(node2.id);
+        this.notifyDraftNodeCreated(node2.id, node2.schemaId);
         if (this.telemetry) {
           this.telemetry.reportPerformance("data.create", Date.now() - start);
           this.telemetry.reportUsage("data.create", 1);
@@ -1507,6 +1516,7 @@ var NodeStore = class {
       await this.persistEncryptedNodeSnapshot(node);
       this.emit(change, node, null, false);
       this.authEvaluator?.invalidate(node.id);
+      this.notifyDraftNodeCreated(node.id, node.schemaId);
       if (this.telemetry) {
         this.telemetry.reportPerformance("data.create", Date.now() - start);
         this.telemetry.reportUsage("data.create", 1);
@@ -1523,10 +1533,186 @@ var NodeStore = class {
    * Get a Node by ID.
    */
   async get(id) {
+    const cloneId = this.checkedOutDraft?.clones[id];
+    if (cloneId) {
+      const clone = await this.getRaw(cloneId);
+      if (clone) return { ...clone, id };
+    }
+    return this.getRaw(id);
+  }
+  /**
+   * Read a node WITHOUT the draft overlay (exploration 0329) — merge review
+   * and diff surfaces use this to see main's true state while checked out.
+   */
+  async getRaw(id) {
     const node = await this.storage.getNode(id);
     const decrypted = await this.decryptNodeSnapshotIfPresent(node);
     return await this.canReadNode(decrypted) ? decrypted : null;
   }
+  // ==========================================================================
+  // Draft overlay (exploration 0329)
+  // ==========================================================================
+  /**
+   * Check a draft out (or pass null to return to main). While checked out,
+   * member reads swap to clone content under original ids, member writes
+   * redirect to clones (lazily forking via `onMissingMember`), and clone
+   * change events mirror to original-id subscribers.
+   */
+  setCheckedOutDraft(overlay) {
+    this.checkedOutDraft = overlay;
+    this.cloneToOriginal = new Map(
+      overlay ? Object.entries(overlay.clones).map(([orig, clone]) => [clone, orig]) : []
+    );
+    this.draftMemberSet = overlay && overlay.members !== "dynamic" ? new Set(overlay.members) : /* @__PURE__ */ new Set();
+    this.draftDynamicMembers = overlay?.members === "dynamic";
+    this.draftMemberSchemaSet = overlay?.memberSchemaIds ? new Set(overlay.memberSchemaIds) : null;
+    this.notifyDraftOverlayListeners();
+  }
+  /** Report a locally-created node to the checkout's draft-born hook (0329 P4). */
+  notifyDraftNodeCreated(nodeId, schemaId) {
+    const overlay = this.checkedOutDraft;
+    if (!overlay?.onNodeCreated) return;
+    if (nodeId === overlay.draftId || this.cloneToOriginal.has(nodeId)) return;
+    try {
+      overlay.onNodeCreated(nodeId, schemaId);
+    } catch (err) {
+      console.error("Error in draft onNodeCreated hook:", err);
+    }
+  }
+  notifyDraftOverlayListeners() {
+    for (const listener of this.draftOverlayListeners) {
+      try {
+        listener();
+      } catch (err) {
+        console.error("Error in draft overlay listener:", err);
+      }
+    }
+  }
+  getCheckedOutDraft() {
+    return this.checkedOutDraft;
+  }
+  /**
+   * Device-local draft privacy (exploration 0329): ids marked here (draft
+   * bookkeeping nodes, clones, draft-born nodes) are excluded from outbound
+   * sync publication by the personal node-sync room's `shouldPublish`
+   * predicate. In-memory only — the draft module rehydrates it from open
+   * Draft nodes at boot, BEFORE sync starts.
+   */
+  draftPrivateNodeIds = /* @__PURE__ */ new Set();
+  markDraftPrivate(ids) {
+    for (const id of ids) this.draftPrivateNodeIds.add(id);
+  }
+  unmarkDraftPrivate(ids) {
+    for (const id of ids) this.draftPrivateNodeIds.delete(id);
+  }
+  isDraftPrivate(id) {
+    return this.draftPrivateNodeIds.has(id);
+  }
+  /** Notified on every checkout change (including clone-map refreshes). */
+  subscribeToDraftOverlay(listener) {
+    this.draftOverlayListeners.add(listener);
+    return () => this.draftOverlayListeners.delete(listener);
+  }
+  /**
+   * Swap checked-out members' content to their clones (original ids kept, so
+   * MV id lists and grid ordering are untouched). No-op without a checkout.
+   */
+  async overlayStates(states) {
+    const overlay = this.checkedOutDraft;
+    if (!overlay) return states;
+    const visible = this.cloneToOriginal.size > 0 ? states.filter((state) => !this.cloneToOriginal.has(state.id)) : states;
+    const cloneIds = visible.map((s) => overlay.clones[s.id]).filter((cloneId) => cloneId !== void 0);
+    if (cloneIds.length === 0) return visible;
+    const cloneMap = await this.getNodesById(cloneIds, this.storage);
+    return Promise.all(
+      visible.map(async (state) => {
+        const cloneId = overlay.clones[state.id];
+        const clone = cloneId ? cloneMap.get(cloneId) : void 0;
+        if (!clone) return state;
+        const decrypted = await this.decryptNodeSnapshotIfPresent(clone);
+        return decrypted ? { ...decrypted, id: state.id } : state;
+      })
+    );
+  }
+  /**
+   * Draft-aware query path (0329 P5): candidates from storage WITHOUT
+   * pagination, unioned with checked-out members the predicate may have
+   * missed (their clone values can change membership), content-swapped,
+   * clone rows hidden, then the full descriptor re-applied in JS so
+   * filter/sort/pagination reflect draft values.
+   */
+  async draftAwareQuery(descriptor, start) {
+    const overlay = this.checkedOutDraft;
+    const unpaginated = withoutNodeQueryMaterializedView(withoutNodeQueryPagination(descriptor));
+    let candidates;
+    if (this.storage.queryNodes && !this.nodeContentCipher) {
+      candidates = (await this.storage.queryNodes(unpaginated)).nodes;
+    } else {
+      const fallback = await this.loadQueryFallbackCandidates(unpaginated);
+      const decrypted = await Promise.all(
+        fallback.nodes.map((node) => this.decryptNodeSnapshotIfPresent(node))
+      );
+      candidates = decrypted.filter((node) => node !== null);
+    }
+    if (overlay) {
+      const present = new Set(candidates.map((node) => node.id));
+      const missing = Object.keys(overlay.clones).filter(
+        (id) => !present.has(id)
+      );
+      if (missing.length > 0) {
+        const extra = await this.getNodesById(missing, this.storage);
+        for (const node of extra.values()) {
+          const decrypted = await this.decryptNodeSnapshotIfPresent(node);
+          if (!decrypted) continue;
+          if (decrypted.schemaId !== descriptor.schemaId) continue;
+          if (decrypted.deleted && !descriptor.includeDeleted) continue;
+          candidates.push(decrypted);
+        }
+      }
+    }
+    const readable = await this.filterReadableNodes(candidates);
+    const swapped = await this.overlayStates(readable);
+    const filtered = applyNodeQueryDescriptor(swapped, withoutNodeQueryPagination(descriptor));
+    const result = applyNodeQueryDescriptor(swapped, descriptor);
+    return {
+      nodes: result,
+      totalCount: filtered.length,
+      plan: {
+        strategy: "draft-overlay",
+        candidateNodeCount: readable.length,
+        hydratedNodeCount: swapped.length,
+        returnedNodeCount: result.length,
+        durationMs: Date.now() - start
+      }
+    };
+  }
+  /**
+   * Resolve where a write to `id` lands under the checkout: an existing
+   * clone, a lazily-forked one (`onMissingMember`), or — for non-members,
+   * clone ids, and declined forks — the id itself.
+   */
+  async resolveDraftWriteTarget(id) {
+    const overlay = this.checkedOutDraft;
+    if (!overlay) return id;
+    const existing = overlay.clones[id];
+    if (existing) return existing;
+    if (this.draftDynamicMembers) {
+      if (id === overlay.draftId || this.cloneToOriginal.has(id)) return id;
+    } else if (!this.draftMemberSet.has(id)) {
+      return id;
+    }
+    if (overlay.onMissingMember) {
+      const cloneId = await overlay.onMissingMember(id);
+      if (cloneId && this.checkedOutDraft === overlay) {
+        this.checkedOutDraft = { ...overlay, clones: { ...overlay.clones, [id]: cloneId } };
+        this.cloneToOriginal.set(cloneId, id);
+        this.notifyDraftOverlayListeners();
+        return cloneId;
+      }
+      if (cloneId) return cloneId;
+    }
+    return id;
+  }
   /**
    * Return the subset of IDs that already exist in materialized storage.
    *
@@ -1606,6 +1792,7 @@ var NodeStore = class {
    */
   async update(id, options) {
     const start = this.telemetry ? Date.now() : 0;
+    id = await this.resolveDraftWriteTarget(id);
     try {
       if (this.canUseSingleWriteFastPath()) {
         const { node: node2, previousNode, change: change2 } = await this.applySingleNodeWrite({
@@ -1688,6 +1875,7 @@ var NodeStore = class {
    */
   async delete(id) {
     const start = this.telemetry ? Date.now() : 0;
+    id = await this.resolveDraftWriteTarget(id);
     try {
       if (this.canUseSingleWriteFastPath()) {
         const { node, previousNode, change: change2 } = await this.applySingleNodeWrite({
@@ -1753,6 +1941,7 @@ var NodeStore = class {
    * Restore a deleted Node.
    */
   async restore(id) {
+    id = await this.resolveDraftWriteTarget(id);
     if (this.canUseSingleWriteFastPath()) {
       const { node: node2, previousNode, change: change2 } = await this.applySingleNodeWrite({
         nodeId: id,
@@ -1821,7 +2010,8 @@ var NodeStore = class {
       const readable = await this.filterReadableNodes(
         decrypted.filter((node) => node !== null)
       );
-      const result = this.authEvaluator ? this.applyListPagination(readable, options) : readable;
+      const paged = this.authEvaluator ? this.applyListPagination(readable, options) : readable;
+      const result = await this.overlayStates(paged);
       if (this.telemetry) {
         this.telemetry.reportPerformance("data.list", Date.now() - start);
         this.telemetry.reportUsage("data.list", 1);
@@ -1840,10 +2030,13 @@ var NodeStore = class {
   async query(descriptor) {
     const start = Date.now();
     try {
+      if (this.checkedOutDraft && Object.keys(this.checkedOutDraft.clones).length > 0 && (this.draftMemberSchemaSet === null || this.draftMemberSchemaSet.has(descriptor.schemaId))) {
+        return this.draftAwareQuery(descriptor, start);
+      }
       if (this.storage.queryNodes && !this.nodeContentCipher && !this.authEvaluator) {
         const result2 = await this.storage.queryNodes(descriptor);
         return {
-          nodes: result2.nodes,
+          nodes: await this.overlayStates(result2.nodes),
           totalCount: result2.totalCount,
           plan: {
             ...result2.plan,
@@ -1855,7 +2048,7 @@ var NodeStore = class {
         const authFingerprint = await this.authFingerprint();
         const result2 = await this.storage.queryNodes({ ...descriptor, authFingerprint });
         return {
-          nodes: result2.nodes,
+          nodes: await this.overlayStates(result2.nodes),
           totalCount: result2.totalCount,
           plan: {
             ...result2.plan,
@@ -1866,7 +2059,7 @@ var NodeStore = class {
       if (this.storage.queryNodes && !this.nodeContentCipher && this.authEvaluator && !descriptor.nodeId && descriptor.materializedView === void 0) {
         const candidates = await this.storage.queryNodes(withoutNodeQueryPagination(descriptor));
         const readable2 = await this.filterReadableNodes(candidates.nodes);
-        const result2 = applyNodeQueryDescriptor(readable2, descriptor);
+        const result2 = await this.overlayStates(applyNodeQueryDescriptor(readable2, descriptor));
         return {
           nodes: result2,
           totalCount: readable2.length,
@@ -1890,7 +2083,9 @@ var NodeStore = class {
       const readable = await this.filterReadableNodes(
         decrypted.filter((node) => node !== null)
       );
-      const result = applyNodeQueryDescriptor(readable, fallback.postFilterDescriptor);
+      const result = await this.overlayStates(
+        applyNodeQueryDescriptor(readable, fallback.postFilterDescriptor)
+      );
       const totalCount = fallback.totalCount ?? (fallback.paginatedInStorage ? void 0 : applyNodeQueryDescriptor(
         readable,
         withoutNodeQueryPagination(fallback.postFilterDescriptor)
@@ -2685,6 +2880,24 @@ var NodeStore = class {
         }
       }
     }
+    const originalId = this.cloneToOriginal.get(change.payload.nodeId);
+    if (originalId) {
+      const originalListeners = this.nodeListeners.get(originalId);
+      if (originalListeners) {
+        const mirrored = {
+          ...event,
+          node: event.node ? { ...event.node, id: originalId } : event.node,
+          previousNode: event.previousNode ? { ...event.previousNode, id: originalId } : event.previousNode
+        };
+        for (const listener of originalListeners) {
+          try {
+            listener(mirrored);
+          } catch (err) {
+            console.error("Error in NodeStore draft-mirror listener:", err);
+          }
+        }
+      }
+    }
   }
   // ==========================================================================
   // Internal Methods
@@ -3415,6 +3628,41 @@ var MemoryNodeStorageAdapter = class {
     this.yjsSnapshotStore = this.yjsSnapshotStore.filter((s) => s.nodeId !== nodeId);
   }
   // ==========================================================================
+  // Pin Registry (exploration 0329)
+  // ==========================================================================
+  /** key -> ownerId -> entry */
+  pinStore = /* @__PURE__ */ new Map();
+  pins = {
+    addPins: async (pins) => {
+      for (const pin of pins) {
+        let owners = this.pinStore.get(pin.key);
+        if (!owners) {
+          owners = /* @__PURE__ */ new Map();
+          this.pinStore.set(pin.key, owners);
+        }
+        owners.set(pin.ownerId, { ...pin });
+      }
+    },
+    removePinsByOwner: async (ownerId) => {
+      for (const [key, owners] of this.pinStore) {
+        owners.delete(ownerId);
+        if (owners.size === 0) this.pinStore.delete(key);
+      }
+    },
+    getPinnedKeysAmong: async (keys) => {
+      const pinned = /* @__PURE__ */ new Set();
+      for (const key of keys) {
+        if (this.pinStore.has(key)) pinned.add(key);
+      }
+      return pinned;
+    },
+    countPins: async () => {
+      let count2 = 0;
+      for (const owners of this.pinStore.values()) count2 += owners.size;
+      return count2;
+    }
+  };
+  // ==========================================================================
   // Utility Methods (for testing)
   // ==========================================================================
   /**
@@ -3426,6 +3674,7 @@ var MemoryNodeStorageAdapter = class {
     this.nodes.clear();
     this.documentContentStore.clear();
     this.yjsSnapshotStore = [];
+    this.pinStore.clear();
     this.lastLamportTime = 0;
     this.syncCursors.clear();
   }
@@ -3465,6 +3714,9 @@ var MemoryNodeStorageAdapter = class {
         ])
       ),
       yjsSnapshotStore: structuredClone(this.yjsSnapshotStore),
+      pinStore: new Map(
+        Array.from(this.pinStore.entries(), ([key, owners]) => [key, new Map(owners)])
+      ),
       lastLamportTime: this.lastLamportTime
     };
   }
@@ -3474,6 +3726,7 @@ var MemoryNodeStorageAdapter = class {
     this.nodes = snapshot.nodes;
     this.documentContentStore = snapshot.documentContentStore;
     this.yjsSnapshotStore = snapshot.yjsSnapshotStore;
+    this.pinStore = snapshot.pinStore;
     this.lastLamportTime = snapshot.lastLamportTime;
   }
 };
@@ -4653,7 +4906,7 @@ var SQLiteNodeStorageAdapter = class {
   nodeReadAuthorizer;
   /** One-time guard: ensure the `auth_fingerprint` column exists on upgraded DBs. */
   materializationColumnsReady = false;
-  nodePropertyColumnsReady = false;
+  nodePropertyColumnsReady = null;
   /**
    * Descriptor→SQL compilation lives in `query-compiler.ts` (exploration
    * 0276). Flags are read per-compile so the compiler never captures stale
@@ -4948,12 +5201,14 @@ var SQLiteNodeStorageAdapter = class {
   }
   // ─── Materialized State Operations ────────────────────────────────────────
   async getNode(id) {
+    await this.ensureNodePropertyColumns();
     const nodes = await hydrateNodesByIds(this.db, [id], this.aggregatedHydration);
     return nodes[0] ?? null;
   }
   async getNodes(ids) {
     const uniqueIds = Array.from(new Set(ids));
     if (uniqueIds.length === 0) return [];
+    await this.ensureNodePropertyColumns();
     return hydrateNodesByIds(this.db, uniqueIds, this.aggregatedHydration);
   }
   async getExistingNodeIds(ids) {
@@ -5075,6 +5330,7 @@ var SQLiteNodeStorageAdapter = class {
    * Fetches nodes and properties in one query for better performance with large datasets.
    */
   async listNodesOptimized(options) {
+    await this.ensureNodePropertyColumns();
     let whereClause = "1=1";
     const params = [];
     if (options?.schemaId) {
@@ -5136,6 +5392,7 @@ var SQLiteNodeStorageAdapter = class {
   }
   async queryNodes(descriptor) {
     const start = Date.now();
+    await this.ensureNodePropertyColumns();
     if (descriptor.materializedView) {
       return this.queryMaterializedView(descriptor, start);
     }
@@ -5326,6 +5583,47 @@ var SQLiteNodeStorageAdapter = class {
       [nodeId, content, Date.now()]
     );
   }
+  // ─── Pin Registry (exploration 0329) ──────────────────────────────────────
+  pins = {
+    addPins: async (pins) => {
+      if (pins.length === 0) return;
+      await this.enqueueWrite(async () => {
+        const now = Date.now();
+        for (const chunk of chunkItems(pins, 200)) {
+          const placeholders = chunk.map(() => "(?, ?, ?, ?)").join(", ");
+          const params = [];
+          for (const pin of chunk) params.push(pin.key, pin.ownerId, pin.reason, now);
+          await this.db.run(
+            `INSERT INTO pinned_changes (pin_key, owner_id, reason, created_at)
+             VALUES ${placeholders}
+             ON CONFLICT(pin_key, owner_id) DO NOTHING`,
+            params
+          );
+        }
+      });
+    },
+    removePinsByOwner: async (ownerId) => {
+      await this.enqueueWrite(async () => {
+        await this.db.run(`DELETE FROM pinned_changes WHERE owner_id = ?`, [ownerId]);
+      });
+    },
+    getPinnedKeysAmong: async (keys) => {
+      const pinned = /* @__PURE__ */ new Set();
+      for (const chunk of chunkItems(keys, 500)) {
+        const placeholders = chunk.map(() => "?").join(", ");
+        const rows = await this.db.query(
+          `SELECT DISTINCT pin_key FROM pinned_changes WHERE pin_key IN (${placeholders})`,
+          [...chunk]
+        );
+        for (const row of rows) pinned.add(row.pin_key);
+      }
+      return pinned;
+    },
+    countPins: async () => {
+      const row = await this.db.queryOne(`SELECT COUNT(*) AS n FROM pinned_changes`);
+      return row?.n ?? 0;
+    }
+  };
   // ─── Yjs Snapshots (Extended) ─────────────────────────────────────────────
   /**
    * Save a Yjs snapshot for time travel.
@@ -5953,15 +6251,16 @@ var SQLiteNodeStorageAdapter = class {
    * just falls back to the author-DID tiebreak.
    */
   async ensureNodePropertyColumns() {
-    if (this.nodePropertyColumnsReady) return;
-    try {
-      const columns = await this.db.query(`PRAGMA table_info(node_properties)`);
-      if (!columns.some((column) => column.name === "tiebreak_key")) {
-        await this.db.run("ALTER TABLE node_properties ADD COLUMN tiebreak_key TEXT");
+    this.nodePropertyColumnsReady ??= (async () => {
+      try {
+        const columns = await this.db.query(`PRAGMA table_info(node_properties)`);
+        if (!columns.some((column) => column.name === "tiebreak_key")) {
+          await this.db.run("ALTER TABLE node_properties ADD COLUMN tiebreak_key TEXT");
+        }
+      } catch {
       }
-    } catch {
-    }
-    this.nodePropertyColumnsReady = true;
+    })();
+    return this.nodePropertyColumnsReady;
   }
   setNodeReadAuthorizer(authorizer) {
     this.nodeReadAuthorizer = authorizer;

package/dist/chunk-6ZUJID52.js

@@ -0,0 +1,41 @@
+import {
+  spaceContributorAuthorization
+} from "./chunk-JA56EQJO.js";
+import {
+  created,
+  createdBy,
+  defineSchema,
+  json,
+  relation,
+  text
+} from "./chunk-RRXJNZX5.js";
+
+// src/schema/schemas/checkpoint.ts
+var CHECKPOINT_SCHEMA_IRI = "xnet://xnet.fyi/Checkpoint@1.0.0";
+var CheckpointSchema = defineSchema({
+  name: "Checkpoint",
+  namespace: "xnet://xnet.fyi/",
+  properties: {
+    /** User-given version name ("Draft sent to review", "Before the rewrite") */
+    name: text({ required: true, maxLength: 200 }),
+    /** Optional longer note shown in the Time Machine */
+    note: text({ maxLength: 2e3 }),
+    /** Per-node frontier: nodeId -> { hash, yjsSnapshotRef? } */
+    frontier: json({}),
+    /** The scope this checkpoint was taken over (page, database, space, …) */
+    scope: relation({}),
+    /** Space containment (single-valued) — drives the authorization roles */
+    space: relation({ target: "xnet://xnet.fyi/Space@1.0.0" }),
+    createdAt: created(),
+    createdBy: createdBy()
+  },
+  document: void 0,
+  // Checkpoints of shared content are visible to the space that content
+  // lives in; contributors can create their own.
+  authorization: spaceContributorAuthorization()
+});
+
+export {
+  CHECKPOINT_SCHEMA_IRI,
+  CheckpointSchema
+};

package/dist/{chunk-ENA6NEFY.js → chunk-DESSPQBS.js}

@@ -1,3 +1,6 @@
+import {
+  createNodeQueryDescriptor
+} from "./chunk-S5RP5RKY.js";
 import {
   extKey
 } from "./chunk-PMUQACPY.js";
@@ -26,9 +29,6 @@ import {
 import {
   DatabaseViewSchema
 } from "./chunk-TRPXLCND.js";
-import {
-  createNodeQueryDescriptor
-} from "./chunk-S5RP5RKY.js";
 
 // src/database/cell-types.ts
 var CELL_PREFIX = "cell_";
@@ -264,6 +264,30 @@ function getRichTextPlainText(doc, columnId) {
   const fragment = doc.getXmlFragment(`${RICHTEXT_PREFIX}${columnId}`);
   return extractPlainText(fragment);
 }
+var BLOCK_ELEMENT_NAMES = /* @__PURE__ */ new Set([
+  // HTML-ish / legacy names
+  "p",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "li",
+  "blockquote",
+  // TipTap / BlockNote shared names
+  "paragraph",
+  "heading",
+  "codeBlock",
+  "listItem",
+  "taskItem",
+  // BlockNote (v4) block-content names
+  "bulletListItem",
+  "numberedListItem",
+  "checkListItem",
+  "toggleListItem",
+  "quote"
+]);
 function extractPlainText(fragment) {
   const parts = [];
   for (let i = 0; i < fragment.length; i++) {
@@ -276,7 +300,33 @@ function extractPlainText(fragment) {
   }
   return parts.join("");
 }
+function inlineAtomText(element) {
+  const attr = (key) => {
+    const value = element.getAttribute(key);
+    return typeof value === "string" ? value : "";
+  };
+  switch (element.nodeName) {
+    case "mention": {
+      const label = attr("label") || attr("id");
+      return label ? `@${label}` : "";
+    }
+    case "hashtag": {
+      const name = attr("name");
+      return name ? `#${name}` : "";
+    }
+    case "wikilink":
+      return element.length === 0 ? attr("title") : null;
+    case "inlineMath":
+      return attr("latex");
+    default:
+      return null;
+  }
+}
 function extractPlainTextFromElement(element) {
+  const atomText = inlineAtomText(element);
+  if (atomText !== null) {
+    return atomText;
+  }
   const parts = [];
   for (let i = 0; i < element.length; i++) {
     const item = element.get(i);
@@ -286,8 +336,7 @@ function extractPlainTextFromElement(element) {
       parts.push(extractPlainTextFromElement(item));
     }
   }
-  const blockElements = ["p", "h1", "h2", "h3", "h4", "h5", "h6", "li", "blockquote"];
-  if (blockElements.includes(element.nodeName)) {
+  if (BLOCK_ELEMENT_NAMES.has(element.nodeName)) {
     parts.push("\n");
   }
   return parts.join("");