@palantir/pack.state.core 0.0.1-beta.1

package/build/browser/index.js

@@ -0,0 +1,1257 @@
+import { getMetadata, DocumentRefBrand, RecordCollectionRefBrand, RecordRefBrand } from '@palantir/pack.document-schema.model-types';
+import { isDeepEqual } from 'remeda';
+import invariant from 'tiny-invariant';
+import * as Y from 'yjs';
+import { assertIsAppInternal, generateId } from '@palantir/pack.core';
+
+// src/DocumentServiceModule.ts
+var DOCUMENT_SERVICE_MODULE_KEY = {
+  key: Symbol("DocumentService"),
+  initModule: initDocumentService
+};
+function getDocumentService(app) {
+  return app.getModule(DOCUMENT_SERVICE_MODULE_KEY);
+}
+function createDocumentServiceConfig(init, config) {
+  return [DOCUMENT_SERVICE_MODULE_KEY, {
+    ...config,
+    init
+  }];
+}
+function initDocumentService(app, config) {
+  if (config == null) {
+    throw new Error("DocumentServiceConfig is required to initialize DocumentService");
+  }
+  return config.init(app, config);
+}
+var STATE_MODULE_ACCESSOR = "state";
+var STATE_MODULE_KEY = {
+  appMemberName: STATE_MODULE_ACCESSOR,
+  key: Symbol.for("pack.state"),
+  initModule: (app) => {
+    const documentService = app.getModule(DOCUMENT_SERVICE_MODULE_KEY);
+    return new StateModuleImpl(documentService);
+  }
+};
+var StateModuleImpl = class {
+  constructor(documentService) {
+    this.documentService = documentService;
+  }
+  createDocRef(id, schema) {
+    return this.documentService.createDocRef(id, schema);
+  }
+  createRecordRef(docRef, id, model) {
+    return this.documentService.getCreateRecordRef(docRef, id, model);
+  }
+  async createDocument(metadata, schema) {
+    return this.documentService.createDocument(metadata, schema);
+  }
+  async getDocumentSnapshot(docRef) {
+    return this.documentService.getDocumentSnapshot(docRef);
+  }
+  onMetadataChange(docRef, cb) {
+    return this.documentService.onMetadataChange(docRef, cb);
+  }
+  onStateChange(docRef, cb) {
+    return this.documentService.onStateChange(docRef, cb);
+  }
+  async getRecordSnapshot(recordRef) {
+    return this.documentService.getRecordSnapshot(recordRef);
+  }
+  async setRecord(recordRef, state) {
+    return this.documentService.setRecord(recordRef, state);
+  }
+  async updateRecord(recordRef, partialState) {
+    return this.documentService.updateRecord(recordRef, partialState);
+  }
+  // Collection methods
+  getCreateRecordCollectionRef(docRef, model) {
+    return this.documentService.getCreateRecordCollectionRef(docRef, model);
+  }
+  // FIXME: confusing vs createRecordRef
+  getRecord(collection, id) {
+    return this.documentService.getRecord(collection, id);
+  }
+  hasRecord(collection, id) {
+    return this.documentService.hasRecord(collection, id);
+  }
+  async setCollectionRecord(collection, id, state) {
+    return this.documentService.setCollectionRecord(collection, id, state);
+  }
+  getCollectionSize(collection) {
+    return this.documentService.getCollectionSize(collection);
+  }
+  getCollectionRecords(collection) {
+    return this.documentService.getCollectionRecords(collection);
+  }
+  onRecordChanged(record, callback) {
+    return this.documentService.onRecordChanged(record, callback);
+  }
+  onRecordDeleted(record, callback) {
+    return this.documentService.onRecordDeleted(record, callback);
+  }
+  onCollectionItemsAdded(collection, callback) {
+    return this.documentService.onCollectionItemsAdded(collection, callback);
+  }
+  onCollectionItemsChanged(collection, callback) {
+    return this.documentService.onCollectionItemsChanged(collection, callback);
+  }
+  onCollectionItemsDeleted(collection, callback) {
+    return this.documentService.onCollectionItemsDeleted(collection, callback);
+  }
+  // Status methods implementation
+  getDocumentStatus(docRef) {
+    return this.documentService.getDocumentStatus(docRef);
+  }
+  onStatusChange(docRef, callback) {
+    return this.documentService.onStatusChange(docRef, callback);
+  }
+  async waitForMetadataLoad(docRef) {
+    return this.documentService.waitForMetadataLoad(docRef);
+  }
+  async waitForDataLoad(docRef) {
+    return this.documentService.waitForDataLoad(docRef);
+  }
+  async deleteRecord(record) {
+    return this.documentService.deleteRecord(record);
+  }
+};
+function getStateModule(app) {
+  assertIsAppInternal(app);
+  return app.getModule(STATE_MODULE_KEY);
+}
+
+// src/types/DocumentRefImpl.ts
+var INVALID_DOC_REF_ID = "INVALID_DOC_REF";
+var INVALID_DOC_REF = Object.freeze({
+  id: INVALID_DOC_REF_ID,
+  schema: {},
+  [DocumentRefBrand]: DocumentRefBrand,
+  getDocSnapshot: () => Promise.reject(new Error("Invalid document reference")),
+  getRecords: () => {
+    throw new Error("Invalid document reference");
+  },
+  onMetadataChange: () => () => {
+  },
+  onStateChange: () => () => {
+  }
+});
+var createDocRef = (app, id, schema) => {
+  return new DocumentRefImpl(app, id, schema);
+};
+function invalidDocRef() {
+  return INVALID_DOC_REF;
+}
+function isValidDocRef(docRef) {
+  return docRef.id !== INVALID_DOC_REF_ID && docRef.id !== "";
+}
+var DocumentRefImpl = class {
+  id;
+  schema;
+  #stateModule;
+  constructor(app, id, schema) {
+    this.#stateModule = getStateModule(app);
+    this.id = id;
+    this.schema = schema;
+  }
+  async getDocSnapshot() {
+    return this.#stateModule.getDocumentSnapshot(this);
+  }
+  getRecords(model) {
+    return this.#stateModule.getCreateRecordCollectionRef(this, model);
+  }
+  onMetadataChange(cb) {
+    return this.#stateModule.onMetadataChange(this, cb);
+  }
+  onStateChange(callback) {
+    return this.#stateModule.onStateChange(this, callback);
+  }
+};
+
+// src/types/DocumentService.ts
+var DocumentLoadStatus = {
+  UNLOADED: "unloaded",
+  // Not yet loaded
+  LOADING: "loading",
+  // Initial load in progress
+  LOADED: "loaded",
+  // Successfully loaded
+  ERROR: "error"
+  // Load failed
+};
+var DocumentLiveStatus = {
+  DISCONNECTED: "disconnected",
+  // Not syncing
+  CONNECTING: "connecting",
+  // Establishing connection
+  CONNECTED: "connected",
+  // Live syncing active
+  ERROR: "error"
+  // Connection error
+};
+var INVALID_RECORD_COLLECTION_REF = Object.freeze({
+  docRef: invalidDocRef(),
+  model: {},
+  [RecordCollectionRefBrand]: RecordCollectionRefBrand,
+  get: () => void 0,
+  has: () => false,
+  set: () => Promise.reject(new Error("Invalid record collection reference")),
+  delete: () => Promise.reject(new Error("Invalid record collection reference")),
+  size: 0,
+  [Symbol.iterator]: () => ({
+    next: () => ({
+      done: true,
+      value: void 0
+    })
+  }),
+  onItemsAdded: () => () => {
+  },
+  onItemsChanged: () => () => {
+  },
+  onItemsDeleted: () => () => {
+  }
+});
+var createRecordCollectionRef = (documentService, docRef, model) => {
+  return new RecordCollectionRefImpl(documentService, docRef, model);
+};
+function invalidRecordCollectionRef() {
+  return INVALID_RECORD_COLLECTION_REF;
+}
+function isValidRecordCollectionRef(collectionRef) {
+  return collectionRef !== INVALID_RECORD_COLLECTION_REF;
+}
+var RecordCollectionRefImpl = class {
+  docRef;
+  model;
+  #documentService;
+  constructor(documentService, docRef, model) {
+    this.docRef = docRef;
+    this.model = model;
+    this.#documentService = documentService;
+  }
+  get(id) {
+    return this.#documentService.getRecord(this, id);
+  }
+  has(id) {
+    return this.#documentService.hasRecord(this, id);
+  }
+  async set(id, state) {
+    return this.#documentService.setCollectionRecord(this, id, state);
+  }
+  delete(id) {
+    const recordRefInstance = this.#documentService.getRecord(this, id);
+    if (recordRefInstance) {
+      return this.#documentService.deleteRecord(recordRefInstance);
+    }
+    return Promise.reject(new Error(`Unknown record`));
+  }
+  get size() {
+    return this.#documentService.getCollectionSize(this);
+  }
+  [Symbol.iterator]() {
+    return this.#documentService.getCollectionRecords(this)[Symbol.iterator]();
+  }
+  onItemsAdded = (callback) => {
+    return this.#documentService.onCollectionItemsAdded(this, callback);
+  };
+  onItemsChanged = (callback) => {
+    return this.#documentService.onCollectionItemsChanged(this, callback);
+  };
+  onItemsDeleted = (callback) => {
+    return this.#documentService.onCollectionItemsDeleted(this, callback);
+  };
+};
+var INVALID_RECORD_ID = "INVALID_RECORD_REF";
+var INVALID_RECORD_REF = Object.freeze({
+  docRef: invalidDocRef(),
+  id: INVALID_RECORD_ID,
+  model: {},
+  [RecordRefBrand]: RecordRefBrand,
+  getSnapshot: () => Promise.reject(new Error("Invalid record reference")),
+  set: () => Promise.reject(new Error("Invalid record reference")),
+  onChange: () => () => {
+  },
+  onDeleted: () => () => {
+  }
+});
+var createRecordRef = (documentService, docRef, id, model) => {
+  return new RecordRefImpl(documentService, docRef, id, model);
+};
+function invalidRecordRef() {
+  return INVALID_RECORD_REF;
+}
+function isValidRecordRef(recordRef) {
+  return recordRef.id !== INVALID_RECORD_ID;
+}
+var RecordRefImpl = class {
+  docRef;
+  id;
+  model;
+  #documentService;
+  constructor(documentService, docRef, id, model) {
+    this.#documentService = documentService;
+    this.docRef = docRef;
+    this.id = id;
+    this.model = model;
+  }
+  async getSnapshot() {
+    return this.#documentService.getRecordSnapshot(this);
+  }
+  onChange(callback) {
+    return this.#documentService.onRecordChanged(this, callback);
+  }
+  onDeleted(callback) {
+    return this.#documentService.onRecordDeleted(this, callback);
+  }
+  delete() {
+    return this.#documentService.deleteRecord(this);
+  }
+  set(record) {
+    return this.#documentService.setRecord(this, record);
+  }
+  update(partialRecord) {
+    return this.#documentService.updateRecord(this, partialRecord);
+  }
+};
+function initializeDocumentStructure(yDoc, schema) {
+  Object.values(schema).forEach((modelEntry) => {
+    yDoc.getMap(getMetadata(modelEntry).name);
+  });
+}
+function getRecordsMap(yDoc, storageName) {
+  return yDoc.getMap(storageName);
+}
+function getRecordData(yDoc, storageName, recordId) {
+  const recordsCollection = getRecordsMap(yDoc, storageName);
+  return recordsCollection.get(recordId);
+}
+function setRecord(yDoc, storageName, recordId, state) {
+  const recordsCollection = getRecordsMap(yDoc, storageName);
+  const currentRecord = recordsCollection.get(recordId);
+  const wasExisting = currentRecord != null;
+  yDoc.transact(() => {
+    if (currentRecord != null) {
+      currentRecord.clear();
+      populateYMapFromState(currentRecord, state);
+    } else {
+      const newRecord = new Y.Map();
+      populateYMapFromState(newRecord, state);
+      recordsCollection.set(recordId, newRecord);
+    }
+  });
+  return wasExisting;
+}
+function getRecordSnapshot(yDoc, storageName, recordId) {
+  const data = getRecordData(yDoc, storageName, recordId);
+  if (!data) {
+    return void 0;
+  }
+  return yMapToState(data);
+}
+function updateRecord(yDoc, storageName, recordId, partialState) {
+  const recordsCollection = getRecordsMap(yDoc, storageName);
+  const currentRecord = recordsCollection.get(recordId);
+  if (currentRecord == null) {
+    return false;
+  }
+  yDoc.transact(() => {
+    updateYMapFromPartialState(currentRecord, partialState);
+  });
+  return true;
+}
+function getAllRecordIds(yDoc, storageName) {
+  const recordsCollection = getRecordsMap(yDoc, storageName);
+  return Array.from(recordsCollection.keys()).map((key) => key);
+}
+function populateYMapFromState(yMap, state) {
+  if (state != null && typeof state === "object") {
+    Object.entries(state).forEach(([key, value]) => {
+      if (value === void 0) return;
+      if (Array.isArray(value)) {
+        const yArray = new Y.Array();
+        value.forEach((item) => {
+          yArray.push([item]);
+        });
+        yMap.set(key, yArray);
+      } else if (typeof value === "object" && value != null) {
+        const nestedMap = new Y.Map();
+        populateYMapFromState(nestedMap, value);
+        yMap.set(key, nestedMap);
+      } else {
+        yMap.set(key, value);
+      }
+    });
+  }
+}
+function updateYMapFromPartialState(yMap, partialState) {
+  if (typeof partialState === "object") {
+    Object.entries(partialState).forEach(([key, value]) => {
+      if (value === void 0) {
+        yMap.delete(key);
+        return;
+      }
+      if (Array.isArray(value)) {
+        const yArray = new Y.Array();
+        value.forEach((item) => {
+          yArray.push([item]);
+        });
+        yMap.set(key, yArray);
+      } else if (typeof value === "object" && value != null) {
+        const existingValue = yMap.get(key);
+        if (existingValue instanceof Y.Map) {
+          updateYMapFromPartialState(existingValue, value);
+        } else {
+          const nestedMap = new Y.Map();
+          populateYMapFromState(nestedMap, value);
+          yMap.set(key, nestedMap);
+        }
+      } else {
+        yMap.set(key, value);
+      }
+    });
+  }
+}
+function yMapToState(yMap) {
+  const state = {};
+  yMap.forEach((value, key) => {
+    if (value instanceof Y.Array) {
+      state[key] = value.toArray();
+    } else if (value instanceof Y.Map) {
+      state[key] = yMapToState(value);
+    } else {
+      state[key] = value;
+    }
+  });
+  return state;
+}
+
+// src/service/BaseYjsDocumentService.ts
+var BaseYjsDocumentService = class {
+  documents = /* @__PURE__ */ new Map();
+  constructor(app, logger) {
+    this.app = app;
+    this.logger = logger;
+  }
+  createDocRef = (id, schema) => {
+    const temporaryRef = createDocRef(this.app, id, schema);
+    const {
+      internalDocRef
+    } = this.getCreateInternalDoc(temporaryRef);
+    return internalDocRef;
+  };
+  getCreateRecordCollectionRef = (docRef, model) => {
+    const {
+      internalDoc
+    } = this.getCreateInternalDoc(docRef);
+    const modelName = getMetadata(model).name;
+    const existingRef = internalDoc.collectionRefs.get(modelName)?.deref();
+    if (existingRef != null) {
+      return existingRef;
+    }
+    const newRef = createRecordCollectionRef(this, docRef, model);
+    internalDoc.collectionRefs.set(modelName, new WeakRef(newRef));
+    return newRef;
+  };
+  getCreateRecordRef = (docRef, id, model) => {
+    const {
+      internalDoc
+    } = this.getCreateInternalDoc(docRef);
+    const modelName = getMetadata(model).name;
+    let modelMap = internalDoc.recordRefs.get(modelName);
+    if (!modelMap) {
+      modelMap = /* @__PURE__ */ new Map();
+      internalDoc.recordRefs.set(modelName, modelMap);
+    }
+    const existingRef = modelMap.get(id)?.deref();
+    if (existingRef != null) {
+      return existingRef;
+    }
+    const newRef = createRecordRef(this, docRef, id, model);
+    modelMap.set(id, new WeakRef(newRef));
+    return newRef;
+  };
+  /**
+   * Called when the first metadata subscription is opened for a document.
+   * Implementation must:
+   * - Set status to LOADING immediately
+   * - Load/validate metadata asynchronously
+   * - Set status to LOADED or ERROR when complete
+   * - Handle all errors internally (never throw/reject)
+   */
+  /**
+   * Called when the first data subscription is opened for a document.
+   * Implementation must:
+   * - Set status to LOADING immediately
+   * - Set up data synchronization asynchronously
+   * - Set status to LOADED or ERROR when ready
+   * - Handle all errors internally (never throw/reject)
+   */
+  /**
+   * Called when the last metadata subscription is closed for a document.
+   * Implementation should clean up any resources related to metadata loading.
+   */
+  /**
+   * Called when the last data subscription is closed for a document.
+   * Implementation should clean up any resources related to data synchronization.
+   */
+  createBaseInternalDoc = (ref, metadata, yDoc) => {
+    const schema = ref.schema;
+    return {
+      ref: new WeakRef(ref),
+      metadata,
+      schema,
+      metadataStatus: {
+        load: metadata ? DocumentLoadStatus.LOADED : DocumentLoadStatus.UNLOADED,
+        live: DocumentLiveStatus.DISCONNECTED
+      },
+      dataStatus: {
+        load: DocumentLoadStatus.UNLOADED,
+        live: DocumentLiveStatus.DISCONNECTED
+      },
+      metadataError: void 0,
+      dataError: void 0,
+      statusSubscribers: /* @__PURE__ */ new Set(),
+      hasMetadataSubscriptions: false,
+      hasDataSubscriptions: false,
+      collectionRefs: /* @__PURE__ */ new Map(),
+      recordRefs: /* @__PURE__ */ new Map(),
+      collectionSubscriptions: /* @__PURE__ */ new Map(),
+      docStateSubscribers: /* @__PURE__ */ new Set(),
+      metadataSubscribers: /* @__PURE__ */ new Set(),
+      recordSubscriptions: /* @__PURE__ */ new Map(),
+      yDoc: yDoc || this.initializeYDoc(schema),
+      yDocUpdateHandler: void 0,
+      yjsCollectionHandlers: /* @__PURE__ */ new Map()
+    };
+  };
+  hasSubscriptions(internalDoc) {
+    if (internalDoc.metadataSubscribers.size > 0 || internalDoc.docStateSubscribers.size > 0) {
+      return true;
+    }
+    for (const subs of internalDoc.recordSubscriptions.values()) {
+      if (!subs.changed?.size || !subs.deleted?.size) {
+        return true;
+      }
+    }
+    return false;
+  }
+  // Status helper methods
+  notifyStatusSubscribers(internalDoc, docRef) {
+    const status = {
+      metadata: internalDoc.metadataStatus,
+      data: internalDoc.dataStatus,
+      metadataError: internalDoc.metadataError,
+      dataError: internalDoc.dataError
+    };
+    for (const callback of internalDoc.statusSubscribers) {
+      callback(docRef, status);
+    }
+  }
+  updateMetadataStatus(internalDoc, docRef, update) {
+    if (update.load != null || update.live != null) {
+      internalDoc.metadataStatus = {
+        load: update.load ?? internalDoc.metadataStatus.load,
+        live: update.live ?? internalDoc.metadataStatus.live
+      };
+    }
+    if (update.error != null) {
+      internalDoc.metadataError = update.error;
+    } else if (update.load === DocumentLoadStatus.LOADED) {
+      internalDoc.metadataError = void 0;
+    }
+    this.notifyStatusSubscribers(internalDoc, docRef);
+  }
+  updateDataStatus(internalDoc, docRef, update) {
+    if (update.load != null || update.live != null) {
+      internalDoc.dataStatus = {
+        load: update.load ?? internalDoc.dataStatus.load,
+        live: update.live ?? internalDoc.dataStatus.live
+      };
+    }
+    if (update.error != null) {
+      internalDoc.dataError = update.error;
+    } else if (update.load === DocumentLoadStatus.LOADED) {
+      internalDoc.dataError = void 0;
+    }
+    this.notifyStatusSubscribers(internalDoc, docRef);
+  }
+  /**
+   * Hook method called after a record is set. Subclasses can override to handle
+   * backend synchronization, logging, or other side effects.
+   */
+  /**
+   * Initialize a Y.Doc with the given schema
+   */
+  initializeYDoc(schema) {
+    const yDoc = new Y.Doc();
+    initializeDocumentStructure(yDoc, schema);
+    return yDoc;
+  }
+  /**
+   * Get existing internal doc or create one with placeholder metadata for lazy initialization
+   */
+  getCreateInternalDoc(ref, metadata, initialYDoc) {
+    const {
+      id,
+      schema
+    } = ref;
+    const existingDoc = this.documents.get(id);
+    if (existingDoc != null) {
+      !(existingDoc.schema === schema || isDeepEqual(existingDoc.schema, schema)) ? process.env.NODE_ENV !== "production" ? invariant(false, "Schema mismatch for existing document") : invariant(false) : void 0;
+      const existingRef = existingDoc.ref.deref();
+      if (existingRef == null) {
+        existingDoc.ref = new WeakRef(ref);
+      }
+      return {
+        internalDocRef: existingRef ?? ref,
+        internalDoc: existingDoc,
+        wasExisting: true
+      };
+    }
+    const internalDoc = this.createInternalDoc(ref, metadata, initialYDoc);
+    this.documents.set(id, internalDoc);
+    return {
+      internalDocRef: ref,
+      internalDoc,
+      wasExisting: false
+    };
+  }
+  getDocumentSnapshot = (docRef) => {
+    const {
+      internalDoc
+    } = this.getCreateInternalDoc(docRef);
+    return Promise.resolve(internalDoc.yDoc);
+  };
+  getRecordSnapshot = (recordRef) => {
+    const {
+      internalDoc
+    } = this.getCreateInternalDoc(recordRef.docRef);
+    const snapshot = this.getRecordSnapshotInternal(internalDoc, recordRef);
+    if (snapshot == null) {
+      return Promise.reject(new Error(`Record not found: ${recordRef.id}`));
+    }
+    return Promise.resolve(snapshot);
+  };
+  getRecordSnapshotInternal(internalDoc, recordRef) {
+    return getRecordSnapshot(internalDoc.yDoc, getMetadata(recordRef.model).name, recordRef.id);
+  }
+  setRecord = (recordRef, state) => {
+    const internalDoc = this.documents.get(recordRef.docRef.id);
+    !(internalDoc != null) ? process.env.NODE_ENV !== "production" ? invariant(false, `Cannot set record as document not found: ${recordRef.docRef.id}`) : invariant(false) : void 0;
+    setRecord(internalDoc.yDoc, getMetadata(recordRef.model).name, recordRef.id, state);
+    this.onRecordSet?.(recordRef, state);
+    return Promise.resolve();
+  };
+  updateRecord = (recordRef, partialState) => {
+    const internalDoc = this.documents.get(recordRef.docRef.id);
+    !(internalDoc != null) ? process.env.NODE_ENV !== "production" ? invariant(false, `Cannot update record as document not found: ${recordRef.docRef.id}`) : invariant(false) : void 0;
+    const wasUpdated = updateRecord(internalDoc.yDoc, getMetadata(recordRef.model).name, recordRef.id, partialState);
+    if (!wasUpdated) {
+      return Promise.reject(new Error(`Record not found for update: ${recordRef.id}`));
+    }
+    this.onRecordSet?.(recordRef, partialState);
+    return Promise.resolve();
+  };
+  onMetadataChange(docRef, callback) {
+    const {
+      internalDoc,
+      internalDocRef
+    } = this.getCreateInternalDoc(docRef);
+    const isFirstSubscription = !internalDoc.hasMetadataSubscriptions;
+    internalDoc.metadataSubscribers.add(callback);
+    internalDoc.hasMetadataSubscriptions = true;
+    if (isFirstSubscription && internalDoc.metadataStatus.load === DocumentLoadStatus.UNLOADED) {
+      this.onMetadataSubscriptionOpened(internalDoc, internalDocRef);
+    }
+    if (internalDoc.metadata != null) {
+      callback(docRef, internalDoc.metadata);
+    }
+    return () => {
+      const currentDoc = this.documents.get(docRef.id);
+      if (currentDoc) {
+        currentDoc.metadataSubscribers.delete(callback);
+        if (currentDoc.metadataSubscribers.size === 0) {
+          currentDoc.hasMetadataSubscriptions = false;
+          this.onMetadataSubscriptionClosed(currentDoc, internalDocRef);
+        }
+      }
+    };
+  }
+  onStateChange = (docRef, callback) => {
+    const {
+      internalDoc,
+      internalDocRef
+    } = this.getCreateInternalDoc(docRef);
+    const isFirstDataSubscription = !internalDoc.hasDataSubscriptions;
+    const isFirstStateSubscription = internalDoc.docStateSubscribers.size === 0;
+    internalDoc.docStateSubscribers.add(callback);
+    internalDoc.hasDataSubscriptions = true;
+    if (isFirstDataSubscription && internalDoc.dataStatus.load === DocumentLoadStatus.UNLOADED) {
+      this.onDataSubscriptionOpened(internalDoc, internalDocRef);
+    }
+    if (isFirstStateSubscription && !internalDoc.yDocUpdateHandler) {
+      const updateHandler = () => {
+        this.notifyStateSubscribers(internalDoc, docRef);
+      };
+      internalDoc.yDoc.on("update", updateHandler);
+      internalDoc.yDocUpdateHandler = updateHandler;
+    }
+    callback(internalDocRef);
+    return () => {
+      const currentDoc = this.documents.get(docRef.id);
+      if (!currentDoc) return;
+      currentDoc.docStateSubscribers.delete(callback);
+      if (currentDoc.docStateSubscribers.size === 0 && currentDoc.yDocUpdateHandler) {
+        currentDoc.yDoc.off("update", currentDoc.yDocUpdateHandler);
+        currentDoc.yDocUpdateHandler = void 0;
+      }
+      const hasDataSubs = currentDoc.docStateSubscribers.size > 0 || currentDoc.recordSubscriptions.size > 0 || Array.from(currentDoc.collectionSubscriptions.values()).some((subs) => subs.added?.size || subs.changed?.size || subs.deleted?.size);
+      if (!hasDataSubs) {
+        currentDoc.hasDataSubscriptions = false;
+        this.onDataSubscriptionClosed(currentDoc, internalDocRef);
+      }
+    };
+  };
+  getDocumentRef(docId) {
+    const internalDoc = this.documents.get(docId);
+    if (!internalDoc) return null;
+    return createDocRef(this.app, docId, internalDoc.schema);
+  }
+  notifyMetadataSubscribers(internalDoc, docRef, metadata) {
+    for (const callback of internalDoc.metadataSubscribers) {
+      callback(docRef, metadata);
+    }
+  }
+  notifyStateSubscribers(internalDoc, docRef) {
+    for (const callback of internalDoc.docStateSubscribers) {
+      callback(docRef);
+    }
+  }
+  updateMetadata(docId, metadata) {
+    const internalDoc = this.documents.get(docId);
+    if (internalDoc) {
+      internalDoc.metadata = metadata;
+      const docRef = this.getDocumentRef(docId);
+      if (docRef) {
+        this.notifyMetadataSubscribers(internalDoc, docRef, metadata);
+      }
+    }
+  }
+  notifyCollectionSubscribers(internalDoc, collection, recordId, changeType) {
+    const storageName = getMetadata(collection.model).name;
+    const subs = internalDoc.collectionSubscriptions.get(storageName);
+    if (!subs) {
+      return;
+    }
+    const subscribers = subs[changeType];
+    if (subscribers == null || subscribers.size === 0) {
+      return;
+    }
+    const recordRefInstance = this.getCreateRecordRef(collection.docRef, recordId, collection.model);
+    const records = [recordRefInstance];
+    for (const callback of subscribers) {
+      callback(records);
+    }
+  }
+  notifyRecordSubscribers(recordRef, changeType) {
+    const internalDoc = this.documents.get(recordRef.docRef.id);
+    !(internalDoc != null) ? process.env.NODE_ENV !== "production" ? invariant(false, "Document not found for record notifications") : invariant(false) : void 0;
+    const recordSubs = internalDoc.recordSubscriptions.get(recordRef.id);
+    if (recordSubs == null) {
+      return;
+    }
+    !(getMetadata(recordSubs.ref.model).name === getMetadata(recordRef.model).name) ? process.env.NODE_ENV !== "production" ? invariant(false, `Model mismatch when notifying record subscribers for ${recordRef.id}: expected ${getMetadata(recordSubs.ref.model).name}, got ${getMetadata(recordRef.model).name}`) : invariant(false) : void 0;
+    switch (changeType) {
+      case "changed": {
+        const snapshot = this.getRecordSnapshotInternal(internalDoc, recordRef);
+        for (const callback of recordSubs.changed ?? []) {
+          try {
+            callback(snapshot, recordRef);
+          } catch (e) {
+            console.error("Record onChanged callback threw unhandled error", e, {
+              model: getMetadata(recordRef.model).name,
+              id: recordRef.id
+            });
+          }
+        }
+        break;
+      }
+      case "deleted": {
+        for (const callback of recordSubs.deleted ?? []) {
+          try {
+            callback(recordRef);
+          } catch (e) {
+            console.error("Record onDeleted callback threw unhandled error", e, {
+              model: getMetadata(recordRef.model).name,
+              id: recordRef.id
+            });
+          }
+        }
+        break;
+      }
+    }
+  }
+  // Collection methods implementation
+  getRecord = (collection, id) => {
+    const internalDoc = this.documents.get(collection.docRef.id);
+    if (!internalDoc) return void 0;
+    const storageName = getMetadata(collection.model).name;
+    const recordExists = getRecordData(internalDoc.yDoc, storageName, id);
+    return recordExists ? this.getCreateRecordRef(collection.docRef, id, collection.model) : void 0;
+  };
+  hasRecord = (collection, id) => {
+    const internalDoc = this.documents.get(collection.docRef.id);
+    if (!internalDoc) return false;
+    const storageName = getMetadata(collection.model).name;
+    return getRecordData(internalDoc.yDoc, storageName, id) != null;
+  };
+  setCollectionRecord = (collection, id, state) => {
+    const recordRefInstance = this.getCreateRecordRef(collection.docRef, id, collection.model);
+    return this.setRecord(recordRefInstance, state);
+  };
+  deleteRecord = (record) => {
+    const internalDoc = this.documents.get(record.docRef.id);
+    if (!internalDoc) {
+      return Promise.resolve();
+    }
+    const storageName = getMetadata(record.model).name;
+    const recordsCollection = getRecordsMap(internalDoc.yDoc, storageName);
+    const existed = recordsCollection.has(record.id);
+    if (existed) {
+      recordsCollection.delete(record.id);
+    }
+    return Promise.resolve();
+  };
+  getCollectionSize = (collection) => {
+    const internalDoc = this.documents.get(collection.docRef.id);
+    if (!internalDoc) return 0;
+    const storageName = getMetadata(collection.model).name;
+    return getAllRecordIds(internalDoc.yDoc, storageName).length;
+  };
+  getCollectionRecords = (collection) => {
+    const internalDoc = this.documents.get(collection.docRef.id);
+    if (!internalDoc) return [];
+    const storageName = getMetadata(collection.model).name;
+    const recordIds = getAllRecordIds(internalDoc.yDoc, storageName);
+    return recordIds.map((id) => this.getCreateRecordRef(collection.docRef, id, collection.model));
+  };
+  onCollectionItemsAdded = (collection, callback) => {
+    const {
+      internalDoc,
+      internalDocRef
+    } = this.getCreateInternalDoc(collection.docRef);
+    return this.subscribeToCollectionChanges(internalDoc, internalDocRef, collection, "added", callback);
+  };
+  onCollectionItemsChanged = (collection, callback) => {
+    const {
+      internalDoc,
+      internalDocRef
+    } = this.getCreateInternalDoc(collection.docRef);
+    return this.subscribeToCollectionChanges(internalDoc, internalDocRef, collection, "changed", callback);
+  };
+  onCollectionItemsDeleted = (collection, callback) => {
+    const {
+      internalDoc,
+      internalDocRef
+    } = this.getCreateInternalDoc(collection.docRef);
+    return this.subscribeToCollectionChanges(internalDoc, internalDocRef, collection, "deleted", callback);
+  };
+  // TODO: clearer naming of subscription vs handlers etc.
+  onRecordChanged = (record, callback) => {
+    const {
+      internalDoc,
+      internalDocRef
+    } = this.getCreateInternalDoc(record.docRef);
+    const isFirstDataSubscription = !internalDoc.hasDataSubscriptions;
+    const storageName = getMetadata(record.model).name;
+    const collectionRef = this.getCreateRecordCollectionRef(record.docRef, record.model);
+    const needsCollectionListener = !internalDoc.yjsCollectionHandlers.has(storageName);
+    const recordSubs = this.getCreateRecordSubscriptions(internalDoc, record);
+    (recordSubs.changed ??= /* @__PURE__ */ new Set()).add(callback);
+    internalDoc.hasDataSubscriptions = true;
+    if (isFirstDataSubscription && internalDoc.dataStatus.load === DocumentLoadStatus.UNLOADED) {
+      this.onDataSubscriptionOpened(internalDoc, internalDocRef);
+    }
+    if (needsCollectionListener) {
+      this.getCreateCollectionSubscriptions(internalDoc, collectionRef);
+      this.setupCollectionListener(internalDoc, collectionRef);
+    }
+    const snapshot = this.getRecordSnapshotInternal(internalDoc, record);
+    if (snapshot != null) {
+      callback(snapshot, record);
+    }
+    return () => {
+      recordSubs.changed?.delete(callback);
+      const currentDoc = this.documents.get(record.docRef.id);
+      if (!currentDoc) return;
+      if (isRecordSubscriptionsEmpty(recordSubs)) {
+        currentDoc.recordSubscriptions.delete(record.id);
+      }
+      this.cleanupCollectionListenerIfUnused(currentDoc, record.docRef.id, storageName);
+      const hasDataSubs = currentDoc.docStateSubscribers.size > 0 || currentDoc.recordSubscriptions.size > 0 || Array.from(currentDoc.collectionSubscriptions.values()).some((subs) => subs.added?.size || subs.changed?.size || subs.deleted?.size);
+      if (!hasDataSubs) {
+        currentDoc.hasDataSubscriptions = false;
+        this.onDataSubscriptionClosed(currentDoc, internalDocRef);
+      }
+    };
+  };
+  onRecordDeleted = (record, callback) => {
+    const {
+      internalDoc,
+      internalDocRef
+    } = this.getCreateInternalDoc(record.docRef);
+    const isFirstDataSubscription = !internalDoc.hasDataSubscriptions;
+    const storageName = getMetadata(record.model).name;
+    const collectionRef = this.getCreateRecordCollectionRef(record.docRef, record.model);
+    const needsCollectionListener = !internalDoc.yjsCollectionHandlers.has(storageName);
+    const recordSubs = this.getCreateRecordSubscriptions(internalDoc, record);
+    (recordSubs.deleted ??= /* @__PURE__ */ new Set()).add(callback);
+    internalDoc.hasDataSubscriptions = true;
+    if (isFirstDataSubscription && internalDoc.dataStatus.load === DocumentLoadStatus.UNLOADED) {
+      this.onDataSubscriptionOpened(internalDoc, internalDocRef);
+    }
+    if (needsCollectionListener) {
+      this.getCreateCollectionSubscriptions(internalDoc, collectionRef);
+      this.setupCollectionListener(internalDoc, collectionRef);
+    }
+    return () => {
+      recordSubs.deleted?.delete(callback);
+      const currentDoc = this.documents.get(record.docRef.id);
+      if (!currentDoc) return;
+      if (isRecordSubscriptionsEmpty(recordSubs)) {
+        currentDoc.recordSubscriptions.delete(record.id);
+      }
+      this.cleanupCollectionListenerIfUnused(currentDoc, record.docRef.id, storageName);
+      const hasDataSubs = currentDoc.docStateSubscribers.size > 0 || currentDoc.recordSubscriptions.size > 0 || Array.from(currentDoc.collectionSubscriptions.values()).some((subs) => subs.added?.size || subs.changed?.size || subs.deleted?.size);
+      if (!hasDataSubs) {
+        currentDoc.hasDataSubscriptions = false;
+        this.onDataSubscriptionClosed(currentDoc, internalDocRef);
+      }
+    };
+  };
+  getCreateCollectionSubscriptions(internalDoc, collection) {
+    const storageName = getMetadata(collection.model).name;
+    const docCollectionSubs = internalDoc.collectionSubscriptions.get(storageName) ?? internalDoc.collectionSubscriptions.set(storageName, {}).get(storageName);
+    return docCollectionSubs;
+  }
+  getCreateRecordSubscriptions(internalDoc, record) {
+    let recordSubs = internalDoc.recordSubscriptions.get(record.id);
+    if (!recordSubs) {
+      recordSubs = {
+        ref: record
+      };
+      internalDoc.recordSubscriptions.set(record.id, recordSubs);
+    } else {
+      if (getMetadata(recordSubs.ref.model).name !== getMetadata(record.model).name) {
+        throw new Error(`Model mismatch for record ${record.id}: expected ${getMetadata(recordSubs.ref.model).name}, got ${getMetadata(record.model).name}`);
+      }
+    }
+    return recordSubs;
+  }
+  subscribeToCollectionChanges(internalDoc, internalDocRef, collection, changeType, callback) {
+    const isFirstDataSubscription = !internalDoc.hasDataSubscriptions;
+    const modelSubscriptions = this.getCreateCollectionSubscriptions(internalDoc, collection);
+    const wasEmpty = isCollectionSubscriptionsEmpty(modelSubscriptions);
+    (modelSubscriptions[changeType] ??= /* @__PURE__ */ new Set()).add(callback);
+    internalDoc.hasDataSubscriptions = true;
+    if (isFirstDataSubscription && internalDoc.dataStatus.load === DocumentLoadStatus.UNLOADED) {
+      this.onDataSubscriptionOpened(internalDoc, internalDocRef);
+    }
+    if (wasEmpty) {
+      this.setupCollectionListener(internalDoc, collection);
+    }
+    return () => {
+      modelSubscriptions[changeType]?.delete(callback);
+      const currentDoc = this.documents.get(collection.docRef.id);
+      if (!currentDoc) return;
+      const storageName = getMetadata(collection.model).name;
+      this.cleanupCollectionListenerIfUnused(currentDoc, collection.docRef.id, storageName);
+      const hasDataSubs = currentDoc.docStateSubscribers.size > 0 || currentDoc.recordSubscriptions.size > 0 || Array.from(currentDoc.collectionSubscriptions.values()).some((subs) => subs.added?.size || subs.changed?.size || subs.deleted?.size);
+      if (!hasDataSubs) {
+        currentDoc.hasDataSubscriptions = false;
+        this.onDataSubscriptionClosed(currentDoc, internalDocRef);
+      }
+    };
+  }
+  setupCollectionListener(internalDoc, collection) {
+    const docId = collection.docRef.id;
+    const storageName = getMetadata(collection.model).name;
+    const yCollection = internalDoc.yDoc.getMap(storageName);
+    this.logger.debug("Setting up collection listener", {
+      docId,
+      storageName,
+      existingKeys: Array.from(yCollection.keys()),
+      allDocMaps: Array.from(internalDoc.yDoc.share.keys())
+    });
+    const eventHandler = (events) => {
+      this.logger.debug("Y.Map observeDeep fired", {
+        docId,
+        storageName,
+        eventCount: events.length
+      });
+      const currentDoc = this.documents.get(docId);
+      if (!currentDoc) return;
+      const subs = currentDoc.collectionSubscriptions.get(storageName);
+      if (!subs) return;
+      const addedKeys = /* @__PURE__ */ new Set();
+      const changedKeys = /* @__PURE__ */ new Set();
+      const deletedKeys = /* @__PURE__ */ new Set();
+      for (const event of events) {
+        if (event.target === yCollection) {
+          for (const [key, change] of event.changes.keys) {
+            switch (change.action) {
+              case "add":
+                addedKeys.add(key);
+                break;
+              case "update":
+                changedKeys.add(key);
+                break;
+              case "delete":
+                deletedKeys.add(key);
+                break;
+            }
+          }
+        } else {
+          const recordId = event.path[0];
+          if (recordId != null) {
+            changedKeys.add(recordId);
+          }
+        }
+      }
+      if (addedKeys.size > 0) {
+        const addedRecords = Array.from(addedKeys).map((id) => this.getCreateRecordRef(collection.docRef, id, collection.model));
+        if (subs.added != null) {
+          for (const callback of subs.added) {
+            callback(addedRecords);
+          }
+        }
+        for (const record of addedRecords) {
+          this.notifyRecordSubscribers(record, "changed");
+        }
+      }
+      if (changedKeys.size > 0) {
+        const changedRecords = Array.from(changedKeys).map((id) => this.getCreateRecordRef(collection.docRef, id, collection.model));
+        if (subs.changed != null) {
+          for (const callback of subs.changed) {
+            callback(changedRecords);
+          }
+        }
+        for (const record of changedRecords) {
+          this.notifyRecordSubscribers(record, "changed");
+        }
+      }
+      if (deletedKeys.size > 0) {
+        const deletedRecords = Array.from(deletedKeys).map((id) => this.getCreateRecordRef(collection.docRef, id, collection.model));
+        if (subs.deleted?.size) {
+          for (const callback of subs.deleted) {
+            callback(deletedRecords);
+          }
+        }
+        for (const record of deletedRecords) {
+          this.notifyRecordSubscribers(record, "deleted");
+        }
+      }
+    };
+    yCollection.observeDeep(eventHandler);
+    internalDoc.yjsCollectionHandlers.set(storageName, () => {
+      yCollection.unobserveDeep(eventHandler);
+    });
+  }
+  cleanupCollectionListener(docId, storageName) {
+    const internalDoc = this.documents.get(docId);
+    if (internalDoc == null) {
+      return;
+    }
+    const cleanup = internalDoc.yjsCollectionHandlers.get(storageName);
+    if (cleanup != null) {
+      cleanup();
+      internalDoc.yjsCollectionHandlers.delete(storageName);
+    }
+  }
+  cleanupCollectionListenerIfUnused(internalDoc, docId, storageName) {
+    const collectionSubs = internalDoc.collectionSubscriptions.get(storageName);
+    const hasCollectionSubs = collectionSubs != null && (collectionSubs.added?.size || collectionSubs.changed?.size || collectionSubs.deleted?.size);
+    const hasRecordSubs = Array.from(internalDoc.recordSubscriptions.values()).some((recordSubs) => getMetadata(recordSubs.ref.model).name === storageName && !isRecordSubscriptionsEmpty(recordSubs));
+    if (!hasCollectionSubs && !hasRecordSubs) {
+      this.cleanupCollectionListener(docId, storageName);
+      if (collectionSubs != null) {
+        internalDoc.collectionSubscriptions.delete(storageName);
+      }
+    }
+  }
+  // DocumentService status methods implementation
+  getDocumentStatus = (docRef) => {
+    const {
+      internalDoc
+    } = this.getCreateInternalDoc(docRef);
+    return {
+      metadata: internalDoc.metadataStatus,
+      data: internalDoc.dataStatus,
+      metadataError: internalDoc.metadataError,
+      dataError: internalDoc.dataError
+    };
+  };
+  onStatusChange = (docRef, callback) => {
+    const {
+      internalDoc
+    } = this.getCreateInternalDoc(docRef);
+    internalDoc.statusSubscribers.add(callback);
+    const status = {
+      metadata: internalDoc.metadataStatus,
+      data: internalDoc.dataStatus,
+      metadataError: internalDoc.metadataError,
+      dataError: internalDoc.dataError
+    };
+    callback(docRef, status);
+    return () => {
+      const currentDoc = this.documents.get(docRef.id);
+      if (currentDoc) {
+        currentDoc.statusSubscribers.delete(callback);
+      }
+    };
+  };
+  waitForMetadataLoad = async (docRef) => {
+    const {
+      internalDoc
+    } = this.getCreateInternalDoc(docRef);
+    if (internalDoc.metadataStatus.load === DocumentLoadStatus.LOADED) {
+      return Promise.resolve();
+    }
+    if (internalDoc.metadataStatus.load === DocumentLoadStatus.ERROR) {
+      return Promise.reject(new Error("Metadata load error", {
+        cause: internalDoc.metadataError
+      }));
+    }
+    return new Promise((resolve, reject) => {
+      const unsubscribe = this.onStatusChange(docRef, (_, status) => {
+        if (status.metadata.load === DocumentLoadStatus.LOADED) {
+          unsubscribe();
+          resolve();
+        } else if (status.metadata.load === DocumentLoadStatus.ERROR) {
+          unsubscribe();
+          reject(new Error("Metadata load error", {
+            cause: status.metadataError
+          }));
+        }
+      });
+    });
+  };
+  waitForDataLoad = async (docRef) => {
+    const {
+      internalDoc
+    } = this.getCreateInternalDoc(docRef);
+    if (internalDoc.dataStatus.load === DocumentLoadStatus.LOADED) {
+      return Promise.resolve();
+    }
+    if (internalDoc.dataStatus.load === DocumentLoadStatus.ERROR) {
+      return Promise.reject(new Error("Data load error", {
+        cause: internalDoc.dataError
+      }));
+    }
+    return new Promise((resolve, reject) => {
+      const unsubscribe = this.onStatusChange(docRef, (_, status) => {
+        if (status.data.load === DocumentLoadStatus.LOADED) {
+          unsubscribe();
+          resolve();
+        } else if (status.data.load === DocumentLoadStatus.ERROR) {
+          unsubscribe();
+          reject(new Error("Data load error", {
+            cause: status.dataError
+          }));
+        }
+      });
+    });
+  };
+  // FIXME: don't expose in production builds
+  /**
+   * @internal
+   */
+  getYDocForTesting(docId) {
+    const internalDoc = this.documents.get(docId);
+    return internalDoc ? internalDoc.yDoc : null;
+  }
+};
+function isCollectionSubscriptionsEmpty(subs) {
+  return !subs.added?.size && !subs.changed?.size && !subs.deleted?.size;
+}
+function isRecordSubscriptionsEmpty(subs) {
+  return !subs.changed?.size && !subs.deleted?.size;
+}
+function createInMemoryDocumentServiceConfig({
+  autoCreateDocuments = true
+} = {}) {
+  const config = {
+    autoCreateDocuments
+  };
+  return createDocumentServiceConfig(internalCreateInMemoryDocumentService, config);
+}
+function internalCreateInMemoryDocumentService(app, options) {
+  return new InMemoryDocumentService(app, options);
+}
+var InMemoryDocumentService = class extends BaseYjsDocumentService {
+  constructor(app, config) {
+    super(app, app.config.logger.child({}, {
+      level: "debug",
+      msgPrefix: "InMemoryDocumentService"
+    }));
+    this.config = config;
+  }
+  createInternalDoc(ref, metadata, yDoc) {
+    return this.createBaseInternalDoc(ref, metadata, yDoc);
+  }
+  get hasMetadataSubscriptions() {
+    return Array.from(this.documents.values()).some((doc) => this.hasSubscriptions(doc) && doc.metadataSubscribers.size > 0);
+  }
+  get hasStateSubscriptions() {
+    return Array.from(this.documents.values()).some((doc) => this.hasSubscriptions(doc) && doc.docStateSubscribers.size > 0);
+  }
+  createDocument = (metadata, schema) => {
+    const id = generateDocumentId();
+    const docRef = createDocRef(this.app, id, schema);
+    const yDoc = this.initializeYDoc(schema);
+    this.getCreateInternalDoc(docRef, metadata, yDoc);
+    return Promise.resolve(docRef);
+  };
+  // Lifecycle method implementations
+  onMetadataSubscriptionOpened(internalDoc, docRef) {
+    this.updateMetadataStatus(internalDoc, docRef, {
+      load: DocumentLoadStatus.LOADING
+    });
+    if (this.config.autoCreateDocuments === false && internalDoc.metadata == null) {
+      this.updateMetadataStatus(internalDoc, docRef, {
+        error: new Error("Document not found and autoCreateDocuments is disabled"),
+        load: DocumentLoadStatus.ERROR
+      });
+      return;
+    }
+    this.updateMetadataStatus(internalDoc, docRef, {
+      load: DocumentLoadStatus.LOADED
+    });
+  }
+  onDataSubscriptionOpened(internalDoc, docRef) {
+    this.updateDataStatus(internalDoc, docRef, {
+      load: DocumentLoadStatus.LOADING
+    });
+    if (this.config.autoCreateDocuments === false && internalDoc.metadata == null) {
+      this.updateDataStatus(internalDoc, docRef, {
+        error: new Error("Document not found and autoCreateDocuments is disabled"),
+        load: DocumentLoadStatus.ERROR
+      });
+      return;
+    }
+    this.updateDataStatus(internalDoc, docRef, {
+      load: DocumentLoadStatus.LOADED
+    });
+  }
+  onMetadataSubscriptionClosed(_internalDoc, _docRef) {
+  }
+  onDataSubscriptionClosed(_internalDoc, _docRef) {
+  }
+};
+function generateDocumentId() {
+  return generateId();
+}
+
+export { BaseYjsDocumentService, DocumentLiveStatus, DocumentLoadStatus, STATE_MODULE_ACCESSOR, createDocRef, createDocumentServiceConfig, createInMemoryDocumentServiceConfig, createRecordCollectionRef, createRecordRef, getDocumentService, getStateModule, invalidDocRef, invalidRecordCollectionRef, invalidRecordRef, isValidDocRef, isValidRecordCollectionRef, isValidRecordRef };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map