@ebbjs/storage 0.3.0 → 1.1.0

package/dist/memory/index.d.ts

@@ -122,9 +122,10 @@ interface MembershipLink {
  * handled by the DirtyTracker.
  *
  * ## Merge Semantics
- * - **put** — full entity replacement
- * - **patch** — field-level Last-Writer-Wins (LWW): higher HLC wins; tiebreak by lexicographic `update_id`
- * - **delete** — soft delete (sets `deleted_hlc`); patch-on-deleted is ignored
+ * - **merge** — Last-Writer-Wins (LWW) at the component's field: higher HLC wins; tiebreak by lexicographic `update_id`
+ * - **replace** — the component's field is set whole; the first write to an absent row creates it
+ * - **drop** — the component's field is removed; the row survives
+ * - **delete** — soft delete (sets `deleted_hlc`); the row keeps its type
  *
  * A field value is either a leaf merged by the LWW rule above, or a
  * `{ map }` of nested field values merged key by key under the same
@@ -136,6 +137,9 @@ interface MembershipLink {
  * - `get(id)` — returns entity by ID, materializes if dirty
  * - `set(entity)` — directly sets an entity (bypasses materialization)
  * - `query(type)` — returns all materialized entities of a type
+ * - `queryByComponent(component)` — returns the live ids carrying that
+ *   `<model>/<field>` component in ascending order, materializing dirty rows
+ *   of the component's model first
  * - `queryByRelationship({ as, type, targetId })` — returns the distinct
  *   source ids indexed under that triple in ascending order,
  *   materializing dirty relationship rows first
@@ -154,6 +158,18 @@ interface EntityStore {
     get(id: string): Promise<Entity | null>;
     set(entity: Entity): Promise<void>;
     query(type: string): Promise<readonly Entity[]>;
+    /**
+     * Live rows currently carrying `component` (`<model>/<field>`), ascending by
+     * id. Existence is the set of present fields on a row, so this is an index
+     * read rather than a row filter; a tombstoned row's components are not
+     * existence.
+     *
+     * The dirty rows materialized first are the component prefix's model. That is
+     * the current `<model>/<field>` addressing rule (#797); a component namespace
+     * that is not the row's model (#805's `ebb/*` components on ordinary rows)
+     * has to decode the model differently and revisit this step.
+     */
+    queryByComponent(component: string): Promise<readonly string[]>;
     queryByRelationship(query: RelationshipIndexQuery): Promise<readonly string[]>;
     queryByRelationshipSource(query: RelationshipSourceQuery): Promise<readonly RelationshipLink[]>;
     queryByMembership(groupId: string): Promise<readonly string[]>;
@@ -229,44 +245,51 @@ interface CursorStore {
  * `conflicted` is a terminal-until-resolved hold: a catch-up pass
  * classified the Action as a loser, so it is structurally excluded from
  * `pending()` and never submitted. The application resolves it by
- * retrying (back to `pending`) or discarding (removed).
+ * sending the Action unchanged (back to `pending`) or clearing it
+ * (removed).
  */
 type OutboxStatus = "pending" | "acknowledged" | "error" | "conflicted";
 /**
  * One side of a contested slot: the buffered local write, or the value
  * the server holds once the catch-up window is applied. A leaf carries
- * its LWW triple; a whole-field map replacement has no single leaf, so
+ * its LWW triple; a whole-component map replacement has no single leaf, so
  * `update_id` / `hlc` are absent and `value` is the projected map. A
- * field an inbound `put` or `delete` reverted also has no triple, and
+ * component an inbound `merge` or `delete` reverted also has no triple, and
  * `value` is `undefined` because the server holds no value.
  */
 interface ConflictSide {
     /** Projected leaf or map value. `undefined` when the server holds nothing. */
     readonly value: unknown;
-    /** `update_id` of the FieldValue; absent for a map side or a reverted field. */
+    /** `update_id` of the FieldValue; absent for a map side or a reverted component. */
     readonly update_id?: string;
-    /** HLC carried by the FieldValue; absent for a map side or a reverted field. */
+    /** HLC carried by the FieldValue; absent for a map side or a reverted component. */
     readonly hlc?: string;
 }
 /**
- * One contested position on a losing Action: a field plus the map-key
- * path from the field root to the position. `path` is empty for a plain
- * leaf field, an entity-level touch that overlaps no position, or a
- * field an inbound `put` / `delete` reverted. Concurrent writes to
+ * One contested position on a losing Action: a component plus the map-key
+ * path from the component's value root to the position. `path` is empty for a
+ * plain leaf component, an entity-level touch that overlaps no position, or a
+ * component an inbound `merge` / `delete` reverted. Concurrent writes to
  * different keys are different slots and so are not conflicts.
  */
 interface ConflictSlot {
     /** The `subject_id` of the Update that carried the write. */
     readonly subjectId: string;
-    /** The field name on that subject. */
-    readonly field: string;
-    /** Ordered map keys from the field root to the position; empty at the root. */
+    /** The `<model>/<field>` component name on that subject. */
+    readonly component: string;
+    /** Ordered map keys from the component root to the position; empty at the root. */
     readonly path: readonly string[];
     /** The buffered local value at the position. */
     readonly local: ConflictSide;
     /** The value the server holds at the position after the missed window. */
     readonly remote: ConflictSide;
 }
+/** One missed Action that out-dated a buffered write and made it a conflict. */
+interface ConflictRemoteAction {
+    readonly actorId: string;
+    readonly actionId: string;
+    readonly gsn: number;
+}
 /**
  * The before/after entity rows for one losing subject. `before` is the
  * row as the client had it immediately before the catch-up window was
@@ -278,7 +301,8 @@ interface ConflictSlot {
  */
 interface ConflictSubjectState {
     readonly subjectId: string;
-    readonly subjectType: string;
+    /** The model the row is committed under. */
+    readonly model: string;
     readonly before: Entity | null;
     readonly after: Entity | null;
 }
@@ -305,6 +329,18 @@ interface OutboxConflict {
      * application reads that as "nothing of mine would be lost".
      */
     readonly slots: readonly ConflictSlot[];
+    /**
+     * The looser of the losing subjects' declared scopes: `"entity"` when
+     * any losing subject declared entity scope, else `"field"`. The union is
+     * spelled inline so storage stays independent of the schema package.
+     */
+    readonly scope: "field" | "component" | "entity";
+    /**
+     * The concurrent missed Actions that touched the losing subjects,
+     * deduped by action id, in window order. The remote half of the
+     * report an application builds a policy from.
+     */
+    readonly remoteActions: readonly ConflictRemoteAction[];
     /** The catch-up pass that produced this entry. */
     readonly catchUpId: string;
     /**
@@ -353,10 +389,9 @@ interface OutboxEntry {
 interface OutboxStore {
     put(entry: OutboxEntry): Promise<void>;
     /**
-     * Persist `entry` and delete `deleteId` in one durable operation. Used
-     * to resolve a conflict by retrying: the fresh re-assert must never
-     * exist without the conflicted row being gone, nor the row be gone
-     * without the re-assert persisted.
+     * Persist `entry` and delete `deleteId` in one durable operation: the
+     * replacement must never exist without the replaced row being gone,
+     * nor the row be gone without the replacement persisted.
      */
     putAndDelete(entry: OutboxEntry, deleteId: string): Promise<void>;
     list(): Promise<readonly OutboxEntry[]>;
@@ -454,7 +489,7 @@ interface StorageAdapter {
  * // On action receipt:
  * await storage.actions.append(action);
  * for (const update of action.updates) {
- *   await storage.dirtyTracker.mark(update.subject_id, update.subject_type);
+ *   await storage.dirtyTracker.mark(update.subject_id, updateModel(update, row));
  * }
  *
  * // On entity read:

package/dist/memory/index.js

@@ -1,26 +1,31 @@
-import { m as b, a as E, i as M, c as m } from "../cursor-record-D39emd6R.js";
-import { l as D, c as _, a as A, f as T, b as h, h as w, k as j, j as v, n as R, M as f, m as k, p as I, r as F, i as q } from "../replica-record-D3lkFACh.js";
-import { compare as C } from "@ebbjs/core";
-const O = (t, n) => {
+import { l as E, c as D, a as b, f as A, d as _, b as T, n as u, p as h, o as v, q as R, s as j, z as C, M as m, m as q, A as x, r as k, i as F, u as w } from "../replica-record-BaptWabD.js";
+import { componentModel as M, compare as O } from "@ebbjs/core";
+import { m as B, a as P, i as L, c as f } from "../cursor-record-D39emd6R.js";
+const N = (t, n) => {
+  for (const [e, s] of t)
+    if (s.has(n)) return e;
+}, H = (t, n) => {
   const e = /* @__PURE__ */ new Map();
   for (const [s, a] of t)
     e.set(s, new Set(a));
   for (const s of n.updates) {
-    const a = e.get(s.subject_type);
-    a ? a.add(s.subject_id) : e.set(s.subject_type, /* @__PURE__ */ new Set([s.subject_id]));
+    const a = s.method === "delete" ? N(e, s.subject_id) : M(s.component);
+    if (a === void 0) continue;
+    const i = e.get(a);
+    i ? i.add(s.subject_id) : e.set(a, /* @__PURE__ */ new Set([s.subject_id]));
   }
   return Array.from(e.entries()).map(([s, a]) => [s, Array.from(a)]);
-}, P = () => {
+}, K = () => {
   let t = {
     actions: [],
     typeIndex: []
   };
   const n = async (e) => {
-    const s = t.actions.findIndex((d) => d.id === e.id), a = s === -1 ? void 0 : t.actions[s], o = a === void 0 ? e : { ...a, updates: b(a.updates, e.updates) }, c = a === void 0, r = c ? t.actions.length + 1 : s + 1, i = E(a?.updates ?? [], e.updates);
+    const s = t.actions.findIndex((d) => d.id === e.id), a = s === -1 ? void 0 : t.actions[s], i = a === void 0 ? e : { ...a, updates: B(a.updates, e.updates) }, o = a === void 0, r = o ? t.actions.length + 1 : s + 1, c = P(a?.updates ?? [], e.updates);
     return t = {
-      actions: c ? [...t.actions, o] : t.actions.map((d) => d.id === e.id ? o : d),
-      typeIndex: O(t.typeIndex, o)
-    }, { action: o, position: r, added: i };
+      actions: o ? [...t.actions, i] : t.actions.map((d) => d.id === e.id ? i : d),
+      typeIndex: H(t.typeIndex, i)
+    }, { action: i, position: r, added: c };
   };
   return {
     append: n,
@@ -44,14 +49,14 @@ const O = (t, n) => {
     },
     async getForEntity(e) {
       return t.actions.filter(
-        (a) => a.updates.some((o) => o.subject_id === e)
-      ).sort((a, o) => a.gsn - o.gsn);
+        (a) => a.updates.some((i) => i.subject_id === e)
+      ).sort((a, i) => a.gsn - i.gsn);
     },
     async clear() {
       t = { actions: [], typeIndex: [] };
     }
   };
-}, B = () => {
+}, Y = () => {
   let t = {
     entities: {},
     typeIndex: {}
@@ -76,12 +81,12 @@ const O = (t, n) => {
     async clear(n) {
       const e = t.entities[n];
       if (!e) return;
-      const { [n]: s, ...a } = t.entities, o = t.typeIndex[e], c = new Set(o);
-      c.delete(n), t = {
+      const { [n]: s, ...a } = t.entities, i = t.typeIndex[e], o = new Set(i);
+      o.delete(n), t = {
         entities: a,
         typeIndex: {
           ...t.typeIndex,
-          [e]: c
+          [e]: o
         }
       };
     },
@@ -89,79 +94,86 @@ const O = (t, n) => {
       t = { entities: {}, typeIndex: {} };
     }
   };
-}, u = (t) => JSON.parse(JSON.stringify(t)), g = (t, n, e) => {
+}, l = (t) => JSON.parse(JSON.stringify(t)), I = (t, n, e) => {
   const s = { ...t };
   if (e && e !== n.type) {
     const a = new Set(s[e] ?? []);
     a.delete(n.id), s[e] = a;
   }
   return s[n.type] || (s[n.type] = /* @__PURE__ */ new Set()), s[n.type] = new Set(s[n.type]).add(n.id), s;
-}, S = (t, n, e) => w(
-  w(t, v(n, e)),
-  j(n, e)
-), L = (t, n) => {
-  let e = { entities: {}, typeIndex: {}, index: {} };
+}, g = (t, n, e) => {
+  const s = R(n, e);
+  return s === null ? t : j(t, s);
+}, S = (t, n, e) => u(
+  u(t, v(n, e)),
+  h(n, e)
+), z = (t, n) => {
+  let e = { entities: {}, typeIndex: {}, components: /* @__PURE__ */ new Map(), index: {} };
   const s = async (r) => {
     if (!await n.isDirty(r)) return;
     const d = await t.getForEntity(r);
     if (d.length === 0) return;
-    let y = null;
-    for (const p of d)
-      for (const x of p.updates)
-        x.subject_id === r && (y = R(y, x, p.gsn, p.hlc));
+    const y = C(d, r);
     if (y === null) return;
-    const l = e.entities[r];
+    const p = e.entities[r];
     e = {
-      entities: { ...e.entities, [r]: u(y) },
-      typeIndex: g(e.typeIndex, y, l?.type),
-      index: S(e.index, l, y)
+      entities: { ...e.entities, [r]: l(y) },
+      typeIndex: I(e.typeIndex, y, p?.type),
+      components: g(e.components, p, y),
+      index: S(e.index, p, y)
     }, await n.clear(r);
   }, a = async (r) => {
-    for (const i of await n.getDirtyForType(r))
-      await s(i);
-  }, o = (r) => h(e.index[r]);
+    for (const c of await n.getDirtyForType(r))
+      await s(c);
+  }, i = (r) => T(e.index[r]);
   return {
     async get(r) {
       await s(r);
-      const i = e.entities[r];
-      return i ? u(i) : null;
+      const c = e.entities[r];
+      return c ? l(c) : null;
     },
     async set(r) {
-      const i = e.entities[r.id];
+      const c = e.entities[r.id];
       e = {
-        entities: { ...e.entities, [r.id]: u(r) },
-        typeIndex: g(e.typeIndex, r, i?.type),
-        index: S(e.index, i, r)
+        entities: { ...e.entities, [r.id]: l(r) },
+        typeIndex: I(e.typeIndex, r, c?.type),
+        components: g(e.components, c, r),
+        index: S(e.index, c, r)
       };
     },
     async query(r) {
-      return await a(r), [...e.typeIndex[r] ?? /* @__PURE__ */ new Set()].map((d) => u(e.entities[d]));
+      return await a(r), [...e.typeIndex[r] ?? /* @__PURE__ */ new Set()].map((d) => l(e.entities[d]));
+    },
+    async queryByComponent(r) {
+      return await a(M(r)), _(e.components, r).filter(
+        (c) => e.entities[c]?.deleted_hlc === null
+      );
     },
     async queryByRelationship({
       as: r,
-      type: i,
+      type: c,
       targetId: d
     }) {
-      return await a(I), o(F(r, i, d));
+      return await a(x), i(k(r, c, d));
     },
     async queryByRelationshipSource({
       as: r,
-      type: i,
+      type: c,
       sourceId: d
     }) {
-      return await a(I), A(e.index[T(r, i, d)]);
+      return await a(x), b(e.index[A(r, c, d)]);
     },
     async queryByMembership(r) {
-      return await a(f), o(k(r));
+      return await a(m), i(q(r));
     },
     async queryByMembershipEntity(r) {
-      return await a(f), D(e.index[_(r)]);
+      return await a(m), E(e.index[D(r)]);
     },
     async reset() {
-      e = { entities: {}, typeIndex: {}, index: {} };
+      e = { entities: {}, typeIndex: {}, components: /* @__PURE__ */ new Map(), index: {} };
     }
   };
-}, N = () => {
+}, J = () => {
   let t = { records: {} };
   const n = (e) => t.records[e] ?? null;
   return {
@@ -170,19 +182,19 @@ const O = (t, n) => {
     },
     async set(e, s) {
       t = {
-        records: { ...t.records, [e]: m({ ...n(e), cursor: s }) }
+        records: { ...t.records, [e]: f({ ...n(e), cursor: s }) }
       };
     },
     async getRecord(e) {
       return n(e);
     },
     async setRecord(e, s) {
-      if (M(s)) {
-        const { [e]: a, ...o } = t.records;
-        t = { records: o };
+      if (L(s)) {
+        const { [e]: a, ...i } = t.records;
+        t = { records: i };
         return;
       }
-      t = { records: { ...t.records, [e]: m(s) } };
+      t = { records: { ...t.records, [e]: f(s) } };
     },
     async records() {
       return new Map(Object.entries(t.records));
@@ -191,7 +203,7 @@ const O = (t, n) => {
       t = { records: {} };
     }
   };
-}, H = () => {
+}, U = () => {
   let t = {};
   return {
     async put(n) {
@@ -202,7 +214,7 @@ const O = (t, n) => {
       t = { ...a, [n.action.id]: structuredClone(n) };
     },
     async list() {
-      return Object.values(t).map((n) => structuredClone(n)).sort((n, e) => C(n.enqueuedAtHlc, e.enqueuedAtHlc));
+      return Object.values(t).map((n) => structuredClone(n)).sort((n, e) => O(n.enqueuedAtHlc, e.enqueuedAtHlc));
     },
     async get(n) {
       const e = t[n];
@@ -216,11 +228,11 @@ const O = (t, n) => {
       t = {};
     }
   };
-}, K = () => {
+}, V = () => {
   let t = null;
   return {
     async load() {
-      return q(t) ? t : null;
+      return F(t) ? t : null;
     },
     async save(n) {
       t = n;
@@ -229,25 +241,31 @@ const O = (t, n) => {
       t = null;
     }
   };
-}, z = () => {
-  const t = P(), n = B(), e = L(t, n), s = N(), a = H(), o = K();
+}, X = () => {
+  const t = K(), n = Y(), e = z(t, n), s = J(), a = U(), i = V();
   return {
     actions: {
-      async append(c) {
-        const r = await t.append(c);
-        for (const i of c.updates)
-          await n.mark(i.subject_id, i.subject_type);
+      async append(o) {
+        const r = await t.append(o);
+        for (const c of o.updates)
+          await n.mark(
+            c.subject_id,
+            w(c, await e.get(c.subject_id))
+          );
         return r;
       },
-      async appendMany(c) {
-        const r = await t.appendMany(c);
-        for (const i of c)
-          for (const d of i.updates)
-            await n.mark(d.subject_id, d.subject_type);
+      async appendMany(o) {
+        const r = await t.appendMany(o);
+        for (const c of o)
+          for (const d of c.updates)
+            await n.mark(
+              d.subject_id,
+              w(d, await e.get(d.subject_id))
+            );
         return r;
       },
-      async readTail(c) {
-        return t.readTail(c);
+      async readTail(o) {
+        return t.readTail(o);
       },
       async lastPosition() {
         return t.lastPosition();
@@ -255,26 +273,26 @@ const O = (t, n) => {
       async getAll() {
         return t.getAll();
       },
-      async getForEntity(c) {
-        return t.getForEntity(c);
+      async getForEntity(o) {
+        return t.getForEntity(o);
       },
       async clear() {
-        await t.clear(), await n.clearAll(), await e.reset(), await o.clear();
+        await t.clear(), await n.clearAll(), await e.reset(), await i.clear();
       }
     },
     entities: e,
     dirtyTracker: {
-      async mark(c, r) {
-        await n.mark(c, r);
+      async mark(o, r) {
+        await n.mark(o, r);
       },
-      async isDirty(c) {
-        return n.isDirty(c);
+      async isDirty(o) {
+        return n.isDirty(o);
       },
-      async getDirtyForType(c) {
-        return n.getDirtyForType(c);
+      async getDirtyForType(o) {
+        return n.getDirtyForType(o);
       },
-      async clear(c) {
-        await n.clear(c);
+      async clear(o) {
+        await n.clear(o);
       },
       async clearAll() {
         await n.clearAll();
@@ -282,15 +300,15 @@ const O = (t, n) => {
     },
     cursors: s,
     outbox: a,
-    replica: o,
-    async isDirty(c) {
-      return n.isDirty(c);
+    replica: i,
+    async isDirty(o) {
+      return n.isDirty(o);
     },
     async reset() {
-      await t.clear(), await n.clearAll(), await e.reset(), await o.clear(), await s.clear();
+      await t.clear(), await n.clearAll(), await e.reset(), await i.clear(), await s.clear();
     }
   };
 };
 export {
-  z as createMemoryAdapter
+  X as createMemoryAdapter
 };

package/dist/replica/index.d.ts

@@ -10,15 +10,34 @@ interface MaterializeOptions {
     readonly residentMapFields?: boolean;
 }
 /**
- * Applies a single update to an entity during materialization.
+ * Applies a single component Update to a row during materialization.
  *
- * - PUT: full replacement
- * - PATCH: field-level LWW merge; ignored on a soft-deleted entity
- * - DELETE: soft delete (sets `deleted_hlc`); bumps `last_gsn` and
- *   `updated_hlc`. A delete for a row that was never materialized is a
- *   no-op, so a per-Update delivery (#473) cannot break the drain.
+ * - `merge` / `replace`: apply the component's value at its field under the
+ *   leaf-level LWW compare. The first such write on a row that does not exist
+ *   creates it; `replace` is the row's create, while `merge` leaves
+ *   `exists: false` and `created_hlc: null` because the create has not been
+ *   seen, so the row is a backfill candidate.
+ * - `drop`: remove the field from an existing row; the row survives with its
+ *   existence and creation time, even when the last component is detached.
+ *   A tombstone stays a tombstone — detaching a component is not a
+ *   resurrection.
+ * - `delete`: tombstone the row, keeping its type and existence bit. A delete
+ *   for a row that was never materialized is a no-op, so a per-Update delivery
+ *   (#473) cannot break the drain.
+ *
+ * A component write to a tombstoned row resurrects it, exactly as the server's
+ * materialization does.
  */
 declare const applyUpdate: (entity: Entity | null, update: Update, gsn: number, hlc: HLCTimestamp, options?: MaterializeOptions) => Entity | null;
+/**
+ * Fold one Action's Updates for `entityId` into a row: every Update addressed
+ * to that subject, in `updates` order, under the Action's `gsn` and `hlc`.
+ * An Update for another subject belongs to a different row and is skipped.
+ *
+ * This is the replay step every EntityStore adapter runs for the row it is
+ * materializing.
+ */
+declare const foldEntityAction: (entity: Entity | null, entityId: string, action: Action) => Entity | null;
 
 /**
  * True when `next` differs from `prev` in anything a reader can observe.
@@ -80,8 +99,15 @@ type Revision = number;
 interface ReplicaChange {
     readonly revision: Revision;
     readonly id: string;
-    readonly type: string;
     readonly deleted: boolean;
+    /**
+     * The components this change touched, so a derived reader invalidates on what
+     * it read rather than on the row's whole model. A tombstone transition touches
+     * every component the row carries, and a write that moves a row between models
+     * names each field under both prefixes. Empty only for a row that carried no
+     * component.
+     */
+    readonly components: readonly string[];
 }
 /**
  * Whether the replica retains a type's rows. The seam #500 builds on-demand
@@ -181,7 +207,11 @@ interface Replica {
      * with gsn 0, which would hide the row's folded position.
      */
     base(id: string): Entity | undefined;
-    iterate(type: string): readonly Entity[];
+    /**
+     * Every row of `model`, whatever optional components it carries. Served by
+     * the model index with the overlay's model overrides layered on top.
+     */
+    iterate(model: string): readonly Entity[];
     /** Whether the materialization policy holds `type` in full. */
     isHeld(type: string): boolean;
     /**
@@ -212,6 +242,12 @@ interface Replica {
      * live sources pointing at `(as, type, targetId)`, ascending.
      */
     relationships(query: RelationshipQuery): readonly string[];
+    /**
+     * Ids currently carrying `component` (`<type>/<field>`) in the composed
+     * view, ascending. Component existence is the set of present fields on a
+     * row, so a query reading it costs its index rather than a row filter.
+     */
+    components(component: string): readonly string[];
     /**
      * Distinct live member entity ids of a group, or distinct live group
      * ids of an entity, ascending.
@@ -262,10 +298,12 @@ declare const DEFAULT_PINNED_TTL_MS = 30000;
  * persists, once pinned on-demand rows are filtered out), `overlay` composes
  * optimistic writes over it, and `effective` caches the composed view for
  * overlaid ids so a read never recomposes.
- * `typeIndex` indexes the base; `iterate` layers the overlay's type overrides
- * on top of it.
+ * `modelIndex` indexes the base by model; `iterate` layers the overlay's model
+ * overrides on top of it. `componentIndex` tracks the composed view's component
+ * set alongside the adjacency indices, and is likewise derived rather than
+ * persisted.
  */
 declare const createReplica: (options?: ReplicaOptions) => Replica;
 
-export { DEFAULT_PINNED_CAPACITY, DEFAULT_PINNED_TTL_MS, applyUpdate, contentChanged, createReplica, holdAll };
+export { DEFAULT_PINNED_CAPACITY, DEFAULT_PINNED_TTL_MS, applyUpdate, contentChanged, createReplica, foldEntityAction, holdAll };
 export type { MaterializationPolicy, MembershipQuery, RelationshipQuery, Replica, ReplicaChange, ReplicaOptions, ReplicaStats, Revision };