@loro-extended/change 0.2.0

package/dist/index.js

@@ -0,0 +1,1491 @@
+// src/change.ts
+import { LoroDoc } from "loro-crdt";
+
+// src/draft-nodes/base.ts
+var DraftNode = class {
+  constructor(_params) {
+    this._params = _params;
+  }
+  _cachedContainer;
+  get shape() {
+    return this._params.shape;
+  }
+  get emptyState() {
+    return this._params.emptyState;
+  }
+  get container() {
+    if (!this._cachedContainer) {
+      const container = this._params.getContainer();
+      this._cachedContainer = container;
+      return container;
+    }
+    return this._cachedContainer;
+  }
+};
+
+// src/draft-nodes/counter.ts
+var CounterDraftNode = class extends DraftNode {
+  absorbPlainValues() {
+  }
+  increment(value) {
+    this.container.increment(value);
+  }
+  decrement(value) {
+    this.container.decrement(value);
+  }
+  get value() {
+    return this.container.value;
+  }
+};
+
+// src/conversion.ts
+import {
+  LoroCounter,
+  LoroList,
+  LoroMap,
+  LoroMovableList,
+  LoroText
+} from "loro-crdt";
+
+// src/utils/type-guards.ts
+import { isContainer, isContainerId } from "loro-crdt";
+function isContainerShape(schema) {
+  return schema._type && schema._type !== "value";
+}
+function isValueShape(schema) {
+  return schema._type === "value" && [
+    "string",
+    "number",
+    "boolean",
+    "null",
+    "undefined",
+    "uint8array",
+    "object",
+    "record",
+    "array"
+  ].includes(schema.valueType);
+}
+function isObjectValue(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Uint8Array);
+}
+
+// src/conversion.ts
+function convertTextInput(value) {
+  const text = new LoroText();
+  if (value.length > 0) {
+    text.insert(0, value);
+  }
+  return text;
+}
+function convertCounterInput(value) {
+  const counter = new LoroCounter();
+  counter.increment(value);
+  return counter;
+}
+function convertListInput(value, shape) {
+  if (!isContainerShape(shape)) {
+    return value;
+  }
+  const list = new LoroList();
+  for (const item of value) {
+    const convertedItem = convertInputToNode(item, shape.shape);
+    if (isContainer(convertedItem)) {
+      list.pushContainer(convertedItem);
+    } else {
+      list.push(convertedItem);
+    }
+  }
+  return list;
+}
+function convertMovableListInput(value, shape) {
+  if (!isContainerShape(shape)) {
+    return value;
+  }
+  const list = new LoroMovableList();
+  for (const item of value) {
+    const convertedItem = convertInputToNode(item, shape.shape);
+    if (isContainer(convertedItem)) {
+      list.pushContainer(convertedItem);
+    } else {
+      list.push(convertedItem);
+    }
+  }
+  return list;
+}
+function convertMapInput(value, shape) {
+  if (!isContainerShape(shape)) {
+    return value;
+  }
+  const map = new LoroMap();
+  for (const [k, v] of Object.entries(value)) {
+    const nestedSchema = shape.shapes[k];
+    if (nestedSchema) {
+      const convertedValue = convertInputToNode(v, nestedSchema);
+      if (isContainer(convertedValue)) {
+        map.setContainer(k, convertedValue);
+      } else {
+        map.set(k, convertedValue);
+      }
+    } else {
+      map.set(k, value);
+    }
+  }
+  return map;
+}
+function convertRecordInput(value, shape) {
+  if (!isContainerShape(shape)) {
+    return value;
+  }
+  const map = new LoroMap();
+  for (const [k, v] of Object.entries(value)) {
+    const convertedValue = convertInputToNode(v, shape.shape);
+    if (isContainer(convertedValue)) {
+      map.setContainer(k, convertedValue);
+    } else {
+      map.set(k, convertedValue);
+    }
+  }
+  return map;
+}
+function convertInputToNode(value, shape) {
+  switch (shape._type) {
+    case "text": {
+      if (typeof value !== "string") {
+        throw new Error("string expected");
+      }
+      return convertTextInput(value);
+    }
+    case "counter": {
+      if (typeof value !== "number") {
+        throw new Error("number expected");
+      }
+      return convertCounterInput(value);
+    }
+    case "list": {
+      if (!Array.isArray(value)) {
+        throw new Error("array expected");
+      }
+      return convertListInput(value, shape);
+    }
+    case "movableList": {
+      if (!Array.isArray(value)) {
+        throw new Error("array expected");
+      }
+      return convertMovableListInput(value, shape);
+    }
+    case "map": {
+      if (!isObjectValue(value)) {
+        throw new Error("object expected");
+      }
+      return convertMapInput(value, shape);
+    }
+    case "record": {
+      if (!isObjectValue(value)) {
+        throw new Error("object expected");
+      }
+      return convertRecordInput(value, shape);
+    }
+    case "value": {
+      if (!isValueShape(shape)) {
+        throw new Error("value expected");
+      }
+      return value;
+    }
+    case "tree":
+      throw new Error("tree type unimplemented");
+    default:
+      throw new Error(`unexpected type: ${shape._type}`);
+  }
+}
+
+// src/draft-nodes/list-base.ts
+var ListDraftNodeBase = class extends DraftNode {
+  // Cache for items returned by array methods to track mutations
+  itemCache = /* @__PURE__ */ new Map();
+  get container() {
+    return super.container;
+  }
+  get shape() {
+    return super.shape;
+  }
+  absorbPlainValues() {
+    for (const [index, cachedItem] of this.itemCache.entries()) {
+      if (cachedItem) {
+        if (isValueShape(this.shape.shape)) {
+          this.absorbValueAtIndex(index, cachedItem);
+        } else {
+          if (cachedItem && typeof cachedItem === "object" && "absorbPlainValues" in cachedItem) {
+            ;
+            cachedItem.absorbPlainValues();
+          }
+        }
+      }
+    }
+    this.itemCache.clear();
+  }
+  insertWithConversion(index, item) {
+    const convertedItem = convertInputToNode(item, this.shape.shape);
+    if (isContainer(convertedItem)) {
+      this.container.insertContainer(index, convertedItem);
+    } else {
+      this.container.insert(index, convertedItem);
+    }
+  }
+  pushWithConversion(item) {
+    const convertedItem = convertInputToNode(item, this.shape.shape);
+    if (isContainer(convertedItem)) {
+      this.container.pushContainer(convertedItem);
+    } else {
+      this.container.push(convertedItem);
+    }
+  }
+  getDraftNodeParams(index, shape) {
+    return {
+      shape,
+      emptyState: void 0,
+      // List items don't have empty state
+      getContainer: () => {
+        const containerItem = this.container.get(index);
+        if (!containerItem || !isContainer(containerItem)) {
+          throw new Error(`No container found at index ${index}`);
+        }
+        return containerItem;
+      }
+    };
+  }
+  // Get item for predicate functions - always returns plain Item for filtering logic
+  getPredicateItem(index) {
+    const cachedItem = this.itemCache.get(index);
+    if (cachedItem && isValueShape(this.shape.shape)) {
+      return cachedItem;
+    }
+    const containerItem = this.container.get(index);
+    if (containerItem === void 0) {
+      return void 0;
+    }
+    if (isValueShape(this.shape.shape)) {
+      return containerItem;
+    } else {
+      if (isContainer(containerItem)) {
+        if (typeof containerItem === "object" && containerItem !== null && "toJSON" in containerItem) {
+          return containerItem.toJSON();
+        } else if (typeof containerItem === "object" && containerItem !== null && "getShallowValue" in containerItem) {
+          return containerItem.getShallowValue();
+        } else {
+          return containerItem;
+        }
+      }
+      return containerItem;
+    }
+  }
+  // Get item for return values - returns DraftItem that can be mutated
+  getDraftItem(index) {
+    let cachedItem = this.itemCache.get(index);
+    if (cachedItem) {
+      return cachedItem;
+    }
+    const containerItem = this.container.get(index);
+    if (containerItem === void 0) {
+      return void 0;
+    }
+    if (isValueShape(this.shape.shape)) {
+      if (typeof containerItem === "object" && containerItem !== null) {
+        cachedItem = JSON.parse(JSON.stringify(containerItem));
+      } else {
+        cachedItem = containerItem;
+      }
+      this.itemCache.set(index, cachedItem);
+      return cachedItem;
+    } else {
+      cachedItem = createContainerDraftNode(
+        this.getDraftNodeParams(index, this.shape.shape)
+      );
+      this.itemCache.set(index, cachedItem);
+      return cachedItem;
+    }
+  }
+  // Array-like methods for better developer experience
+  // DUAL INTERFACE: Predicates get Item (plain data), return values are DraftItem (mutable)
+  find(predicate) {
+    for (let i = 0; i < this.length; i++) {
+      const predicateItem = this.getPredicateItem(i);
+      if (predicate(predicateItem, i)) {
+        return this.getDraftItem(i);
+      }
+    }
+    return void 0;
+  }
+  findIndex(predicate) {
+    for (let i = 0; i < this.length; i++) {
+      const predicateItem = this.getPredicateItem(i);
+      if (predicate(predicateItem, i)) {
+        return i;
+      }
+    }
+    return -1;
+  }
+  map(callback) {
+    const result = [];
+    for (let i = 0; i < this.length; i++) {
+      const predicateItem = this.getPredicateItem(i);
+      result.push(callback(predicateItem, i));
+    }
+    return result;
+  }
+  filter(predicate) {
+    const result = [];
+    for (let i = 0; i < this.length; i++) {
+      const predicateItem = this.getPredicateItem(i);
+      if (predicate(predicateItem, i)) {
+        result.push(this.getDraftItem(i));
+      }
+    }
+    return result;
+  }
+  forEach(callback) {
+    for (let i = 0; i < this.length; i++) {
+      const predicateItem = this.getPredicateItem(i);
+      callback(predicateItem, i);
+    }
+  }
+  some(predicate) {
+    for (let i = 0; i < this.length; i++) {
+      const predicateItem = this.getPredicateItem(i);
+      if (predicate(predicateItem, i)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  every(predicate) {
+    for (let i = 0; i < this.length; i++) {
+      const predicateItem = this.getPredicateItem(i);
+      if (!predicate(predicateItem, i)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  insert(index, item) {
+    this.updateCacheForInsert(index);
+    this.insertWithConversion(index, item);
+  }
+  delete(index, len) {
+    this.updateCacheForDelete(index, len);
+    this.container.delete(index, len);
+  }
+  push(item) {
+    this.pushWithConversion(item);
+  }
+  pushContainer(container) {
+    return this.container.pushContainer(container);
+  }
+  insertContainer(index, container) {
+    return this.container.insertContainer(index, container);
+  }
+  get(index) {
+    return this.getDraftItem(index);
+  }
+  toArray() {
+    return this.container.toArray();
+  }
+  get length() {
+    return this.container.length;
+  }
+  // Update cache indices when items are deleted
+  updateCacheForDelete(deleteIndex, deleteLen) {
+    const newCache = /* @__PURE__ */ new Map();
+    for (const [cachedIndex, cachedItem] of this.itemCache.entries()) {
+      if (cachedIndex < deleteIndex) {
+        newCache.set(cachedIndex, cachedItem);
+      } else if (cachedIndex >= deleteIndex + deleteLen) {
+        newCache.set(cachedIndex - deleteLen, cachedItem);
+      }
+    }
+    this.itemCache = newCache;
+  }
+  // Update cache indices when items are inserted
+  updateCacheForInsert(insertIndex) {
+    const newCache = /* @__PURE__ */ new Map();
+    for (const [cachedIndex, cachedItem] of this.itemCache.entries()) {
+      if (cachedIndex < insertIndex) {
+        newCache.set(cachedIndex, cachedItem);
+      } else {
+        newCache.set(cachedIndex + 1, cachedItem);
+      }
+    }
+    this.itemCache = newCache;
+  }
+};
+
+// src/draft-nodes/list.ts
+var ListDraftNode = class extends ListDraftNodeBase {
+  get container() {
+    return super.container;
+  }
+  absorbValueAtIndex(index, value) {
+    this.container.delete(index, 1);
+    this.container.insert(index, value);
+  }
+};
+
+// src/draft-nodes/map.ts
+import {
+  LoroCounter as LoroCounter2,
+  LoroList as LoroList2,
+  LoroMap as LoroMap2,
+  LoroMovableList as LoroMovableList2,
+  LoroText as LoroText2,
+  LoroTree
+} from "loro-crdt";
+var containerConstructor = {
+  counter: LoroCounter2,
+  list: LoroList2,
+  map: LoroMap2,
+  movableList: LoroMovableList2,
+  record: LoroMap2,
+  text: LoroText2,
+  tree: LoroTree
+};
+var MapDraftNode = class extends DraftNode {
+  propertyCache = /* @__PURE__ */ new Map();
+  constructor(params) {
+    super(params);
+    this.createLazyProperties();
+  }
+  get shape() {
+    return super.shape;
+  }
+  get container() {
+    return super.container;
+  }
+  absorbPlainValues() {
+    for (const [key, node] of this.propertyCache.entries()) {
+      if (node instanceof DraftNode) {
+        node.absorbPlainValues();
+        continue;
+      }
+      this.container.set(key, node);
+    }
+  }
+  getDraftNodeParams(key, shape) {
+    const emptyState = this.emptyState?.[key];
+    const LoroContainer = containerConstructor[shape._type];
+    return {
+      shape,
+      emptyState,
+      getContainer: () => this.container.getOrCreateContainer(key, new LoroContainer())
+    };
+  }
+  getOrCreateNode(key, shape) {
+    let node = this.propertyCache.get(key);
+    if (!node) {
+      if (isContainerShape(shape)) {
+        node = createContainerDraftNode(this.getDraftNodeParams(key, shape));
+      } else {
+        const containerValue = this.container.get(key);
+        if (containerValue !== void 0) {
+          node = containerValue;
+        } else {
+          const emptyState = this.emptyState?.[key];
+          if (!emptyState) {
+            throw new Error("empty state required");
+          }
+          node = emptyState;
+        }
+      }
+      if (!node) throw new Error("no container made");
+      this.propertyCache.set(key, node);
+    }
+    return node;
+  }
+  createLazyProperties() {
+    for (const key in this.shape.shapes) {
+      const shape = this.shape.shapes[key];
+      Object.defineProperty(this, key, {
+        get: () => this.getOrCreateNode(key, shape),
+        set: isValueShape(shape) ? (value) => {
+          this.container.set(key, value);
+        } : void 0
+      });
+    }
+  }
+  // TOOD(duane): return correct type here
+  get(key) {
+    return this.container.get(key);
+  }
+  set(key, value) {
+    this.container.set(key, value);
+  }
+  setContainer(key, container) {
+    return this.container.setContainer(key, container);
+  }
+  delete(key) {
+    this.container.delete(key);
+  }
+  has(key) {
+    return this.container.get(key) !== void 0;
+  }
+  keys() {
+    return this.container.keys();
+  }
+  values() {
+    return this.container.values();
+  }
+  get size() {
+    return this.container.size;
+  }
+};
+
+// src/draft-nodes/movable-list.ts
+var MovableListDraftNode = class extends ListDraftNodeBase {
+  get container() {
+    return super.container;
+  }
+  absorbValueAtIndex(index, value) {
+    this.container.set(index, value);
+  }
+  move(from, to) {
+    this.container.move(from, to);
+  }
+  set(index, item) {
+    return this.container.set(index, item);
+  }
+};
+
+// src/draft-nodes/record.ts
+import {
+  LoroCounter as LoroCounter3,
+  LoroList as LoroList3,
+  LoroMap as LoroMap3,
+  LoroMovableList as LoroMovableList3,
+  LoroText as LoroText3,
+  LoroTree as LoroTree2
+} from "loro-crdt";
+var containerConstructor2 = {
+  counter: LoroCounter3,
+  list: LoroList3,
+  map: LoroMap3,
+  movableList: LoroMovableList3,
+  record: LoroMap3,
+  text: LoroText3,
+  tree: LoroTree2
+};
+var RecordDraftNode = class extends DraftNode {
+  nodeCache = /* @__PURE__ */ new Map();
+  constructor(params) {
+    super(params);
+    return new Proxy(this, {
+      get: (target, prop) => {
+        if (typeof prop === "string" && !(prop in target)) {
+          return target.get(prop);
+        }
+        return Reflect.get(target, prop);
+      },
+      set: (target, prop, value) => {
+        if (typeof prop === "string" && !(prop in target)) {
+          target.set(prop, value);
+          return true;
+        }
+        return Reflect.set(target, prop, value);
+      },
+      deleteProperty: (target, prop) => {
+        if (typeof prop === "string" && !(prop in target)) {
+          target.delete(prop);
+          return true;
+        }
+        return Reflect.deleteProperty(target, prop);
+      },
+      ownKeys: (target) => {
+        return target.keys();
+      },
+      getOwnPropertyDescriptor: (target, prop) => {
+        if (typeof prop === "string" && target.has(prop)) {
+          return {
+            configurable: true,
+            enumerable: true,
+            value: target.get(prop)
+          };
+        }
+        return Reflect.getOwnPropertyDescriptor(target, prop);
+      }
+    });
+  }
+  get shape() {
+    return super.shape;
+  }
+  get container() {
+    return super.container;
+  }
+  absorbPlainValues() {
+    for (const [key, node] of this.nodeCache.entries()) {
+      if (node instanceof DraftNode) {
+        node.absorbPlainValues();
+        continue;
+      }
+      this.container.set(key, node);
+    }
+  }
+  getDraftNodeParams(key, shape) {
+    const emptyState = this.emptyState?.[key];
+    const LoroContainer = containerConstructor2[shape._type];
+    return {
+      shape,
+      emptyState,
+      getContainer: () => this.container.getOrCreateContainer(key, new LoroContainer())
+    };
+  }
+  getOrCreateNode(key) {
+    let node = this.nodeCache.get(key);
+    if (!node) {
+      const shape = this.shape.shape;
+      if (isContainerShape(shape)) {
+        node = createContainerDraftNode(
+          this.getDraftNodeParams(key, shape)
+        );
+      } else {
+        const containerValue = this.container.get(key);
+        if (containerValue !== void 0) {
+          node = containerValue;
+        } else {
+          const emptyState = this.emptyState?.[key];
+          if (emptyState === void 0) {
+            node = shape._plain;
+          } else {
+            node = emptyState;
+          }
+        }
+      }
+      if (node !== void 0) {
+        this.nodeCache.set(key, node);
+      }
+    }
+    return node;
+  }
+  get(key) {
+    return this.getOrCreateNode(key);
+  }
+  set(key, value) {
+    if (isValueShape(this.shape.shape)) {
+      this.container.set(key, value);
+      this.nodeCache.set(key, value);
+    } else {
+      throw new Error(
+        "Cannot set container directly, modify the draft node instead"
+      );
+    }
+  }
+  setContainer(key, container) {
+    return this.container.setContainer(key, container);
+  }
+  delete(key) {
+    this.container.delete(key);
+    this.nodeCache.delete(key);
+  }
+  has(key) {
+    return this.container.get(key) !== void 0;
+  }
+  keys() {
+    return this.container.keys();
+  }
+  values() {
+    return this.container.values();
+  }
+  get size() {
+    return this.container.size;
+  }
+};
+
+// src/draft-nodes/text.ts
+var TextDraftNode = class extends DraftNode {
+  absorbPlainValues() {
+  }
+  // Text methods
+  insert(index, content) {
+    if (content.length === 0) return;
+    this.container.insert(index, content);
+  }
+  delete(index, len) {
+    this.container.delete(index, len);
+  }
+  toString() {
+    return this.container.toString();
+  }
+  update(text) {
+    this.container.update(text);
+  }
+  mark(range, key, value) {
+    this.container.mark(range, key, value);
+  }
+  unmark(range, key) {
+    this.container.unmark(range, key);
+  }
+  toDelta() {
+    return this.container.toDelta();
+  }
+  applyDelta(delta) {
+    this.container.applyDelta(delta);
+  }
+  get length() {
+    return this.container.length;
+  }
+};
+
+// src/draft-nodes/tree.ts
+var TreeDraftNode = class extends DraftNode {
+  absorbPlainValues() {
+  }
+  createNode(parent, index) {
+    return this.container.createNode(parent, index);
+  }
+  move(target, parent, index) {
+    this.container.move(target, parent, index);
+  }
+  delete(target) {
+    this.container.delete(target);
+  }
+  has(target) {
+    return this.container.has(target);
+  }
+  getNodeByID(id) {
+    return this.container.getNodeByID ? this.container.getNodeByID(id) : void 0;
+  }
+};
+
+// src/draft-nodes/utils.ts
+function createContainerDraftNode(params) {
+  switch (params.shape._type) {
+    case "counter":
+      return new CounterDraftNode(
+        params
+      );
+    case "list":
+      return new ListDraftNode(params);
+    case "map":
+      return new MapDraftNode(params);
+    case "movableList":
+      return new MovableListDraftNode(
+        params
+      );
+    case "record":
+      return new RecordDraftNode(
+        params
+      );
+    case "text":
+      return new TextDraftNode(params);
+    case "tree":
+      return new TreeDraftNode(params);
+    default:
+      throw new Error(
+        `Unknown container type: ${params.shape._type}`
+      );
+  }
+}
+
+// src/draft-nodes/doc.ts
+var containerGetter = {
+  counter: "getCounter",
+  list: "getList",
+  map: "getMap",
+  movableList: "getMovableList",
+  record: "getMap",
+  text: "getText",
+  tree: "getTree"
+};
+var DraftDoc = class extends DraftNode {
+  doc;
+  propertyCache = /* @__PURE__ */ new Map();
+  requiredEmptyState;
+  constructor(_params) {
+    super({
+      ..._params,
+      getContainer: () => {
+        throw new Error("can't get container on DraftDoc");
+      }
+    });
+    if (!_params.emptyState) throw new Error("emptyState required");
+    this.doc = _params.doc;
+    this.requiredEmptyState = _params.emptyState;
+    this.createLazyProperties();
+  }
+  getDraftNodeParams(key, shape) {
+    const getter = this.doc[containerGetter[shape._type]].bind(this.doc);
+    return {
+      shape,
+      emptyState: this.requiredEmptyState[key],
+      getContainer: () => getter(key)
+    };
+  }
+  getOrCreateDraftNode(key, shape) {
+    let node = this.propertyCache.get(key);
+    if (!node) {
+      node = createContainerDraftNode(this.getDraftNodeParams(key, shape));
+      this.propertyCache.set(key, node);
+    }
+    return node;
+  }
+  createLazyProperties() {
+    for (const key in this.shape.shapes) {
+      const shape = this.shape.shapes[key];
+      Object.defineProperty(this, key, {
+        get: () => this.getOrCreateDraftNode(key, shape)
+      });
+    }
+  }
+  absorbPlainValues() {
+    for (const [, node] of this.propertyCache.entries()) {
+      node.absorbPlainValues();
+    }
+  }
+};
+
+// src/json-patch.ts
+function normalizePath(path) {
+  if (Array.isArray(path)) {
+    return path;
+  }
+  if (path.startsWith("/")) {
+    return path.slice(1).split("/").map((segment) => {
+      const unescaped = segment.replace(/~1/g, "/").replace(/~0/g, "~");
+      const asNumber = Number(unescaped);
+      return Number.isInteger(asNumber) && asNumber >= 0 ? asNumber : unescaped;
+    });
+  }
+  return path.split(".").map((segment) => {
+    const asNumber = Number(segment);
+    return Number.isInteger(asNumber) && asNumber >= 0 ? asNumber : segment;
+  });
+}
+function navigateToPath(draft, path) {
+  if (path.length === 0) {
+    throw new Error("Cannot navigate to empty path");
+  }
+  let current = draft;
+  for (let i = 0; i < path.length - 1; i++) {
+    const segment = path[i];
+    if (typeof segment === "string") {
+      current = current[segment];
+      if (current === void 0) {
+        throw new Error(`Cannot navigate to path segment: ${segment}`);
+      }
+    } else if (typeof segment === "number") {
+      if (current.get && typeof current.get === "function") {
+        current = current.get(segment);
+        if (current === void 0) {
+          throw new Error(`List index ${segment} does not exist`);
+        }
+      } else {
+        throw new Error(`Cannot use numeric index ${segment} on non-list`);
+      }
+    } else {
+      throw new Error(`Invalid path segment type: ${typeof segment}`);
+    }
+  }
+  const targetKey = path[path.length - 1];
+  return { parent: current, key: targetKey };
+}
+function getValueAtPath(draft, path) {
+  if (path.length === 0) {
+    return draft;
+  }
+  const { parent, key } = navigateToPath(draft, path);
+  if (typeof key === "string") {
+    if (parent.get && typeof parent.get === "function") {
+      return parent.get(key);
+    }
+    return parent[key];
+  } else if (typeof key === "number") {
+    if (parent.get && typeof parent.get === "function") {
+      return parent.get(key);
+    }
+    throw new Error(`Cannot use numeric index ${key} on non-list`);
+  }
+  throw new Error(`Invalid key type: ${typeof key}`);
+}
+function handleAdd(draft, operation) {
+  const path = normalizePath(operation.path);
+  const { parent, key } = navigateToPath(draft, path);
+  if (typeof key === "string") {
+    if (parent.set && typeof parent.set === "function") {
+      parent.set(key, operation.value);
+    } else {
+      parent[key] = operation.value;
+    }
+  } else if (typeof key === "number") {
+    if (parent.insert && typeof parent.insert === "function") {
+      parent.insert(key, operation.value);
+    } else {
+      throw new Error(`Cannot insert at numeric index ${key} on non-list`);
+    }
+  } else {
+    throw new Error(`Invalid key type: ${typeof key}`);
+  }
+}
+function handleRemove(draft, operation) {
+  const path = normalizePath(operation.path);
+  const { parent, key } = navigateToPath(draft, path);
+  if (typeof key === "string") {
+    if (parent.delete && typeof parent.delete === "function") {
+      parent.delete(key);
+    } else {
+      delete parent[key];
+    }
+  } else if (typeof key === "number") {
+    if (parent.delete && typeof parent.delete === "function") {
+      parent.delete(key, 1);
+    } else {
+      throw new Error(`Cannot remove at numeric index ${key} on non-list`);
+    }
+  } else {
+    throw new Error(`Invalid key type: ${typeof key}`);
+  }
+}
+function handleReplace(draft, operation) {
+  const path = normalizePath(operation.path);
+  const { parent, key } = navigateToPath(draft, path);
+  if (typeof key === "string") {
+    if (parent.set && typeof parent.set === "function") {
+      parent.set(key, operation.value);
+    } else {
+      parent[key] = operation.value;
+    }
+  } else if (typeof key === "number") {
+    if (parent.delete && parent.insert && typeof parent.delete === "function" && typeof parent.insert === "function") {
+      parent.delete(key, 1);
+      parent.insert(key, operation.value);
+    } else {
+      throw new Error(`Cannot replace at numeric index ${key} on non-list`);
+    }
+  } else {
+    throw new Error(`Invalid key type: ${typeof key}`);
+  }
+}
+function handleMove(draft, operation) {
+  const fromPath = normalizePath(operation.from);
+  const toPath = normalizePath(operation.path);
+  if (fromPath.length === toPath.length && fromPath.slice(0, -1).every((segment, i) => segment === toPath[i])) {
+    const fromIndex = fromPath[fromPath.length - 1];
+    const toIndex = toPath[toPath.length - 1];
+    if (typeof fromIndex === "number" && typeof toIndex === "number") {
+      const { parent } = navigateToPath(draft, fromPath.slice(0, -1));
+      if (parent.move && typeof parent.move === "function") {
+        parent.move(fromIndex, toIndex);
+        return;
+      }
+      const value2 = getValueAtPath(draft, fromPath);
+      handleRemove(draft, { op: "remove", path: operation.from });
+      handleAdd(draft, { op: "add", path: operation.path, value: value2 });
+      return;
+    }
+  }
+  const value = getValueAtPath(draft, fromPath);
+  handleRemove(draft, { op: "remove", path: operation.from });
+  handleAdd(draft, { op: "add", path: operation.path, value });
+}
+function handleCopy(draft, operation) {
+  const fromPath = normalizePath(operation.from);
+  const value = getValueAtPath(draft, fromPath);
+  handleAdd(draft, { op: "add", path: operation.path, value });
+}
+function handleTest(draft, operation) {
+  const path = normalizePath(operation.path);
+  const actualValue = getValueAtPath(draft, path);
+  return JSON.stringify(actualValue) === JSON.stringify(operation.value);
+}
+var JsonPatchApplicator = class {
+  constructor(rootDraft) {
+    this.rootDraft = rootDraft;
+  }
+  /**
+   * Apply a single JSON Patch operation
+   */
+  applyOperation(operation) {
+    switch (operation.op) {
+      case "add":
+        handleAdd(this.rootDraft, operation);
+        break;
+      case "remove":
+        handleRemove(this.rootDraft, operation);
+        break;
+      case "replace":
+        handleReplace(this.rootDraft, operation);
+        break;
+      case "move":
+        handleMove(this.rootDraft, operation);
+        break;
+      case "copy":
+        handleCopy(this.rootDraft, operation);
+        break;
+      case "test":
+        if (!handleTest(this.rootDraft, operation)) {
+          throw new Error(`JSON Patch test failed at path: ${operation.path}`);
+        }
+        break;
+      default:
+        throw new Error(
+          `Unsupported JSON Patch operation: ${operation.op}`
+        );
+    }
+  }
+  /**
+   * Apply multiple JSON Patch operations in sequence
+   */
+  applyPatch(patch) {
+    for (const operation of patch) {
+      this.applyOperation(operation);
+    }
+  }
+};
+
+// src/overlay.ts
+function overlayEmptyState(shape, crdtValue, emptyValue) {
+  if (typeof crdtValue !== "object") {
+    throw new Error("crdt object is required");
+  }
+  if (typeof emptyValue !== "object") {
+    throw new Error("empty object is required");
+  }
+  const result = { ...emptyValue };
+  for (const [key, propShape] of Object.entries(shape.shapes)) {
+    const propCrdtValue = crdtValue[key];
+    const propEmptyValue = emptyValue[key];
+    result[key] = mergeValue(
+      propShape,
+      propCrdtValue,
+      propEmptyValue
+    );
+  }
+  return result;
+}
+function mergeValue(shape, crdtValue, emptyValue) {
+  if (crdtValue === void 0 && emptyValue === void 0) {
+    throw new Error("either crdt or empty value must be defined");
+  }
+  switch (shape._type) {
+    case "text":
+      return crdtValue ?? emptyValue ?? "";
+    case "counter":
+      return crdtValue ?? emptyValue ?? 0;
+    case "list":
+    case "movableList":
+      return crdtValue ?? emptyValue ?? [];
+    case "map": {
+      if (!isObjectValue(crdtValue) && crdtValue !== void 0) {
+        throw new Error("map crdt must be object");
+      }
+      const crdtMapValue = crdtValue ?? {};
+      if (!isObjectValue(emptyValue) && emptyValue !== void 0) {
+        throw new Error("map empty state must be object");
+      }
+      const emptyMapValue = emptyValue ?? {};
+      const result = { ...emptyMapValue };
+      for (const [key, nestedShape] of Object.entries(shape.shapes)) {
+        const nestedCrdtValue = crdtMapValue[key];
+        const nestedEmptyValue = emptyMapValue[key];
+        result[key] = mergeValue(
+          nestedShape,
+          nestedCrdtValue,
+          nestedEmptyValue
+        );
+      }
+      return result;
+    }
+    case "tree":
+      return crdtValue ?? emptyValue ?? [];
+    default:
+      return crdtValue ?? emptyValue;
+  }
+}
+
+// src/validation.ts
+function validateValue(value, schema, path = "") {
+  if (!schema || typeof schema !== "object" || !("_type" in schema)) {
+    throw new Error(`Invalid schema at path ${path}: missing _type`);
+  }
+  const currentPath = path || "root";
+  if (schema._type === "text") {
+    if (typeof value !== "string") {
+      throw new Error(
+        `Expected string at path ${currentPath}, got ${typeof value}`
+      );
+    }
+    return value;
+  }
+  if (schema._type === "counter") {
+    if (typeof value !== "number") {
+      throw new Error(
+        `Expected number at path ${currentPath}, got ${typeof value}`
+      );
+    }
+    return value;
+  }
+  if (schema._type === "list" || schema._type === "movableList") {
+    if (!Array.isArray(value)) {
+      throw new Error(
+        `Expected array at path ${currentPath}, got ${typeof value}`
+      );
+    }
+    const listSchema = schema;
+    return value.map(
+      (item, index) => validateValue(item, listSchema.shape, `${currentPath}[${index}]`)
+    );
+  }
+  if (schema._type === "map") {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+      throw new Error(
+        `Expected object at path ${currentPath}, got ${typeof value}`
+      );
+    }
+    const mapSchema = schema;
+    const result = {};
+    for (const [key, nestedSchema] of Object.entries(mapSchema.shapes)) {
+      const nestedPath = `${currentPath}.${key}`;
+      const nestedValue = value[key];
+      result[key] = validateValue(nestedValue, nestedSchema, nestedPath);
+    }
+    return result;
+  }
+  if (schema._type === "record") {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+      throw new Error(
+        `Expected object at path ${currentPath}, got ${typeof value}`
+      );
+    }
+    const recordSchema = schema;
+    const result = {};
+    for (const [key, nestedValue] of Object.entries(value)) {
+      const nestedPath = `${currentPath}.${key}`;
+      result[key] = validateValue(nestedValue, recordSchema.shape, nestedPath);
+    }
+    return result;
+  }
+  if (schema._type === "tree") {
+    if (!Array.isArray(value)) {
+      throw new Error(
+        `Expected array for tree at path ${currentPath}, got ${typeof value}`
+      );
+    }
+    return value;
+  }
+  if (schema._type === "value") {
+    const valueSchema = schema;
+    switch (valueSchema.valueType) {
+      case "string":
+        if (typeof value !== "string") {
+          throw new Error(
+            `Expected string at path ${currentPath}, got ${typeof value}`
+          );
+        }
+        return value;
+      case "number":
+        if (typeof value !== "number") {
+          throw new Error(
+            `Expected number at path ${currentPath}, got ${typeof value}`
+          );
+        }
+        return value;
+      case "boolean":
+        if (typeof value !== "boolean") {
+          throw new Error(
+            `Expected boolean at path ${currentPath}, got ${typeof value}`
+          );
+        }
+        return value;
+      case "null":
+        if (value !== null) {
+          throw new Error(
+            `Expected null at path ${currentPath}, got ${typeof value}`
+          );
+        }
+        return value;
+      case "undefined":
+        if (value !== void 0) {
+          throw new Error(
+            `Expected undefined at path ${currentPath}, got ${typeof value}`
+          );
+        }
+        return value;
+      case "uint8array":
+        if (!(value instanceof Uint8Array)) {
+          throw new Error(
+            `Expected Uint8Array at path ${currentPath}, got ${typeof value}`
+          );
+        }
+        return value;
+      case "object": {
+        if (!value || typeof value !== "object" || Array.isArray(value)) {
+          throw new Error(
+            `Expected object at path ${currentPath}, got ${typeof value}`
+          );
+        }
+        const objectSchema = valueSchema;
+        const result = {};
+        for (const [key, nestedSchema] of Object.entries(objectSchema.shape)) {
+          const nestedPath = `${currentPath}.${key}`;
+          const nestedValue = value[key];
+          result[key] = validateValue(nestedValue, nestedSchema, nestedPath);
+        }
+        return result;
+      }
+      case "record": {
+        if (!value || typeof value !== "object" || Array.isArray(value)) {
+          throw new Error(
+            `Expected object at path ${currentPath}, got ${typeof value}`
+          );
+        }
+        const recordSchema = valueSchema;
+        const result = {};
+        for (const [key, nestedValue] of Object.entries(value)) {
+          const nestedPath = `${currentPath}.${key}`;
+          result[key] = validateValue(
+            nestedValue,
+            recordSchema.shape,
+            nestedPath
+          );
+        }
+        return result;
+      }
+      case "array": {
+        if (!Array.isArray(value)) {
+          throw new Error(
+            `Expected array at path ${currentPath}, got ${typeof value}`
+          );
+        }
+        const arraySchema = valueSchema;
+        return value.map(
+          (item, index) => validateValue(item, arraySchema.shape, `${currentPath}[${index}]`)
+        );
+      }
+      case "union": {
+        const unionSchema = valueSchema;
+        let lastError = null;
+        for (const shape of unionSchema.shapes) {
+          try {
+            return validateValue(value, shape, currentPath);
+          } catch (error) {
+            lastError = error;
+          }
+        }
+        throw new Error(
+          `Value at path ${currentPath} does not match any union type: ${lastError?.message}`
+        );
+      }
+      default:
+        throw new Error(`Unknown value type: ${valueSchema.valueType}`);
+    }
+  }
+  throw new Error(`Unknown schema type: ${schema._type}`);
+}
+function validateEmptyState(emptyState, schema) {
+  if (!emptyState || typeof emptyState !== "object" || Array.isArray(emptyState)) {
+    throw new Error("Empty state must be an object");
+  }
+  const result = {};
+  for (const [key, schemaValue] of Object.entries(schema.shapes)) {
+    const value = emptyState[key];
+    result[key] = validateValue(value, schemaValue, key);
+  }
+  return result;
+}
+
+// src/change.ts
+var TypedDoc = class {
+  constructor(shape, emptyState, doc = new LoroDoc()) {
+    this.shape = shape;
+    this.emptyState = emptyState;
+    this.doc = doc;
+    validateEmptyState(emptyState, shape);
+  }
+  get value() {
+    const crdtValue = this.doc.toJSON();
+    return overlayEmptyState(
+      this.shape,
+      crdtValue,
+      this.emptyState
+    );
+  }
+  change(fn) {
+    const draft = new DraftDoc({
+      shape: this.shape,
+      emptyState: this.emptyState,
+      doc: this.doc
+    });
+    fn(draft);
+    draft.absorbPlainValues();
+    this.doc.commit();
+    return this.value;
+  }
+  /**
+   * Apply JSON Patch operations to the document
+   *
+   * @param patch - Array of JSON Patch operations (RFC 6902)
+   * @param pathPrefix - Optional path prefix for scoped operations
+   * @returns Updated document value
+   *
+   * @example
+   * ```typescript
+   * const result = typedDoc.applyPatch([
+   *   { op: 'add', path: '/users/0/name', value: 'Alice' },
+   *   { op: 'replace', path: '/settings/theme', value: 'dark' }
+   * ])
+   * ```
+   */
+  applyPatch(patch, pathPrefix) {
+    return this.change((draft) => {
+      const applicator = new JsonPatchApplicator(draft);
+      const prefixedPatch = pathPrefix ? patch.map((op) => ({
+        ...op,
+        path: [...pathPrefix, ...normalizePath(op.path)]
+      })) : patch;
+      applicator.applyPatch(prefixedPatch);
+    });
+  }
+  // Expose underlying doc for advanced use cases
+  get loroDoc() {
+    return this.doc;
+  }
+  // Expose shape for internal use
+  get docShape() {
+    return this.shape;
+  }
+  // Get raw CRDT value without overlay
+  get rawValue() {
+    return this.doc.toJSON();
+  }
+};
+function createTypedDoc(shape, emptyState, existingDoc) {
+  return new TypedDoc(shape, emptyState, existingDoc || new LoroDoc());
+}
+
+// src/shape.ts
+var Shape = {
+  doc: (shape) => ({
+    _type: "doc",
+    shapes: shape,
+    _plain: {},
+    _draft: {}
+  }),
+  // CRDTs are represented by Loro Containers--they converge on state using Loro's
+  // various CRDT algorithms
+  counter: () => ({
+    _type: "counter",
+    _plain: 0,
+    _draft: {}
+  }),
+  list: (shape) => ({
+    _type: "list",
+    shape,
+    _plain: [],
+    _draft: {}
+  }),
+  map: (shape) => ({
+    _type: "map",
+    shapes: shape,
+    _plain: {},
+    _draft: {}
+  }),
+  record: (shape) => ({
+    _type: "record",
+    shape,
+    _plain: {},
+    _draft: {}
+  }),
+  movableList: (shape) => ({
+    _type: "movableList",
+    shape,
+    _plain: [],
+    _draft: {}
+  }),
+  text: () => ({
+    _type: "text",
+    _plain: "",
+    _draft: {}
+  }),
+  tree: (shape) => ({
+    _type: "tree",
+    shape,
+    _plain: {},
+    _draft: {}
+  }),
+  // Values are represented as plain JS objects, with the limitation that they MUST be
+  // representable as a Loro "Value"--basically JSON. The behavior of a Value is basically
+  // "Last Write Wins", meaning there is no subtle convergent behavior here, just taking
+  // the most recent value based on the current available information.
+  plain: {
+    string: () => ({
+      _type: "value",
+      valueType: "string",
+      _plain: "",
+      _draft: ""
+    }),
+    number: () => ({
+      _type: "value",
+      valueType: "number",
+      _plain: 0,
+      _draft: 0
+    }),
+    boolean: () => ({
+      _type: "value",
+      valueType: "boolean",
+      _plain: false,
+      _draft: false
+    }),
+    null: () => ({
+      _type: "value",
+      valueType: "null",
+      _plain: null,
+      _draft: null
+    }),
+    undefined: () => ({
+      _type: "value",
+      valueType: "undefined",
+      _plain: void 0,
+      _draft: void 0
+    }),
+    uint8Array: () => ({
+      _type: "value",
+      valueType: "uint8array",
+      _plain: new Uint8Array(),
+      _draft: new Uint8Array()
+    }),
+    object: (shape) => ({
+      _type: "value",
+      valueType: "object",
+      shape,
+      _plain: {},
+      _draft: {}
+    }),
+    record: (shape) => ({
+      _type: "value",
+      valueType: "record",
+      shape,
+      _plain: {},
+      _draft: {}
+    }),
+    array: (shape) => ({
+      _type: "value",
+      valueType: "array",
+      shape,
+      _plain: [],
+      _draft: []
+    }),
+    // Special value type that helps make things like `string | null` representable
+    // TODO(duane): should this be a more general type for containers too?
+    union: (shapes) => ({
+      _type: "value",
+      valueType: "union",
+      shapes,
+      _plain: {},
+      _draft: {}
+    })
+  }
+};
+export {
+  Shape,
+  TypedDoc,
+  createTypedDoc,
+  mergeValue,
+  overlayEmptyState,
+  validateEmptyState
+};
+//# sourceMappingURL=index.js.map