@ebbjs/storage 1.0.0 → 1.1.0

package/dist/indexeddb/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[]>;
@@ -236,32 +252,32 @@ 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;
@@ -285,7 +301,8 @@ interface ConflictRemoteAction {
  */
 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;
 }

package/dist/indexeddb/index.js

@@ -1,125 +1,125 @@
-import { unwrap as h, openDB as D } from "idb";
-import { m as _, a as T, i as O, c as v } from "../cursor-record-D39emd6R.js";
-import { c as R, l as b, f as k, a as N, b as P, j as C, k as B, q as M, t as F, u as H, M as g, m as L, s as x, r as G, i as K } from "../replica-record-D5gGEoVQ.js";
-import { compare as U } from "@ebbjs/core";
-const Y = 10, V = 9, w = "actionPosition", j = "replica", z = (t, e, a, o) => {
-  const s = e > 0 && e < V;
-  if (s)
-    for (const r of Array.from(t.objectStoreNames))
-      t.deleteObjectStore(r);
+import { unwrap as D, openDB as O } from "idb";
+import { c as T, l as N, f as R, a as b, b as C, e as k, o as P, p as B, z as M, B as F, C as H, M as x, m as L, A as j, r as G, i as K, u as I } from "../replica-record-BaptWabD.js";
+import { m as U, a as V, i as Y, c as h } from "../cursor-record-D39emd6R.js";
+import { componentModel as z, compare as X } from "@ebbjs/core";
+const Q = 11, J = 9, W = 11, f = "actionPosition", A = "replica", Z = (t, e, o, a) => {
+  const s = [J, W], u = e > 0 && s.some((i) => e < i);
+  if (u)
+    for (const i of Array.from(t.objectStoreNames))
+      t.deleteObjectStore(i);
   if (t.objectStoreNames.contains("actions"))
-    o.objectStore("actions").indexNames.contains("position") || o.objectStore("actions").createIndex("position", "position");
+    a.objectStore("actions").indexNames.contains("position") || a.objectStore("actions").createIndex("position", "position");
   else {
-    const r = t.createObjectStore("actions", { keyPath: "id" });
-    r.createIndex("subject_id", "subject_ids", { multiEntry: !0 }), r.createIndex("position", "position");
+    const i = t.createObjectStore("actions", { keyPath: "id" });
+    i.createIndex("subject_id", "subject_ids", { multiEntry: !0 }), i.createIndex("position", "position");
   }
   if (!t.objectStoreNames.contains("entities")) {
-    const r = t.createObjectStore("entities", { keyPath: "id" });
-    r.indexNames.contains("type") || r.createIndex("type", "type");
+    const i = t.createObjectStore("entities", { keyPath: "id" });
+    i.indexNames.contains("type") || i.createIndex("type", "type"), i.createIndex("components", "components", { multiEntry: !0 });
   }
   if (t.objectStoreNames.contains("relationships") || t.createObjectStore("relationships", { keyPath: "key" }), !t.objectStoreNames.contains("dirty")) {
-    const r = t.createObjectStore("dirty", { keyPath: "entityId" });
-    r.indexNames.contains("entityType") || r.createIndex("entityType", "entityType");
+    const i = t.createObjectStore("dirty", { keyPath: "entityId" });
+    i.indexNames.contains("entityType") || i.createIndex("entityType", "entityType");
   }
-  t.objectStoreNames.contains("cursors") || t.createObjectStore("cursors", { keyPath: "groupId" }), t.objectStoreNames.contains("outbox") || t.createObjectStore("outbox", { keyPath: "action.id" }), t.objectStoreNames.contains("sequence") || t.createObjectStore("sequence", { keyPath: "id" }), t.objectStoreNames.contains("replica") || t.createObjectStore("replica", { keyPath: ["type", "id"] }), t.objectStoreNames.contains("replicaCursor") || t.createObjectStore("replicaCursor", { keyPath: "id" }), s ? o.objectStore("sequence").put({ id: w, value: 0 }) : e < 8 && Q(o);
-}, Q = (t) => {
-  const e = h(t.objectStore("actions")), a = t.objectStore("sequence");
-  let o = 0;
+  t.objectStoreNames.contains("cursors") || t.createObjectStore("cursors", { keyPath: "groupId" }), t.objectStoreNames.contains("outbox") || t.createObjectStore("outbox", { keyPath: "action.id" }), t.objectStoreNames.contains("sequence") || t.createObjectStore("sequence", { keyPath: "id" }), t.objectStoreNames.contains("replica") || t.createObjectStore("replica", { keyPath: ["type", "id"] }), t.objectStoreNames.contains("replicaCursor") || t.createObjectStore("replicaCursor", { keyPath: "id" }), u ? a.objectStore("sequence").put({ id: f, value: 0 }) : e < 8 && $(a);
+}, $ = (t) => {
+  const e = D(t.objectStore("actions")), o = t.objectStore("sequence");
+  let a = 0;
   const s = e.openCursor();
   s.onsuccess = () => {
-    const r = s.result;
-    if (r === null) {
-      a.put({ id: w, value: o });
+    const u = s.result;
+    if (u === null) {
+      o.put({ id: f, value: a });
       return;
     }
-    o += 1, r.update({ ...r.value, position: o }), r.continue();
+    a += 1, u.update({ ...u.value, position: a }), u.continue();
   };
-}, X = (t) => {
+}, tt = (t) => {
   const e = /* @__PURE__ */ new Set();
-  for (const a of t.updates)
-    e.add(a.subject_id);
+  for (const o of t.updates)
+    e.add(o.subject_id);
   return Array.from(e);
-}, S = (t) => {
-  const { subject_ids: e, position: a, ...o } = t;
-  return o;
-}, I = async (t, e) => {
-  const a = t.objectStore("actions"), o = await a.get(e.id), s = await t.objectStore("sequence").get(w), r = o === void 0, l = r ? (s?.value ?? 0) + 1 : o.position, p = o === void 0 ? e : { ...e, updates: _(o.updates, e.updates) }, y = T(o?.updates ?? [], e.updates);
-  return await a.put({ ...p, position: l, subject_ids: X(p) }), r && await t.objectStore("sequence").put({ id: w, value: l }), { action: p, position: l, added: y };
-}, J = (t) => ({
+}, g = (t) => {
+  const { subject_ids: e, position: o, ...a } = t;
+  return a;
+}, E = async (t, e) => {
+  const o = t.objectStore("actions"), a = await o.get(e.id), s = await t.objectStore("sequence").get(f), u = a === void 0, i = u ? (s?.value ?? 0) + 1 : a.position, y = a === void 0 ? e : { ...e, updates: U(a.updates, e.updates) }, w = V(a?.updates ?? [], e.updates);
+  return await o.put({ ...y, position: i, subject_ids: tt(y) }), u && await t.objectStore("sequence").put({ id: f, value: i }), { action: y, position: i, added: w };
+}, et = (t) => ({
   async append(e) {
-    const a = t.transaction(["actions", "sequence"], "readwrite"), o = await I(a, e);
-    return await a.done, o;
+    const o = t.transaction(["actions", "sequence"], "readwrite"), a = await E(o, e);
+    return await o.done, a;
   },
   async appendMany(e) {
-    const a = t.transaction(["actions", "sequence"], "readwrite"), o = [];
+    const o = t.transaction(["actions", "sequence"], "readwrite"), a = [];
     for (const s of e)
-      o.push(await I(a, s));
-    return await a.done, o;
+      a.push(await E(o, s));
+    return await o.done, a;
   },
   async readTail(e) {
-    const a = t.transaction("actions", "readonly"), o = await a.store.index("position").getAll(IDBKeyRange.lowerBound(e, !0));
-    return await a.done, o.map((s) => ({
-      action: S(s),
+    const o = t.transaction("actions", "readonly"), a = await o.store.index("position").getAll(IDBKeyRange.lowerBound(e, !0));
+    return await o.done, a.map((s) => ({
+      action: g(s),
       position: s.position,
       added: s.updates
     }));
   },
   async lastPosition() {
-    return (await t.get("sequence", w))?.value ?? 0;
+    return (await t.get("sequence", f))?.value ?? 0;
   },
   async getAll() {
-    return (await t.getAll("actions")).map(S);
+    return (await t.getAll("actions")).map(g);
   },
   async getForEntity(e) {
-    const a = t.transaction("actions", "readonly"), o = await a.store.index("subject_id").getAll(e);
-    return await a.done, o.map(S).sort((r, l) => r.gsn - l.gsn);
+    const o = t.transaction("actions", "readonly"), a = await o.store.index("subject_id").getAll(e);
+    return await o.done, a.map(g).sort((u, i) => u.gsn - i.gsn);
   },
   async clear() {
     const e = t.transaction(["actions", "sequence"], "readwrite");
-    await e.objectStore("actions").clear(), await e.objectStore("sequence").put({ id: w, value: 0 }), await e.done;
+    await e.objectStore("actions").clear(), await e.objectStore("sequence").put({ id: f, value: 0 }), await e.done;
   }
-}), A = (t) => t === void 0 ? null : v(t), W = (t) => {
-  const e = async (a) => A(await t.get("cursors", a));
+}), v = (t) => t === void 0 ? null : h(t), ot = (t) => {
+  const e = async (o) => v(await t.get("cursors", o));
   return {
-    async get(a) {
-      return (await t.get("cursors", a))?.cursor ?? null;
+    async get(o) {
+      return (await t.get("cursors", o))?.cursor ?? null;
     },
-    async set(a, o) {
-      const s = await e(a);
-      await t.put("cursors", { groupId: a, ...s, cursor: o });
+    async set(o, a) {
+      const s = await e(o);
+      await t.put("cursors", { groupId: o, ...s, cursor: a });
     },
-    async getRecord(a) {
-      return e(a);
+    async getRecord(o) {
+      return e(o);
     },
-    async setRecord(a, o) {
-      if (O(o)) {
-        await t.delete("cursors", a);
+    async setRecord(o, a) {
+      if (Y(a)) {
+        await t.delete("cursors", o);
         return;
       }
       await t.put("cursors", {
-        groupId: a,
-        ...v(o)
+        groupId: o,
+        ...h(a)
       });
     },
     async records() {
-      const a = await t.getAll("cursors"), o = /* @__PURE__ */ new Map();
-      for (const s of a)
-        o.set(s.groupId, A(s) ?? {});
-      return o;
+      const o = await t.getAll("cursors"), a = /* @__PURE__ */ new Map();
+      for (const s of o)
+        a.set(s.groupId, v(s) ?? {});
+      return a;
     },
     async clear() {
       await t.clear("cursors");
     }
   };
-}, Z = (t) => ({
-  async mark(e, a) {
-    await t.get("dirty", e) || await t.put("dirty", { entityId: e, entityType: a });
+}, at = (t) => ({
+  async mark(e, o) {
+    await t.get("dirty", e) || await t.put("dirty", { entityId: e, entityType: o });
   },
   async isDirty(e) {
     return await t.get("dirty", e) !== void 0;
   },
   async getDirtyForType(e) {
-    return (await t.getAllFromIndex("dirty", "entityType", e)).map((o) => o.entityId);
+    return (await t.getAllFromIndex("dirty", "entityType", e)).map((a) => a.entityId);
   },
   async clear(e) {
     await t.delete("dirty", e);
@@ -127,87 +127,99 @@ const Y = 10, V = 9, w = "actionPosition", j = "replica", z = (t, e, a, o) => {
   async clearAll() {
     await t.clear("dirty");
   }
-}), $ = (t, e, a) => {
-  const o = (n) => structuredClone(n), s = async (n, i) => {
-    i === null ? await t.delete("relationships", n) : await t.put("relationships", { key: n, rows: i });
-  }, r = async (n) => {
-    const i = await t.get("relationships", n.key);
-    await s(n.key, H(i?.rows, n));
-  }, l = async (n) => {
-    const i = await t.get("relationships", n.key);
-    await s(n.key, F(i?.rows, n));
-  }, p = async (n, i) => {
-    for (const u of [C(n, i), B(n, i)])
-      u.remove !== null && await l(u.remove), u.add !== null && await r(u.add);
+}), nt = (t, e, o) => {
+  const a = (n) => ({
+    ...structuredClone(n),
+    components: k(n)
+  }), s = (n) => {
+    const { components: r, ...l } = n;
+    return l;
+  }, u = async (n) => {
+    const r = await t.get("entities", n);
+    return r === void 0 ? void 0 : s(r);
+  }, i = async (n, r) => {
+    r === null ? await t.delete("relationships", n) : await t.put("relationships", { key: n, rows: r });
   }, y = async (n) => {
-    if (!await a.isDirty(n)) return;
-    const u = await e.getForEntity(n);
-    if (u.length === 0) return;
-    const m = M(u, n);
-    if (m === null) return;
-    const q = await t.get("entities", n);
-    await t.put("entities", o(m)), await p(q, m), await a.clear(n);
-  }, c = async (n) => {
-    for (const i of await a.getDirtyForType(n))
-      await y(i);
+    const r = await t.get("relationships", n.key);
+    await i(n.key, H(r?.rows, n));
+  }, w = async (n) => {
+    const r = await t.get("relationships", n.key);
+    await i(n.key, F(r?.rows, n));
+  }, c = async (n, r) => {
+    for (const l of [P(n, r), B(n, r)])
+      l.remove !== null && await w(l.remove), l.add !== null && await y(l.add);
+  }, p = async (n) => {
+    if (!await o.isDirty(n)) return;
+    const l = await e.getForEntity(n);
+    if (l.length === 0) return;
+    const S = M(l, n);
+    if (S === null) return;
+    const q = await u(n);
+    await t.put("entities", a(S)), await c(q, S), await o.clear(n);
   }, d = async (n) => {
-    const i = await t.get("relationships", n);
-    return P(i?.rows);
+    for (const r of await o.getDirtyForType(n))
+      await p(r);
+  }, m = async (n) => {
+    const r = await t.get("relationships", n);
+    return C(r?.rows);
   };
   return {
     async get(n) {
-      await y(n);
-      const i = await t.get("entities", n);
-      return i ? o(i) : null;
+      await p(n);
+      const r = await t.get("entities", n);
+      return r === void 0 ? null : s(r);
     },
     async set(n) {
-      const i = await t.get("entities", n.id);
-      await t.put("entities", o(n)), await p(i, n);
+      const r = await u(n.id);
+      await t.put("entities", a(n)), await c(r, n);
     },
     async query(n) {
-      return await c(n), (await t.getAllFromIndex("entities", "type", n)).map(o);
+      return await d(n), (await t.getAllFromIndex("entities", "type", n)).map(s);
+    },
+    async queryByComponent(n) {
+      return await d(z(n)), (await t.getAllFromIndex("entities", "components", n)).filter((l) => l.deleted_hlc === null).map((l) => l.id).sort();
     },
     async queryByRelationship({
       as: n,
-      type: i,
-      targetId: u
+      type: r,
+      targetId: l
     }) {
-      return await c(x), d(G(n, i, u));
+      return await d(j), m(G(n, r, l));
     },
     async queryByRelationshipSource({
       as: n,
-      type: i,
-      sourceId: u
+      type: r,
+      sourceId: l
     }) {
-      await c(x);
-      const m = await t.get("relationships", k(n, i, u));
-      return N(m?.rows);
+      await d(j);
+      const S = await t.get("relationships", R(n, r, l));
+      return b(S?.rows);
     },
     async queryByMembership(n) {
-      return await c(g), d(L(n));
+      return await d(x), m(L(n));
     },
     async queryByMembershipEntity(n) {
-      await c(g);
-      const i = await t.get("relationships", R(n));
-      return b(i?.rows);
+      await d(x);
+      const r = await t.get("relationships", T(n));
+      return N(r?.rows);
     },
     async reset() {
       await t.clear("relationships"), await t.clear("entities");
     }
   };
-}, tt = (t) => ({
+}, st = (t) => ({
   ...t,
   scope: t.scope ?? "field",
   remoteActions: t.remoteActions ?? []
-}), E = (t) => ({
+}), _ = (t) => ({
   action: t.action,
   status: t.status,
   enqueuedAtHlc: t.enqueuedAtHlc,
   // A row predating the field reads as "always concurrent", never
   // silently dropped.
   basedOnGsn: t.basedOnGsn ?? 0,
-  conflict: t.conflict === void 0 ? void 0 : tt(t.conflict)
-}), et = (t) => ({
+  conflict: t.conflict === void 0 ? void 0 : st(t.conflict)
+}), rt = (t) => ({
   async put(e) {
     await t.put("outbox", {
       action: e.action,
@@ -217,22 +229,22 @@ const Y = 10, V = 9, w = "actionPosition", j = "replica", z = (t, e, a, o) => {
       conflict: e.conflict
     });
   },
-  async putAndDelete(e, a) {
-    const o = t.transaction("outbox", "readwrite");
-    o.store.put({
+  async putAndDelete(e, o) {
+    const a = t.transaction("outbox", "readwrite");
+    a.store.put({
       action: e.action,
       status: e.status,
       enqueuedAtHlc: e.enqueuedAtHlc,
       basedOnGsn: e.basedOnGsn,
       conflict: e.conflict
-    }), o.store.delete(a), await o.done;
+    }), a.store.delete(o), await a.done;
   },
   async list() {
-    return (await t.getAll("outbox")).map(E).sort((a, o) => U(a.enqueuedAtHlc, o.enqueuedAtHlc));
+    return (await t.getAll("outbox")).map(_).sort((o, a) => X(o.enqueuedAtHlc, a.enqueuedAtHlc));
   },
   async get(e) {
-    const a = await t.get("outbox", e);
-    return a === void 0 ? null : E(a);
+    const o = await t.get("outbox", e);
+    return o === void 0 ? null : _(o);
   },
   async delete(e) {
     await t.delete("outbox", e);
@@ -240,76 +252,82 @@ const Y = 10, V = 9, w = "actionPosition", j = "replica", z = (t, e, a, o) => {
   async clear() {
     await t.clear("outbox");
   }
-}), at = (t) => ({
+}), it = (t) => ({
   async load() {
-    const e = t.transaction(["replica", "replicaCursor"], "readonly"), a = await e.objectStore("replicaCursor").get(j);
-    if (a === void 0)
+    const e = t.transaction(["replica", "replicaCursor"], "readonly"), o = await e.objectStore("replicaCursor").get(A);
+    if (o === void 0)
       return await e.done, null;
-    const o = await e.objectStore("replica").getAll();
+    const a = await e.objectStore("replica").getAll();
     await e.done;
     const s = {
-      format: a.format,
-      position: a.position,
-      revision: a.revision,
-      entities: o
+      format: o.format,
+      position: o.position,
+      revision: o.revision,
+      entities: a
     };
     return K(s) ? s : null;
   },
   async save(e) {
-    const a = t.transaction(["replica", "replicaCursor"], "readwrite"), o = a.objectStore("replica");
-    await o.clear();
+    const o = t.transaction(["replica", "replicaCursor"], "readwrite"), a = o.objectStore("replica");
+    await a.clear();
     for (const s of e.entities)
-      await o.put(s);
-    await a.objectStore("replicaCursor").put({
-      id: j,
+      await a.put(s);
+    await o.objectStore("replicaCursor").put({
+      id: A,
       format: e.format,
       position: e.position,
       revision: e.revision
-    }), await a.done;
+    }), await o.done;
   },
   async clear() {
     const e = t.transaction(["replica", "replicaCursor"], "readwrite");
     await e.objectStore("replica").clear(), await e.objectStore("replicaCursor").clear(), await e.done;
   }
-}), it = async (t = {}) => {
-  const e = t.dbName ?? "ebb-storage", a = await D(e, Y, {
-    upgrade: z
-  }), o = J(a), s = Z(a), r = $(a, o, s), l = W(a), p = et(a), y = at(a);
+}), yt = async (t = {}) => {
+  const e = t.dbName ?? "ebb-storage", o = await O(e, Q, {
+    upgrade: Z
+  }), a = et(o), s = at(o), u = nt(o, a, s), i = ot(o), y = rt(o), w = it(o);
   return {
     actions: {
       async append(c) {
-        const d = await o.append(c);
-        for (const f of c.updates)
-          await s.mark(f.subject_id, f.subject_type);
-        return d;
+        const p = await a.append(c);
+        for (const d of c.updates)
+          await s.mark(
+            d.subject_id,
+            I(d, await u.get(d.subject_id))
+          );
+        return p;
       },
       async appendMany(c) {
-        const d = await o.appendMany(c);
-        for (const f of c)
-          for (const n of f.updates)
-            await s.mark(n.subject_id, n.subject_type);
-        return d;
+        const p = await a.appendMany(c);
+        for (const d of c)
+          for (const m of d.updates)
+            await s.mark(
+              m.subject_id,
+              I(m, await u.get(m.subject_id))
+            );
+        return p;
       },
       async readTail(c) {
-        return o.readTail(c);
+        return a.readTail(c);
       },
       async lastPosition() {
-        return o.lastPosition();
+        return a.lastPosition();
       },
       async getAll() {
-        return o.getAll();
+        return a.getAll();
       },
       async getForEntity(c) {
-        return o.getForEntity(c);
+        return a.getForEntity(c);
       },
       async clear() {
-        await o.clear(), await s.clearAll(), await r.reset(), await y.clear();
+        await a.clear(), await s.clearAll(), await u.reset(), await w.clear();
       }
     },
-    entities: r,
+    entities: u,
     dirtyTracker: {
-      async mark(c, d) {
-        await s.mark(c, d);
+      async mark(c, p) {
+        await s.mark(c, p);
       },
       async isDirty(c) {
         return s.isDirty(c);
@@ -324,17 +342,17 @@ const Y = 10, V = 9, w = "actionPosition", j = "replica", z = (t, e, a, o) => {
         await s.clearAll();
       }
     },
-    cursors: l,
-    outbox: p,
-    replica: y,
+    cursors: i,
+    outbox: y,
+    replica: w,
     async isDirty(c) {
       return s.isDirty(c);
     },
     async reset() {
-      await o.clear(), await s.clearAll(), await r.reset(), await y.clear(), await l.clear();
+      await a.clear(), await s.clearAll(), await u.reset(), await w.clear(), await i.clear();
     }
   };
 };
 export {
-  it as createIndexedDBAdapter
+  yt as createIndexedDBAdapter
 };