@ebbjs/storage 0.3.0 → 1.1.0

package/dist/replica-record-BaptWabD.js

@@ -0,0 +1,243 @@
+import { isFieldMap as u, mergeFieldValue as p, latestHlc as F, componentModel as m, componentField as H, isFieldLeaf as W, componentName as b } from "@ebbjs/core";
+const B = 500, y = 64, h = /* @__PURE__ */ new WeakMap(), K = (e) => {
+  let t = 2166136261;
+  for (let n = 0; n < e.length; n += 1)
+    t ^= e.charCodeAt(n), t = Math.imul(t, 16777619) >>> 0;
+  return t >>> 0;
+}, R = (e) => K(e) % y, V = () => Array.from({ length: y }, () => ({})), k = (e, t) => {
+  let n = t;
+  const o = {
+    get map() {
+      if (n === void 0) {
+        const r = {};
+        for (const s of e) Object.assign(r, s);
+        n = r;
+      }
+      return n;
+    }
+  };
+  return h.set(o, e), o;
+}, I = (e) => u(e) && h.has(e), Y = (e) => {
+  const t = h.get(e);
+  if (t === void 0) throw new Error("not a sharded map field");
+  return t;
+}, $ = (e) => e.map, z = (e) => {
+  const t = V(), n = {};
+  for (const [o, r] of Object.entries(e))
+    t[R(o)][o] = r, n[o] = r;
+  return k(t, n);
+}, O = (e) => !u(e) || I(e) ? e : Object.keys(e.map).length >= B ? z(e.map) : e, j = (e) => {
+  let t;
+  for (const [n, o] of Object.entries(e)) {
+    const r = O(o);
+    r !== o && (t === void 0 && (t = { ...e }), t[n] = r);
+  }
+  return t ?? e;
+}, U = (e) => {
+  let t;
+  for (const [n, o] of Object.entries(e))
+    !u(o) || !I(o) || (t === void 0 && (t = { ...e }), t[n] = { map: $(o) });
+  return t ?? e;
+}, q = (e, t) => {
+  const n = Y(e), o = [...n], r = /* @__PURE__ */ new Map();
+  for (const [s, l] of Object.entries(t.map)) {
+    const a = R(s), v = (r.get(a) ?? n[a])[s], g = p(v, l);
+    if (g === v) continue;
+    let i = r.get(a);
+    i === void 0 && (i = { ...n[a] }, r.set(a, i)), i[s] = g;
+  }
+  if (r.size === 0) return e;
+  for (const [s, l] of r) o[s] = l;
+  return k(o);
+}, G = (e, t) => {
+  if (e !== void 0 && u(e) && I(e))
+    return u(t) ? q(e, t) : t;
+  const n = p(e, t);
+  return n === e ? n : O(n);
+}, he = (e, t) => e.method === "delete" ? t?.type ?? "" : m(e.component), J = (e) => {
+  if (e.method === "delete") return null;
+  const t = H(e.component);
+  return e.method === "drop" ? { field: t, method: "drop", value: null } : { field: t, method: e.method, value: e.data };
+}, Ie = { residentMapFields: !0 }, Q = (e, t, n) => {
+  const o = n?.residentMapFields ? G : p, r = e.fields[t.field], s = o(r, t.value);
+  return s === r ? e : { fields: { ...e.fields, [t.field]: s } };
+}, A = (e, t) => {
+  const n = t(e.data.fields);
+  return n === e.data.fields ? e : { ...e, data: { ...e.data, fields: n } };
+}, _e = (e) => A(e, j), we = (e) => A(e, U), X = (e, t, n, o, r) => {
+  const s = { [t.field]: t.value }, l = t.method === "replace";
+  return {
+    id: e.subject_id,
+    type: m(e.component),
+    data: { fields: r?.residentMapFields ? j(s) : s },
+    // A `replace` is the row's create; a `merge` arrives first only when the
+    // replica has not seen that create, so the placeholder waits for the base.
+    exists: l,
+    created_hlc: l ? o : null,
+    updated_hlc: o,
+    deleted_hlc: null,
+    last_gsn: n
+  };
+}, Z = (e, t, n, o, r) => {
+  if (t.method === "delete")
+    return e ? {
+      ...e,
+      deleted_hlc: o,
+      updated_hlc: o,
+      last_gsn: Math.max(e.last_gsn, n)
+    } : null;
+  const s = J(t);
+  if (s === null) return e;
+  if (s.method === "drop") {
+    if (!e) return null;
+    const { [s.field]: a, ...w } = e.data.fields;
+    return {
+      ...e,
+      data: { fields: w },
+      updated_hlc: F(e.updated_hlc, o),
+      last_gsn: Math.max(e.last_gsn, n)
+    };
+  }
+  if (!e) return X(t, s, n, o, r);
+  const l = s.method === "replace" && !e.exists;
+  return {
+    ...e,
+    type: m(t.component),
+    // A leaf `replace` is the leaf-level LWW compare, so it shares the merge
+    // rule: an out-of-order base snapshot must not clobber a newer write.
+    data: Q(e.data, s, r),
+    exists: e.exists || s.method === "replace",
+    created_hlc: l ? o : e.created_hlc,
+    updated_hlc: F(e.updated_hlc, o),
+    deleted_hlc: null,
+    last_gsn: Math.max(e.last_gsn, n)
+  };
+}, ee = (e, t, n) => {
+  let o = e;
+  for (const r of n.updates)
+    r.subject_id === t && (o = Z(o, r, n.gsn, n.hlc));
+  return o;
+}, ve = (e, t) => {
+  let n = null;
+  for (const o of e)
+    n = ee(n, t, o);
+  return n;
+}, T = "relationship", f = "entityGroup", C = "groups", _ = (e, t, n) => `${e}\0${t}\0${n}`, D = (e, t, n) => `
${_(e, t, n)}`, te = (e) => _(C, f, e), ne = (e) => D(C, f, e), d = (e, t) => {
+  const n = e.data?.fields?.[t];
+  if (n === void 0 || !W(n)) return null;
+  const o = n.value;
+  return typeof o == "string" ? o : null;
+}, oe = (e) => {
+  if (e.type !== T || e.deleted_hlc !== null) return null;
+  const t = d(e, "field"), n = d(e, "type"), o = d(e, "target_id"), r = d(e, "source_id");
+  return t === null || n === null || o === null || r === null ? null : { key: _(t, n, o), rowId: e.id, value: r };
+}, re = (e) => {
+  if (e.type !== T || e.deleted_hlc !== null) return null;
+  const t = d(e, "field"), n = d(e, "type"), o = d(e, "source_id"), r = d(e, "target_id");
+  return t === null || n === null || o === null || r === null ? null : { key: D(t, n, o), rowId: e.id, value: r };
+}, se = (e) => {
+  if (e.type !== f || e.deleted_hlc !== null) return null;
+  const t = d(e, "group_id"), n = d(e, "entity_id");
+  return t === null || n === null ? null : { key: te(t), rowId: e.id, value: n };
+}, le = (e) => {
+  if (e.type !== f || e.deleted_hlc !== null) return null;
+  const t = d(e, "group_id"), n = d(e, "entity_id");
+  return t === null || n === null ? null : { key: ne(n), rowId: e.id, value: t };
+}, de = (e) => oe(e) ?? se(e), ce = (e) => re(e) ?? le(e), x = (e) => [...e].sort(), ge = (e) => x(new Set(Object.values(e ?? {}))), P = (e) => Object.entries(e ?? {}).map(([t, n]) => ({ rowId: t, value: n })).sort(
+  (t, n) => t.value === n.value ? t.rowId.localeCompare(n.rowId) : t.value.localeCompare(n.value)
+), Fe = (e) => P(e).map(({ rowId: t, value: n }) => ({ relationshipId: t, targetId: n })), Me = (e) => P(e).map(({ rowId: t, value: n }) => ({ membershipId: t, groupId: n })), N = (e, t, n) => {
+  const o = { ...e };
+  return n ? o[t.rowId] = t.value : delete o[t.rowId], o;
+}, ae = (e, t) => N(e, t, !0), ue = (e, t) => {
+  const n = N(e, t, !1);
+  return Object.keys(n).length === 0 ? null : n;
+}, ie = (e, t) => e?.key === t?.key && e?.rowId === t?.rowId && e?.value === t?.value, L = (e) => (t, n) => {
+  const o = t === void 0 ? null : e(t), r = n === void 0 ? null : e(n);
+  return ie(o, r) ? { remove: null, add: null } : { remove: o, add: r };
+}, Ee = L(de), Se = L(ce), M = (e, t, n) => {
+  if (n === null) {
+    const o = { ...e };
+    return delete o[t.key], o;
+  }
+  return { ...e, [t.key]: n };
+}, be = (e, t) => {
+  if (t.remove === null && t.add === null) return e;
+  let n = e;
+  return t.remove !== null && (n = M(n, t.remove, ue(n[t.remove.key], t.remove))), t.add !== null && (n = M(n, t.add, ae(n[t.add.key], t.add))), n;
+}, c = (e) => Object.keys(e.data?.fields ?? {}).map((t) => b(e.type, t)), E = (e) => e.deleted_hlc !== null, ye = (e, t) => {
+  if (e === t) return [];
+  if (e == null)
+    return t == null ? [] : c(t);
+  if (t == null) return c(e);
+  if (e.type !== t.type || E(e) !== E(t))
+    return [.../* @__PURE__ */ new Set([...c(e), ...c(t)])];
+  const n = e.data?.fields ?? {}, o = t.data?.fields ?? {}, r = [], s = /* @__PURE__ */ new Set([...Object.keys(n), ...Object.keys(o)]);
+  for (const l of s)
+    n[l] !== o[l] && r.push(b(t.type, l));
+  return r;
+}, Re = (e, t) => {
+  if (e === t || e === void 0 && t === void 0) return null;
+  const n = e === void 0 ? [] : c(e), o = t === void 0 ? [] : c(t), r = new Set(n), s = new Set(o);
+  return {
+    rowId: (t ?? e).id,
+    remove: n.filter((l) => !s.has(l)),
+    add: o.filter((l) => !r.has(l))
+  };
+}, ke = (e, t) => {
+  if (t.add.length === 0 && t.remove.length === 0) return e;
+  const n = new Map(e);
+  for (const o of t.remove) {
+    const r = n.get(o);
+    if (r === void 0) continue;
+    const s = new Set(r);
+    s.delete(t.rowId), s.size === 0 ? n.delete(o) : n.set(o, s);
+  }
+  for (const o of t.add)
+    n.set(o, /* @__PURE__ */ new Set([...n.get(o) ?? [], t.rowId]));
+  return n;
+}, Oe = (e) => {
+  const t = /* @__PURE__ */ new Map();
+  for (const n of e)
+    for (const o of c(n)) {
+      const r = t.get(o);
+      r === void 0 ? t.set(o, /* @__PURE__ */ new Set([n.id])) : r.add(n.id);
+    }
+  return t;
+}, je = (e, t) => x(e.get(t) ?? []), fe = 2, S = (e) => typeof e == "number" && Number.isInteger(e) && e >= 0, pe = (e) => typeof e == "object" && e !== null && typeof e.id == "string" && typeof e.type == "string" && typeof e.exists == "boolean" && (e.created_hlc === null || typeof e.created_hlc == "string"), Ae = (e) => {
+  if (typeof e != "object" || e === null) return !1;
+  const t = e;
+  return t.format !== fe || !S(t.position) || !S(t.revision) || !Array.isArray(t.entities) ? !1 : t.entities.every(pe);
+};
+export {
+  T as A,
+  ue as B,
+  ae as C,
+  f as M,
+  fe as R,
+  Fe as a,
+  ge as b,
+  ne as c,
+  je as d,
+  c as e,
+  D as f,
+  _e as g,
+  de as h,
+  Ae as i,
+  ce as j,
+  Oe as k,
+  Me as l,
+  te as m,
+  be as n,
+  Ee as o,
+  Se as p,
+  Re as q,
+  _ as r,
+  ke as s,
+  Z as t,
+  he as u,
+  ye as v,
+  we as w,
+  Ie as x,
+  ee as y,
+  ve as z
+};

package/dist/types/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[]>;
@@ -263,8 +279,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
@@ -364,7 +387,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;
     /**
@@ -395,6 +422,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.
@@ -445,44 +478,51 @@ interface Replica {
  * `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
@@ -494,7 +534,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;
 }
@@ -521,6 +562,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;
     /**
@@ -532,6 +585,16 @@ interface OutboxConflict {
     /** Client HLC stamped at detection. The conflict view's ordering key. */
     readonly detectedAtHlc: string;
 }
+/**
+ * The conflict payload as a row written before IndexedDB schema v10
+ * persisted it: `scope` and `remoteActions` were added at v10. The store's
+ * read path fills both in; a legacy row is still a field-scope conflict
+ * with no recorded remote context.
+ */
+interface StoredOutboxConflict extends Omit<OutboxConflict, "scope" | "remoteActions"> {
+    readonly scope?: "field" | "component" | "entity";
+    readonly remoteActions?: readonly ConflictRemoteAction[];
+}
 /**
  * One locally-authored Action awaiting acknowledgement, plus the HLC at
  * which it entered the outbox. A `conflicted` entry carries its
@@ -557,6 +620,13 @@ interface OutboxEntry {
     /** Present iff `status === "conflicted"`. */
     readonly conflict?: OutboxConflict;
 }
+/**
+ * The persisted form of an outbox entry. Identical to {@link OutboxEntry}
+ * except that a conflict payload may predate the v10 fields.
+ */
+interface StoredOutboxEntry extends Omit<OutboxEntry, "conflict"> {
+    readonly conflict?: StoredOutboxConflict;
+}
 /**
  * OutboxStore — durable buffer of pending local Actions.
  *
@@ -569,10 +639,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[]>;
@@ -618,4 +687,4 @@ interface StorageAdapter {
     reset(): Promise<void>;
 }
 
-export type { ActionLog, ConflictSide, ConflictSlot, ConflictSubjectState, CursorRecord, CursorStore, DirtyTracker, EntityStore, LoggedAction, MaterializationPolicy, MembershipLink, MembershipQuery, OutboxConflict, OutboxEntry, OutboxStatus, OutboxStore, RelationshipIndexQuery, RelationshipLink, RelationshipQuery, RelationshipSourceQuery, Replica, ReplicaChange, ReplicaOptions, ReplicaRecord, ReplicaStats, ReplicaStore, Revision, SeedMarker, StorageAdapter };
+export type { ActionLog, ConflictRemoteAction, ConflictSide, ConflictSlot, ConflictSubjectState, CursorRecord, CursorStore, DirtyTracker, EntityStore, LoggedAction, MaterializationPolicy, MembershipLink, MembershipQuery, OutboxConflict, OutboxEntry, OutboxStatus, OutboxStore, RelationshipIndexQuery, RelationshipLink, RelationshipQuery, RelationshipSourceQuery, Replica, ReplicaChange, ReplicaOptions, ReplicaRecord, ReplicaStats, ReplicaStore, Revision, SeedMarker, StorageAdapter, StoredOutboxConflict, StoredOutboxEntry };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ebbjs/storage",
-  "version": "0.3.0",
+  "version": "1.1.0",
   "private": false,
   "description": "Storage components for ebbjs",
   "homepage": "https://ebbjs.com",
@@ -44,7 +44,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@ebbjs/core": "^0.3.0"
+    "@ebbjs/core": "^1.1.0"
   },
   "devDependencies": {
     "fake-indexeddb": "^6.2.5",

package/dist/replica-record-D3lkFACh.js

@@ -1,167 +0,0 @@
-import { isFieldMap as u, mergeFieldValue as m, latestHlc as P, isFieldLeaf as D } from "@ebbjs/core";
-const L = 500, M = 64, I = /* @__PURE__ */ new WeakMap(), N = (e) => {
-  let r = 2166136261;
-  for (let t = 0; t < e.length; t += 1)
-    r ^= e.charCodeAt(t), r = Math.imul(r, 16777619) >>> 0;
-  return r >>> 0;
-}, E = (e) => N(e) % M, C = () => Array.from({ length: M }, () => ({})), R = (e, r) => {
-  let t = r;
-  const n = {
-    get map() {
-      if (t === void 0) {
-        const s = {};
-        for (const o of e) Object.assign(s, o);
-        t = s;
-      }
-      return t;
-    }
-  };
-  return I.set(n, e), n;
-}, _ = (e) => u(e) && I.has(e), H = (e) => {
-  const r = I.get(e);
-  if (r === void 0) throw new Error("not a sharded map field");
-  return r;
-}, V = (e) => e.map, W = (e) => {
-  const r = C(), t = {};
-  for (const [n, s] of Object.entries(e))
-    r[E(n)][n] = s, t[n] = s;
-  return R(r, t);
-}, b = (e) => !u(e) || _(e) ? e : Object.keys(e.map).length >= L ? W(e.map) : e, k = (e) => {
-  let r;
-  for (const [t, n] of Object.entries(e)) {
-    const s = b(n);
-    s !== n && (r === void 0 && (r = { ...e }), r[t] = s);
-  }
-  return r ?? e;
-}, K = (e) => {
-  let r;
-  for (const [t, n] of Object.entries(e))
-    !u(n) || !_(n) || (r === void 0 && (r = { ...e }), r[t] = { map: V(n) });
-  return r ?? e;
-}, Y = (e, r) => {
-  const t = H(e), n = [...t], s = /* @__PURE__ */ new Map();
-  for (const [o, d] of Object.entries(r.map)) {
-    const a = E(o), c = (s.get(a) ?? t[a])[o], F = m(c, d);
-    if (F === c) continue;
-    let i = s.get(a);
-    i === void 0 && (i = { ...t[a] }, s.set(a, i)), i[o] = F;
-  }
-  if (s.size === 0) return e;
-  for (const [o, d] of s) n[o] = d;
-  return R(n);
-}, $ = (e, r) => {
-  if (e !== void 0 && u(e) && _(e))
-    return u(r) ? Y(e, r) : r;
-  const t = m(e, r);
-  return t === e ? t : b(t);
-}, h = (e) => e.data?.fields ?? {}, de = { residentMapFields: !0 }, B = (e, r, t) => {
-  const n = h(r), s = t?.residentMapFields ? $ : m;
-  let o;
-  for (const [d, a] of Object.entries(n)) {
-    const p = o === void 0 ? e.fields[d] : o[d], c = s(p, a);
-    c !== p && (o === void 0 && (o = { ...e.fields }), o[d] = c);
-  }
-  return o === void 0 ? e : { fields: o };
-}, y = (e, r) => {
-  const t = r(e.data.fields);
-  return t === e.data.fields ? e : { ...e, data: { ...e.data, fields: t } };
-}, ae = (e) => y(e, k), ce = (e) => y(e, K), ue = (e, r, t, n, s) => {
-  switch (r.method) {
-    case "put":
-      return {
-        id: r.subject_id,
-        type: r.subject_type,
-        data: {
-          fields: s?.residentMapFields ? k(h(r)) : h(r)
-        },
-        created_hlc: n,
-        updated_hlc: n,
-        deleted_hlc: null,
-        last_gsn: t
-      };
-    case "patch":
-      return e ? e.deleted_hlc ? e : {
-        ...e,
-        data: B(e.data, r, s),
-        updated_hlc: P(e.updated_hlc, n),
-        last_gsn: Math.max(e.last_gsn, t)
-      } : null;
-    case "delete":
-      return e ? {
-        ...e,
-        deleted_hlc: n,
-        updated_hlc: n,
-        last_gsn: Math.max(e.last_gsn, t)
-      } : null;
-  }
-}, S = "relationship", f = "entityGroup", O = "groups", v = (e, r, t) => `${e}\0${r}\0${t}`, j = (e, r, t) => `
${v(e, r, t)}`, U = (e) => v(O, f, e), q = (e) => j(O, f, e), l = (e, r) => {
-  const t = e.data?.fields?.[r];
-  if (t === void 0 || !D(t)) return null;
-  const n = t.value;
-  return typeof n == "string" ? n : null;
-}, z = (e) => {
-  if (e.type !== S || e.deleted_hlc !== null) return null;
-  const r = l(e, "field"), t = l(e, "type"), n = l(e, "target_id"), s = l(e, "source_id");
-  return r === null || t === null || n === null || s === null ? null : { key: v(r, t, n), rowId: e.id, value: s };
-}, G = (e) => {
-  if (e.type !== S || e.deleted_hlc !== null) return null;
-  const r = l(e, "field"), t = l(e, "type"), n = l(e, "source_id"), s = l(e, "target_id");
-  return r === null || t === null || n === null || s === null ? null : { key: j(r, t, n), rowId: e.id, value: s };
-}, J = (e) => {
-  if (e.type !== f || e.deleted_hlc !== null) return null;
-  const r = l(e, "group_id"), t = l(e, "entity_id");
-  return r === null || t === null ? null : { key: U(r), rowId: e.id, value: t };
-}, Q = (e) => {
-  if (e.type !== f || e.deleted_hlc !== null) return null;
-  const r = l(e, "group_id"), t = l(e, "entity_id");
-  return r === null || t === null ? null : { key: q(t), rowId: e.id, value: r };
-}, X = (e) => z(e) ?? J(e), Z = (e) => G(e) ?? Q(e), ee = (e) => [...e].sort(), ie = (e) => ee(new Set(Object.values(e ?? {}))), x = (e) => Object.entries(e ?? {}).map(([r, t]) => ({ rowId: r, value: t })).sort(
-  (r, t) => r.value === t.value ? r.rowId.localeCompare(t.rowId) : r.value.localeCompare(t.value)
-), fe = (e) => x(e).map(({ rowId: r, value: t }) => ({ relationshipId: r, targetId: t })), pe = (e) => x(e).map(({ rowId: r, value: t }) => ({ membershipId: r, groupId: t })), A = (e, r, t) => {
-  const n = { ...e };
-  return t ? n[r.rowId] = r.value : delete n[r.rowId], n;
-}, re = (e, r) => A(e, r, !0), te = (e, r) => {
-  const t = A(e, r, !1);
-  return Object.keys(t).length === 0 ? null : t;
-}, ne = (e, r) => e?.key === r?.key && e?.rowId === r?.rowId && e?.value === r?.value, T = (e) => (r, t) => {
-  const n = r === void 0 ? null : e(r), s = t === void 0 ? null : e(t);
-  return ne(n, s) ? { remove: null, add: null } : { remove: n, add: s };
-}, he = T(X), me = T(Z), w = (e, r, t) => {
-  if (t === null) {
-    const n = { ...e };
-    return delete n[r.key], n;
-  }
-  return { ...e, [r.key]: t };
-}, Ie = (e, r) => {
-  if (r.remove === null && r.add === null) return e;
-  let t = e;
-  return r.remove !== null && (t = w(t, r.remove, te(t[r.remove.key], r.remove))), r.add !== null && (t = w(t, r.add, re(t[r.add.key], r.add))), t;
-}, se = 1, g = (e) => typeof e == "number" && Number.isInteger(e) && e >= 0, oe = (e) => typeof e == "object" && e !== null && typeof e.id == "string" && typeof e.type == "string", _e = (e) => {
-  if (typeof e != "object" || e === null) return !1;
-  const r = e;
-  return r.format !== se || !g(r.position) || !g(r.revision) || !Array.isArray(r.entities) ? !1 : r.entities.every(oe);
-};
-export {
-  f as M,
-  se as R,
-  fe as a,
-  ie as b,
-  q as c,
-  ae as d,
-  X as e,
-  j as f,
-  Z as g,
-  Ie as h,
-  _e as i,
-  he as j,
-  me as k,
-  pe as l,
-  U as m,
-  ue as n,
-  de as o,
-  S as p,
-  te as q,
-  v as r,
-  re as s,
-  ce as w
-};