@sovereignbase/convergent-replicated-struct 1.0.1 → 1.1.0

package/dist/index.js

@@ -15,276 +15,399 @@
  */
 
 
-// src/OOStruct/class.ts
+// src/.helpers/overwriteAndReturnSnapshotEntry/index.ts
 import { v7 as uuidv7 } from "uuid";
+function overwriteAndReturnSnapshotEntry(key, value, crStructReplica) {
+  const target = crStructReplica.entries[key];
+  const oldUuidv7 = target.uuidv7;
+  target.uuidv7 = uuidv7();
+  target.value = value;
+  target.predecessor = oldUuidv7;
+  target.tombstones.add(oldUuidv7);
+  return parseStateEntryToSnapshotEntry(target);
+}
 
-// src/.errors/class.ts
-var OOStructError = class extends Error {
-  /**
-   * The semantic error code for the failure.
-   */
-  code;
-  /**
-   * Creates a typed OO-Struct error.
-   *
-   * @param code - The semantic error code.
-   * @param message - An optional human-readable detail message.
-   */
-  constructor(code, message) {
-    const detail = message ?? code;
-    super(`{@sovereignbase/observed-overwrite-struct} ${detail}`);
-    this.code = code;
-    this.name = "OOStructError";
-  }
-};
-
-// src/OOStruct/parseSnapshotEntryToStateEntry/index.ts
+// src/.helpers/parseSnapshotEntryToStateEntry/index.ts
 import { isUuidV7, prototype, safeStructuredClone } from "@sovereignbase/utils";
 function parseSnapshotEntryToStateEntry(defaultValue, snapshotEntry) {
-  if (prototype(snapshotEntry) !== "record" || !Object.hasOwn(snapshotEntry, "__value") || !isUuidV7(snapshotEntry.__uuidv7) || !isUuidV7(snapshotEntry.__after) || !Array.isArray(snapshotEntry.__overwrites))
+  if (prototype(snapshotEntry) !== "record" || !Object.hasOwn(snapshotEntry, "value") || !isUuidV7(snapshotEntry.uuidv7) || !isUuidV7(snapshotEntry.predecessor) || !Array.isArray(snapshotEntry.tombstones))
     return false;
-  const [cloned, copiedValue] = safeStructuredClone(snapshotEntry.__value);
+  const [cloned, copiedValue] = safeStructuredClone(snapshotEntry.value);
   if (!cloned || prototype(copiedValue) !== prototype(defaultValue))
     return false;
-  const overwrites = /* @__PURE__ */ new Set([]);
-  for (const overwrite of snapshotEntry.__overwrites) {
-    if (!isUuidV7(overwrite) || overwrite === snapshotEntry.__uuidv7)
+  const tombstones = /* @__PURE__ */ new Set([]);
+  for (const overwrite of snapshotEntry.tombstones) {
+    if (!isUuidV7(overwrite) || overwrite === snapshotEntry.uuidv7)
       continue;
-    overwrites.add(overwrite);
+    tombstones.add(overwrite);
   }
-  if (!overwrites.has(snapshotEntry.__after)) return false;
+  if (!tombstones.has(snapshotEntry.predecessor)) return false;
   return {
-    __uuidv7: snapshotEntry.__uuidv7,
-    __value: copiedValue,
-    __after: snapshotEntry.__after,
-    __overwrites: overwrites
+    uuidv7: snapshotEntry.uuidv7,
+    value: copiedValue,
+    predecessor: snapshotEntry.predecessor,
+    tombstones
   };
 }
 
-// src/OOStruct/parseStateEntryToSnapshotEntry/index.ts
+// src/.helpers/parseStateEntryToSnapshotEntry/index.ts
 function parseStateEntryToSnapshotEntry(stateEntry) {
   return {
-    __uuidv7: stateEntry.__uuidv7,
-    __value: structuredClone(stateEntry.__value),
-    __after: stateEntry.__after,
-    __overwrites: Array.from(stateEntry.__overwrites)
+    uuidv7: stateEntry.uuidv7,
+    value: structuredClone(stateEntry.value),
+    predecessor: stateEntry.predecessor,
+    tombstones: Array.from(stateEntry.tombstones)
   };
 }
 
-// src/OOStruct/class.ts
-import { isUuidV7 as isUuidV72, prototype as prototype2, safeStructuredClone as safeStructuredClone2 } from "@sovereignbase/utils";
-var OOStruct = class _OOStruct {
-  __eventTarget = new EventTarget();
-  __defaults;
-  __state;
-  __live;
-  /**
-   * Creates a replica from default values and an optional snapshot.
-   *
-   * @param defaults - The default field values that define the struct shape.
-   * @param snapshot - An optional serialized snapshot used for hydration.
-   * @throws {OOStructError} Thrown when the default values are not supported by `structuredClone`.
-   */
-  constructor(defaults, snapshot) {
-    const [cloned, copiedDefaults] = safeStructuredClone2(defaults);
-    if (!cloned)
-      throw new OOStructError(
-        "DEFAULTS_NOT_CLONEABLE",
-        "Default values must be supported by structuredClone."
-      );
-    this.__defaults = copiedDefaults;
-    this.__state = {};
-    this.__live = {};
-    const snapshotIsObject = snapshot && prototype2(snapshot) === "record";
-    for (const key of Object.keys(this.__defaults)) {
-      const defaultValue = this.__defaults[key];
-      if (snapshotIsObject && Object.hasOwn(snapshot, key)) {
-        const valid = parseSnapshotEntryToStateEntry(
-          defaultValue,
-          snapshot[key]
+// src/core/mags/merge/index.ts
+function __merge(crStructDelta, crStructReplica) {
+  if (!crStructDelta || typeof crStructDelta !== "object" || Array.isArray(crStructDelta))
+    return false;
+  const delta = {};
+  const change = {};
+  let hasDelta = false;
+  let hasChange = false;
+  for (const [key, value] of Object.entries(crStructDelta)) {
+    if (!Object.hasOwn(crStructReplica.defaults, key)) continue;
+    const candidate = parseSnapshotEntryToStateEntry(
+      crStructReplica.defaults[key],
+      value
+    );
+    if (!candidate) continue;
+    const target = crStructReplica.entries[key];
+    const current = { ...target };
+    let frontier = "";
+    for (const overwrite of target.tombstones) {
+      if (frontier < overwrite) frontier = overwrite;
+    }
+    for (const overwrite of candidate.tombstones) {
+      if (overwrite <= frontier || target.tombstones.has(overwrite)) continue;
+      target.tombstones.add(overwrite);
+    }
+    if (target.tombstones.has(candidate.uuidv7)) continue;
+    if (current.uuidv7 === candidate.uuidv7) {
+      if (current.predecessor < candidate.predecessor) {
+        target.value = candidate.value;
+        target.predecessor = candidate.predecessor;
+        target.tombstones.add(candidate.predecessor);
+        change[key] = structuredClone(candidate.value);
+        hasChange = true;
+      } else {
+        delta[key] = overwriteAndReturnSnapshotEntry(
+          key,
+          current.value,
+          crStructReplica
         );
-        if (valid) {
-          this.__live[key] = valid.__value;
-          this.__state[key] = valid;
-          continue;
-        }
+        hasDelta = true;
       }
-      this.__live[key] = defaultValue;
-      const root = uuidv7();
-      this.__state[key] = {
-        __uuidv7: uuidv7(),
-        __after: root,
-        __value: defaultValue,
-        __overwrites: /* @__PURE__ */ new Set([root])
-      };
+      continue;
+    }
+    if (current.uuidv7 === candidate.predecessor || target.tombstones.has(current.uuidv7) || candidate.uuidv7 > current.uuidv7) {
+      target.uuidv7 = candidate.uuidv7;
+      target.value = candidate.value;
+      target.predecessor = candidate.predecessor;
+      target.tombstones.add(candidate.predecessor);
+      target.tombstones.add(current.uuidv7);
+      change[key] = structuredClone(candidate.value);
+      hasChange = true;
+      continue;
     }
+    target.tombstones.add(candidate.uuidv7);
+    delta[key] = parseStateEntryToSnapshotEntry(target);
+    hasDelta = true;
   }
-  /**CRUD*/
-  /**
-   * Creates a new replica.
-   *
-   * @param defaults - The default field values that define the struct shape.
-   * @param snapshot - An optional serialized snapshot used for hydration.
-   * @returns A new OO-Struct replica.
-   */
-  static create(defaults, snapshot) {
-    return new _OOStruct(defaults, snapshot);
+  if (!hasDelta && !hasChange) return false;
+  return { change, delta };
+}
+
+// src/core/mags/acknowledge/index.ts
+function __acknowledge(crStructReplica) {
+  const ack = {};
+  for (const [key, value] of Object.entries(crStructReplica.entries)) {
+    let max = "";
+    for (const tombstone of value.tombstones) {
+      if (max < tombstone) max = tombstone;
+    }
+    ack[key] = max;
   }
-  /**
-   * Reads the current value of a field.
-   *
-   * @param key - The field key to read.
-   * @returns A cloned copy of the field's current value.
-   */
-  read(key) {
-    return structuredClone(this.__live[key]);
+  return ack;
+}
+
+// src/core/mags/garbageCollect/index.ts
+import { isUuidV7 as isUuidV72 } from "@sovereignbase/utils";
+function __garbageCollect(frontiers, crStructReplica) {
+  if (!Array.isArray(frontiers) || frontiers.length < 1) return;
+  const smallestAcknowledgementsPerKey = {};
+  for (const frontier of frontiers) {
+    for (const [key, value] of Object.entries(frontier)) {
+      if (!Object.hasOwn(crStructReplica.entries, key) || !isUuidV72(value))
+        continue;
+      const current = smallestAcknowledgementsPerKey[key];
+      if (typeof current === "string" && current <= value) continue;
+      smallestAcknowledgementsPerKey[key] = value;
+    }
   }
-  /**
-   * Overwrites a field with a new value.
-   *
-   * @param key - The field key to overwrite.
-   * @param value - The next value for the field.
-   * @throws {OOStructError} Thrown when the value is not supported by `structuredClone`.
-   * @throws {OOStructError} Thrown when the value runtime type does not match the default value runtime type.
-   */
-  update(key, value) {
-    const [cloned, copiedValue] = safeStructuredClone2(value);
-    if (!cloned)
-      throw new OOStructError(
-        "VALUE_NOT_CLONEABLE",
-        "Updated values must be supported by structuredClone."
-      );
-    if (prototype2(copiedValue) !== prototype2(this.__defaults[key]))
-      throw new OOStructError(
-        "VALUE_TYPE_MISMATCH",
-        "Updated value must match the default value runtime type."
-      );
-    const delta = {};
-    const change = {};
-    delta[key] = this.overwriteAndReturnSnapshotEntry(key, copiedValue);
-    change[key] = structuredClone(copiedValue);
-    this.__eventTarget.dispatchEvent(
-      new CustomEvent("delta", { detail: delta })
-    );
-    this.__eventTarget.dispatchEvent(
-      new CustomEvent("change", { detail: change })
+  for (const [key, value] of Object.entries(smallestAcknowledgementsPerKey)) {
+    const target = crStructReplica.entries[key];
+    const smallest = value;
+    for (const uuidv73 of target.tombstones) {
+      if (uuidv73 === target.predecessor || uuidv73 > smallest) continue;
+      target.tombstones.delete(uuidv73);
+    }
+  }
+}
+
+// src/core/mags/snapshot/index.ts
+function __snapshot(crStructReplica) {
+  const snapshot = {};
+  for (const [key, value] of Object.entries(crStructReplica.entries)) {
+    snapshot[key] = parseStateEntryToSnapshotEntry(
+      value
     );
   }
+  return snapshot;
+}
+
+// src/core/crud/create/index.ts
+import { safeStructuredClone as safeStructuredClone2, prototype as prototype2 } from "@sovereignbase/utils";
+
+// src/.errors/class.ts
+var CRStructError = class extends Error {
+  /**
+   * The semantic error code for the failure.
+   */
+  code;
   /**
-   * Resets one field or the entire struct back to default values.
+   * Creates a typed CR-Struct error.
    *
-   * @param key - The optional field key to reset. When omitted, every field is reset.
+   * @param code - The semantic error code.
+   * @param message - An optional human-readable detail message.
    */
-  delete(key) {
-    const delta = {};
-    const change = {};
-    if (key !== void 0) {
-      if (!Object.hasOwn(this.__defaults, key)) return;
-      const value = this.__defaults[key];
-      delta[key] = this.overwriteAndReturnSnapshotEntry(key, value);
-      change[key] = structuredClone(value);
-    } else {
-      for (const [key2, value] of Object.entries(this.__defaults)) {
-        delta[key2] = this.overwriteAndReturnSnapshotEntry(
-          key2,
-          value
-        );
-        change[key2] = structuredClone(value);
+  constructor(code, message) {
+    const detail = message ?? code;
+    super(`{@sovereignbase/convergent-replicated-struct} ${detail}`);
+    this.code = code;
+    this.name = "CRStructError";
+  }
+};
+
+// src/core/crud/create/index.ts
+import { v7 as uuidv72 } from "uuid";
+function __create(defaults, snapshot) {
+  const [cloned, copiedDefaults] = safeStructuredClone2(defaults);
+  if (!cloned)
+    throw new CRStructError(
+      "DEFAULTS_NOT_CLONEABLE",
+      "Default values must be supported by structuredClone."
+    );
+  const state = {
+    entries: {},
+    defaults: copiedDefaults
+  };
+  const snapshotIsObject = snapshot && prototype2(snapshot) === "record";
+  for (const key of Object.keys(defaults)) {
+    const defaultValue = copiedDefaults[key];
+    if (snapshotIsObject && Object.hasOwn(snapshot, key)) {
+      const valid = parseSnapshotEntryToStateEntry(
+        defaultValue,
+        snapshot[key]
+      );
+      if (valid) {
+        state.entries[key] = valid;
+        continue;
       }
     }
-    this.__eventTarget.dispatchEvent(
-      new CustomEvent("delta", { detail: delta })
+    const root = uuidv72();
+    state.entries[key] = {
+      uuidv7: uuidv72(),
+      predecessor: root,
+      value: defaultValue,
+      tombstones: /* @__PURE__ */ new Set([root])
+    };
+  }
+  return state;
+}
+
+// src/core/crud/read/index.ts
+function __read(key, crStructReplica) {
+  return structuredClone(crStructReplica.entries[key].value);
+}
+
+// src/core/crud/update/index.ts
+import { safeStructuredClone as safeStructuredClone3, prototype as prototype3 } from "@sovereignbase/utils";
+function __update(key, value, crStructReplica) {
+  const [cloned, copiedValue] = safeStructuredClone3(value);
+  if (!cloned)
+    throw new CRStructError(
+      "VALUE_NOT_CLONEABLE",
+      "Updated values must be supported by structuredClone."
     );
-    this.__eventTarget.dispatchEvent(
-      new CustomEvent("change", { detail: change })
+  if (prototype3(copiedValue) !== prototype3(crStructReplica.defaults[key]))
+    throw new CRStructError(
+      "VALUE_TYPE_MISMATCH",
+      "Updated value must match the default value runtime type."
     );
+  const delta = {};
+  const change = {};
+  delta[key] = overwriteAndReturnSnapshotEntry(
+    key,
+    copiedValue,
+    crStructReplica
+  );
+  change[key] = structuredClone(copiedValue);
+  return { change, delta };
+}
+
+// src/core/crud/delete/index.ts
+function __delete(crStructReplica, key) {
+  const delta = {};
+  const change = {};
+  if (key !== void 0) {
+    if (!Object.hasOwn(crStructReplica.defaults, key)) return false;
+    const value = crStructReplica.defaults[key];
+    delta[key] = overwriteAndReturnSnapshotEntry(key, value, crStructReplica);
+    change[key] = structuredClone(value);
+  } else {
+    for (const [key2, value] of Object.entries(crStructReplica.defaults)) {
+      delta[key2] = overwriteAndReturnSnapshotEntry(
+        key2,
+        value,
+        crStructReplica
+      );
+      change[key2] = structuredClone(value);
+    }
   }
-  /**MAGS*/
+  return { change, delta };
+}
+
+// src/CRStruct/class.ts
+var CRStructRaw = class {
   /**
-   * Merges an incoming delta into the current replica.
+   * Creates a replica from default values and an optional snapshot.
+   *
+   * The struct shape is fixed by the provided default values. The returned
+   * proxy exposes those fields as direct properties on the instance.
    *
-   * @param replica - The incoming partial snapshot projection to merge.
+   * @param defaults - The default field values that define the struct shape.
+   * @param snapshot - An optional serialized snapshot used to hydrate the replica.
+   * @throws {CRStructError} Thrown when the default values are not supported by `structuredClone`.
    */
-  merge(replica) {
-    if (!replica || typeof replica !== "object" || Array.isArray(replica))
-      return;
-    const delta = {};
-    const change = {};
-    let hasDelta = false;
-    let hasChange = false;
-    for (const [key, value] of Object.entries(replica)) {
-      if (!Object.hasOwn(this.__state, key)) continue;
-      const candidate = parseSnapshotEntryToStateEntry(
-        this.__defaults[key],
-        value
-      );
-      if (!candidate) continue;
-      const target = this.__state[key];
-      const current = { ...target };
-      let frontier = "";
-      for (const overwrite of target.__overwrites) {
-        if (frontier < overwrite) frontier = overwrite;
-      }
-      for (const overwrite of candidate.__overwrites) {
-        if (overwrite <= frontier || target.__overwrites.has(overwrite))
-          continue;
-        target.__overwrites.add(overwrite);
+  constructor(defaults, snapshot) {
+    Object.defineProperties(this, {
+      state: {
+        value: __create(defaults, snapshot),
+        enumerable: false,
+        configurable: false,
+        writable: false
+      },
+      eventTarget: {
+        value: new EventTarget(),
+        enumerable: false,
+        configurable: false,
+        writable: false
       }
-      if (target.__overwrites.has(candidate.__uuidv7)) continue;
-      if (current.__uuidv7 === candidate.__uuidv7) {
-        if (current.__after < candidate.__after) {
-          target.__value = candidate.__value;
-          target.__after = candidate.__after;
-          target.__overwrites.add(candidate.__after);
-          this.__live[key] = candidate.__value;
-          change[key] = structuredClone(candidate.__value);
-          hasChange = true;
-        } else {
-          delta[key] = this.overwriteAndReturnSnapshotEntry(
-            key,
-            current.__value
-          );
-          hasDelta = true;
+    });
+    const keys = new Set(Object.keys(defaults));
+    return new Proxy(this, {
+      get(target, key, receiver) {
+        if (typeof key !== "string" || !keys.has(key))
+          return Reflect.get(target, key, receiver);
+        return __read(key, target.state);
+      },
+      has(target, key) {
+        if (typeof key !== "string" || !keys.has(key))
+          return Reflect.has(target, key);
+        return true;
+      },
+      set(target, key, value) {
+        if (typeof key !== "string" || !keys.has(key)) return false;
+        try {
+          const result = __update(key, value, target.state);
+          if (!result) return false;
+          const { delta, change } = result;
+          if (delta)
+            void target.eventTarget.dispatchEvent(
+              new CustomEvent("delta", { detail: delta })
+            );
+          if (change)
+            void target.eventTarget.dispatchEvent(
+              new CustomEvent("change", { detail: change })
+            );
+          return true;
+        } catch {
+          return false;
         }
-        continue;
-      }
-      if (current.__uuidv7 === candidate.__after || target.__overwrites.has(current.__uuidv7) || candidate.__uuidv7 > current.__uuidv7) {
-        target.__uuidv7 = candidate.__uuidv7;
-        target.__value = candidate.__value;
-        target.__after = candidate.__after;
-        target.__overwrites.add(candidate.__after);
-        target.__overwrites.add(current.__uuidv7);
-        this.__live[key] = candidate.__value;
-        change[key] = structuredClone(candidate.__value);
-        hasChange = true;
-        continue;
+      },
+      deleteProperty(target, key) {
+        if (typeof key !== "string" || !keys.has(key)) return false;
+        try {
+          const result = __delete(target.state, key);
+          if (!result) return false;
+          const { delta, change } = result;
+          if (delta) {
+            void target.eventTarget.dispatchEvent(
+              new CustomEvent("delta", { detail: delta })
+            );
+          }
+          if (change) {
+            void target.eventTarget.dispatchEvent(
+              new CustomEvent("change", { detail: change })
+            );
+          }
+          return true;
+        } catch {
+          return false;
+        }
+      },
+      ownKeys(target) {
+        return [
+          ...Reflect.ownKeys(target),
+          ...Reflect.ownKeys(target.state.defaults)
+        ];
+      },
+      getOwnPropertyDescriptor(target, key) {
+        if (typeof key !== "string" || !keys.has(key))
+          return Reflect.getOwnPropertyDescriptor(target, key);
+        return {
+          value: __read(key, target.state),
+          writable: true,
+          enumerable: true,
+          configurable: true
+        };
       }
-      target.__overwrites.add(candidate.__uuidv7);
-      delta[key] = parseStateEntryToSnapshotEntry(target);
-      hasDelta = true;
-    }
-    if (hasDelta)
-      this.__eventTarget.dispatchEvent(
+    });
+  }
+  /**
+   * Applies a remote or local delta to the replica state.
+   *
+   * @param crStructDelta - The partial serialized field state to merge.
+   */
+  merge(crStructDelta) {
+    const result = __merge(crStructDelta, this.state);
+    if (!result) return;
+    const { delta, change } = result;
+    if (delta) {
+      void this.eventTarget.dispatchEvent(
         new CustomEvent("delta", { detail: delta })
       );
-    if (hasChange)
-      this.__eventTarget.dispatchEvent(
+    }
+    if (change) {
+      void this.eventTarget.dispatchEvent(
         new CustomEvent("change", { detail: change })
       );
+    }
   }
   /**
    * Emits the current acknowledgement frontier for each field.
    */
   acknowledge() {
-    const ack = {};
-    for (const [key, value] of Object.entries(this.__state)) {
-      let max = "";
-      for (const overwrite of value.__overwrites) {
-        if (max < overwrite) max = overwrite;
-      }
-      ack[key] = max;
+    const ack = __acknowledge(this.state);
+    if (ack) {
+      void this.eventTarget.dispatchEvent(
+        new CustomEvent("ack", { detail: ack })
+      );
     }
-    this.__eventTarget.dispatchEvent(new CustomEvent("ack", { detail: ack }));
   }
   /**
    * Removes overwritten identifiers that every provided frontier has acknowledged.
@@ -292,47 +415,57 @@ var OOStruct = class _OOStruct {
    * @param frontiers - A collection of acknowledgement frontiers to compact against.
    */
   garbageCollect(frontiers) {
-    if (!Array.isArray(frontiers) || frontiers.length < 1) return;
-    const smallestAcknowledgementsPerKey = {};
-    for (const frontier of frontiers) {
-      for (const [key, value] of Object.entries(frontier)) {
-        if (!Object.hasOwn(this.__state, key) || !isUuidV72(value)) continue;
-        const current = smallestAcknowledgementsPerKey[key];
-        if (typeof current === "string" && current <= value) continue;
-        smallestAcknowledgementsPerKey[key] = value;
-      }
-    }
-    for (const [key, value] of Object.entries(smallestAcknowledgementsPerKey)) {
-      const target = this.__state[key];
-      const smallest = value;
-      for (const uuidv72 of target.__overwrites) {
-        if (uuidv72 === target.__after || uuidv72 > smallest) continue;
-        target.__overwrites.delete(uuidv72);
-      }
-    }
+    void __garbageCollect(frontiers, this.state);
   }
   /**
    * Emits a serialized snapshot of the current replica state.
    */
   snapshot() {
-    const snapshot = {};
-    for (const [key, value] of Object.entries(this.__state)) {
-      snapshot[key] = parseStateEntryToSnapshotEntry(
-        value
+    const snapshot = __snapshot(this.state);
+    if (snapshot) {
+      void this.eventTarget.dispatchEvent(
+        new CustomEvent("snapshot", { detail: snapshot })
       );
     }
-    this.__eventTarget.dispatchEvent(
-      new CustomEvent("snapshot", { detail: snapshot })
-    );
   }
-  /**ADDITIONAL*/
   /**
    * Returns the struct field keys.
    *
    * @returns The field keys in the current replica.
    */
   keys() {
-    return Object.keys(this.__live);
+    return Object.keys(this.state.entries);
+  }
+  /**
+   * Resets every field in the replica back to its default value.
+   */
+  clear() {
+    const result = __delete(this.state);
+    if (result) {
+      const { delta, change } = result;
+      if (delta) {
+        void this.eventTarget.dispatchEvent(
+          new CustomEvent("delta", { detail: delta })
+        );
+      }
+      if (change) {
+        void this.eventTarget.dispatchEvent(
+          new CustomEvent("change", { detail: change })
+        );
+      }
+    }
+  }
+  /**
+   * Returns a cloned plain object view of the current replica fields.
+   *
+   * @returns The current field values keyed by field name.
+   */
+  clone() {
+    const out = {};
+    for (const [key, entry] of Object.entries(this.state.entries)) {
+      out[key] = structuredClone(entry.value);
+    }
+    return out;
   }
   /**
    * Returns cloned copies of the current field values.
@@ -340,8 +473,8 @@ var OOStruct = class _OOStruct {
    * @returns The current field values.
    */
   values() {
-    return Object.values(this.__live).map(
-      (value) => structuredClone(value)
+    return Object.values(this.state.entries).map(
+      (entry) => structuredClone(entry.value)
     );
   }
   /**
@@ -350,12 +483,45 @@ var OOStruct = class _OOStruct {
    * @returns The current field entries.
    */
   entries() {
-    return Object.entries(this.__live).map(([key, value]) => [
+    return Object.entries(this.state.entries).map(([key, entry]) => [
       key,
-      structuredClone(value)
+      structuredClone(entry.value)
     ]);
   }
-  /**EVENTS*/
+  /**
+   * Returns a serializable snapshot representation of this replica.
+   *
+   * Called automatically by `JSON.stringify`.
+   */
+  toJSON() {
+    return __snapshot(this.state);
+  }
+  /**
+   * Returns this replica as a JSON string.
+   */
+  toString() {
+    return JSON.stringify(this);
+  }
+  /**
+   * Returns the Node.js console inspection representation.
+   */
+  [/* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom")]() {
+    return this.toJSON();
+  }
+  /**
+   * Returns the Deno console inspection representation.
+   */
+  [/* @__PURE__ */ Symbol.for("Deno.customInspect")]() {
+    return this.toJSON();
+  }
+  /**
+   * Iterates over the current live field entries.
+   */
+  *[Symbol.iterator]() {
+    for (const [key, entry] of Object.entries(this.state.entries)) {
+      yield [key, structuredClone(entry.value)];
+    }
+  }
   /**
    * Registers an event listener.
    *
@@ -364,7 +530,7 @@ var OOStruct = class _OOStruct {
    * @param options - Listener registration options.
    */
   addEventListener(type, listener, options) {
-    this.__eventTarget.addEventListener(
+    this.eventTarget.addEventListener(
       type,
       listener,
       options
@@ -378,32 +544,23 @@ var OOStruct = class _OOStruct {
    * @param options - Listener removal options.
    */
   removeEventListener(type, listener, options) {
-    this.__eventTarget.removeEventListener(
+    this.eventTarget.removeEventListener(
       type,
       listener,
       options
     );
   }
-  /**HELPERS*/
-  /**
-   * Overwrites a field and returns the serialized delta entry for that overwrite.
-   *
-   * @param key - The field key to overwrite.
-   * @param value - The next value for the field.
-   * @returns The serialized snapshot entry for the new winning value.
-   */
-  overwriteAndReturnSnapshotEntry(key, value) {
-    const target = this.__state[key];
-    const old = { ...target };
-    target.__uuidv7 = uuidv7();
-    target.__value = value;
-    target.__after = old.__uuidv7;
-    target.__overwrites.add(old.__uuidv7);
-    this.__live[key] = value;
-    return parseStateEntryToSnapshotEntry(target);
-  }
 };
+var CRStruct = CRStructRaw;
 export {
-  OOStruct
+  CRStruct,
+  __acknowledge,
+  __create,
+  __delete,
+  __garbageCollect,
+  __merge,
+  __read,
+  __snapshot,
+  __update
 };
 //# sourceMappingURL=index.js.map