@mnaoumov/obsidian-lib 6.3.0 → 7.1.0

package/dist/lib/esm/components/incremental-file-index-component.mjs

@@ -0,0 +1,260 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+(function () {
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return "/";
+    },
+    env: {},
+    platform: "android"
+  };
+  const existingProcess = globalThis.process;
+  if (!existingProcess) {
+    globalThis.process = browserProcess;
+    return;
+  }
+  if (existingProcess.versions?.node) {
+    return;
+  }
+  const existingProcessRecord = existingProcess;
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+  existingProcessRecord["browser"] = true;
+}
+
+ensureBrowserProcess();
+})();
+
+import { invokeAsyncSafely } from "@mnaoumov/typescript-lib/async";
+import {
+  noop,
+  noopAsync
+} from "@mnaoumov/typescript-lib/function";
+import {
+  debounce,
+  TFile,
+  TFolder,
+  Vault
+} from "obsidian";
+import { ComponentEx } from "./component-ex.mjs";
+const SAVE_DEBOUNCE_IN_MILLISECONDS = 5e3;
+class IncrementalFileIndexComponent extends ComponentEx {
+  /**
+   * Whether startup reconciliation has completed.
+   *
+   * @returns Whether the index completed its first reconciliation.
+   */
+  get isBuilt() {
+    return this.isBuiltValue;
+  }
+  /**
+   * Projection, notifications and persistence supplied by the consumer.
+   */
+  options;
+  isBuiltValue = false;
+  readTail = noopAsync();
+  records = /* @__PURE__ */ new Map();
+  requestSave;
+  revision = 0;
+  revisions = /* @__PURE__ */ new WeakMap();
+  savedRevision = 0;
+  savePromise = null;
+  /**
+   * Creates an index with consumer-owned projection and persistence.
+   *
+   * @param params - The index dependencies.
+   */
+  constructor(params) {
+    super();
+    this.options = { accepts: params.accepts, app: params.app, indexFile: params.indexFile, load: params.load, onRemove: params.onRemove, onSet: params.onSet, save: params.save };
+    this.requestSave = debounce(
+      () => {
+        invokeAsyncSafely(() => this.flush());
+      },
+      SAVE_DEBOUNCE_IN_MILLISECONDS,
+      false
+    );
+  }
+  /**
+   * Saves a snapshot after previous writes finish, including changes arriving during a write.
+   *
+   * @returns Completion of the serialized writes; rejects on persistence failure without marking it saved.
+   */
+  async flush() {
+    if (this.savePromise) {
+      await this.savePromise;
+      return;
+    }
+    this.savePromise = this.saveChanges();
+    try {
+      await this.savePromise;
+    } finally {
+      this.savePromise = null;
+    }
+  }
+  /**
+   * Returns a shallow snapshot; consumers must treat records as immutable.
+   *
+   * @returns Current records by vault-relative path.
+   */
+  getRecords() {
+    return new Map(this.records);
+  }
+  /**
+   * Registers changes before startup restoration.
+   */
+  onload() {
+    const { app } = this.options;
+    this.registerEvent(app.metadataCache.on("changed", (file, content) => {
+      this.setText(file, content);
+    }));
+    this.registerEvent(app.vault.on("create", this.queueScan.bind(this)));
+    this.registerEvent(app.vault.on("modify", this.queueScan.bind(this)));
+    this.registerEvent(app.vault.on("delete", (file) => {
+      if (file instanceof TFile) {
+        this.removeRecord(file.path);
+      } else {
+        this.removeTree(file.path);
+      }
+    }));
+    this.registerEvent(app.vault.on("rename", (file, oldPath) => {
+      this.rename(file, oldPath);
+    }));
+  }
+  /**
+   * Reuses unchanged saved records and reads other files one at a time.
+   *
+   * @returns Completion of startup reconciliation.
+   */
+  async onloadAsync() {
+    const saved = await this.options.load();
+    for (const file of this.options.app.vault.getFiles()) {
+      if (this.isUnloaded()) {
+        return;
+      }
+      if (!this.options.accepts(file) || this.revisions.has(file) || this.options.app.vault.getFileByPath(file.path) !== file) {
+        continue;
+      }
+      const entry = saved.get(file.path);
+      if (entry?.mtime === file.stat.mtime && entry.size === file.stat.size) {
+        this.setRecord(file.path, entry);
+      } else {
+        await this.scanFile(file);
+      }
+    }
+    await this.readTail;
+    if (this.isUnloaded()) {
+      return;
+    }
+    this.isBuiltValue = true;
+    this.markDirty();
+  }
+  /**
+   * Cancels the debounce and flushes completed indexes before disposing event listeners.
+   */
+  onunload() {
+    this.requestSave.cancel();
+    if (this.isBuiltValue) {
+      invokeAsyncSafely(() => this.flush());
+    }
+    super.onunload();
+  }
+  /**
+   * Rebuilds projections for every accepted file, for example after a consumer learns new names to find in text.
+   * Events arriving during the scan supersede its older reads. Consumers coordinate any domain scan markers.
+   *
+   * @returns Completion of the bounded full scan.
+   */
+  async rescan() {
+    for (const file of this.options.app.vault.getFiles()) {
+      await this.scanFile(file);
+    }
+  }
+  markDirty() {
+    this.revision++;
+    if (this.isBuiltValue && !this.isUnloaded()) {
+      this.requestSave();
+    }
+  }
+  queueScan(file) {
+    if (file instanceof TFile) {
+      invokeAsyncSafely(() => this.scanFile(file));
+    }
+  }
+  removeRecord(path) {
+    if (!this.records.delete(path)) {
+      return;
+    }
+    this.options.onRemove(path);
+    this.markDirty();
+  }
+  removeTree(path) {
+    for (const key of this.records.keys()) {
+      if (!(key === path || key.startsWith(`${path}/`))) {
+        continue;
+      }
+      this.removeRecord(key);
+    }
+  }
+  rename(file, oldPath) {
+    if (file instanceof TFile) {
+      this.removeRecord(oldPath);
+    } else {
+      this.removeTree(oldPath);
+    }
+    this.queueScan(file);
+    if (file instanceof TFolder) {
+      Vault.recurseChildren(file, this.queueScan.bind(this));
+    }
+  }
+  async saveChanges() {
+    while (this.isBuiltValue && this.savedRevision !== this.revision) {
+      const revision = this.revision;
+      await this.options.save(new Map(this.records));
+      this.savedRevision = revision;
+    }
+  }
+  async scanFile(file) {
+    if (this.isUnloaded() || !this.options.accepts(file)) {
+      return;
+    }
+    this.removeRecord(file.path);
+    const token = {};
+    this.revisions.set(file, token);
+    const { path } = file;
+    const { mtime, size } = file.stat;
+    const isCurrent = () => !this.isUnloaded() && this.revisions.get(file) === token && file.path === path && file.stat.mtime === mtime && file.stat.size === size && this.options.app.vault.getFileByPath(path) === file;
+    const read = this.readTail.then(async () => {
+      if (!isCurrent()) {
+        return;
+      }
+      const content = await this.options.app.vault.cachedRead(file);
+      if (!isCurrent()) {
+        return;
+      }
+      this.setText(file, content);
+    });
+    this.readTail = read.catch(noop);
+    await read;
+  }
+  setRecord(path, entry) {
+    this.records.set(path, entry);
+    this.options.onSet(path, entry.record);
+    this.markDirty();
+  }
+  setText(file, content) {
+    this.revisions.set(file, {});
+    if (!this.isUnloaded() && this.options.accepts(file)) {
+      this.setRecord(file.path, { mtime: file.stat.mtime, record: this.options.indexFile({ content, file }), size: file.stat.size });
+    }
+  }
+}
+export {
+  IncrementalFileIndexComponent
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/components/incremental-file-index-component.ts"],"sourcesContent":["/**\n * @file\n *\n * Incremental per-file projections with stat-based restoration and injected persistence.\n */\n\nimport type {\n  App,\n  Debouncer,\n  TAbstractFile\n} from 'obsidian';\n\nimport { invokeAsyncSafely } from '@mnaoumov/typescript-lib/async';\nimport {\n  noop,\n  noopAsync\n} from '@mnaoumov/typescript-lib/function';\nimport {\n  debounce,\n  TFile,\n  TFolder,\n  Vault\n} from 'obsidian';\n\nimport { ComponentEx } from './component-ex.ts';\n\nconst SAVE_DEBOUNCE_IN_MILLISECONDS = 5000;\n\n/**\n * Dependencies of an incremental index. Persistence must validate its own schema.\n *\n * @typeParam T - The immutable per-file projection.\n */\nexport interface IncrementalFileIndexComponentConstructorParams<T> {\n  /**\n   * Files accepted by this index, for example Markdown files only.\n   */\n  readonly accepts: (file: TFile) => boolean;\n  /**\n   * The application owning the vault.\n   */\n  readonly app: App;\n  /**\n   * Builds an immutable record synchronously; text is never retained by this component.\n   */\n  readonly indexFile: (params: IndexFileParams) => T;\n  /**\n   * Reads validated records, or an empty map for a missing/incompatible cache.\n   */\n  readonly load: () => Promise<ReadonlyMap<string, IndexedFileRecord<T>>>;\n  /**\n   * Removes a record from a consumer's secondary index. Called for known records only.\n   */\n  readonly onRemove: (path: string) => void;\n  /**\n   * Updates a consumer's secondary index, including restored records.\n   */\n  readonly onSet: (path: string, record: T) => void;\n  /**\n   * Persists a snapshot; writes are serialized and retried by the next flush after failure.\n   */\n  readonly save: (records: ReadonlyMap<string, IndexedFileRecord<T>>) => Promise<void>;\n}\n\n/**\n * A projection and the file stats observed before reading its text.\n *\n * @typeParam T - The immutable per-file projection.\n */\nexport interface IndexedFileRecord<T> {\n  /**\n   * Last modification time, in milliseconds.\n   */\n  readonly mtime: number;\n  /**\n   * The consumer's immutable projection.\n   */\n  readonly record: T;\n  /**\n   * File size in bytes.\n   */\n  readonly size: number;\n}\n\n/**\n * Inputs to a per-file projection.\n */\nexport interface IndexFileParams {\n  /**\n   * Text read from the vault, or supplied by a metadata-cache event.\n   */\n  readonly content: string;\n  /**\n   * The file being indexed.\n   */\n  readonly file: TFile;\n}\n\n/**\n * Keeps per-file projections current while loaded. Call loadWithPromises after metadata readiness if the\n * projection needs cached metadata. Listeners are installed before restoration, and events win over older reads.\n * Reads are sequential, bounding memory and I/O; consumers own schema, storage location and secondary indexes.\n * Unchanged records are reused by mtime and size, which cannot detect a same-stat external rewrite.\n *\n * @typeParam T - The immutable per-file projection.\n */\nexport class IncrementalFileIndexComponent<T> extends ComponentEx {\n  /**\n   * Whether startup reconciliation has completed.\n   *\n   * @returns Whether the index completed its first reconciliation.\n   */\n  public get isBuilt(): boolean {\n    return this.isBuiltValue;\n  }\n\n  /**\n   * Projection, notifications and persistence supplied by the consumer.\n   */\n  protected readonly options: IncrementalFileIndexComponentConstructorParams<T>;\n\n  private isBuiltValue = false;\n  private readTail: Promise<void> = noopAsync();\n  private readonly records = new Map<string, IndexedFileRecord<T>>();\n  private readonly requestSave: Debouncer<[], void>;\n  private revision = 0;\n  private readonly revisions = new WeakMap<TFile, object>();\n  private savedRevision = 0;\n  private savePromise: null | Promise<void> = null;\n\n  /**\n   * Creates an index with consumer-owned projection and persistence.\n   *\n   * @param params - The index dependencies.\n   */\n  public constructor(params: IncrementalFileIndexComponentConstructorParams<T>) {\n    super();\n    this.options = { accepts: params.accepts, app: params.app, indexFile: params.indexFile, load: params.load, onRemove: params.onRemove, onSet: params.onSet, save: params.save };\n    this.requestSave = debounce(\n      () => {\n        invokeAsyncSafely(() => this.flush());\n      },\n      SAVE_DEBOUNCE_IN_MILLISECONDS,\n      false\n    );\n  }\n\n  /**\n   * Saves a snapshot after previous writes finish, including changes arriving during a write.\n   *\n   * @returns Completion of the serialized writes; rejects on persistence failure without marking it saved.\n   */\n  public async flush(): Promise<void> {\n    if (this.savePromise) {\n      await this.savePromise;\n      return;\n    }\n    this.savePromise = this.saveChanges();\n    try {\n      await this.savePromise;\n    } finally {\n      this.savePromise = null;\n    }\n  }\n\n  /**\n   * Returns a shallow snapshot; consumers must treat records as immutable.\n   *\n   * @returns Current records by vault-relative path.\n   */\n  public getRecords(): ReadonlyMap<string, IndexedFileRecord<T>> {\n    return new Map(this.records);\n  }\n\n  /**\n   * Registers changes before startup restoration.\n   */\n  public override onload(): void {\n    const { app } = this.options;\n    this.registerEvent(app.metadataCache.on('changed', (file, content) => {\n      this.setText(file, content);\n    }));\n\n    this.registerEvent(app.vault.on('create', this.queueScan.bind(this)));\n    this.registerEvent(app.vault.on('modify', this.queueScan.bind(this)));\n    this.registerEvent(app.vault.on('delete', (file) => {\n      if (file instanceof TFile) {\n        this.removeRecord(file.path);\n      } else {\n        this.removeTree(file.path);\n      }\n    }));\n    this.registerEvent(app.vault.on('rename', (file, oldPath) => {\n      this.rename(file, oldPath);\n    }));\n  }\n\n  /**\n   * Reuses unchanged saved records and reads other files one at a time.\n   *\n   * @returns Completion of startup reconciliation.\n   */\n  public override async onloadAsync(): Promise<void> {\n    const saved = await this.options.load();\n    for (const file of this.options.app.vault.getFiles()) {\n      if (this.isUnloaded()) {\n        return;\n      }\n      if (!this.options.accepts(file) || this.revisions.has(file) || this.options.app.vault.getFileByPath(file.path) !== file) {\n        continue;\n      }\n      const entry = saved.get(file.path);\n      if (entry?.mtime === file.stat.mtime && entry.size === file.stat.size) {\n        this.setRecord(file.path, entry);\n      } else {\n        await this.scanFile(file);\n      }\n    }\n    await this.readTail;\n    if (this.isUnloaded()) {\n      return;\n    }\n\n    this.isBuiltValue = true;\n    this.markDirty();\n  }\n\n  /**\n   * Cancels the debounce and flushes completed indexes before disposing event listeners.\n   */\n  public override onunload(): void {\n    this.requestSave.cancel();\n    if (this.isBuiltValue) {\n      invokeAsyncSafely(() => this.flush());\n    }\n    super.onunload();\n  }\n\n  /**\n   * Rebuilds projections for every accepted file, for example after a consumer learns new names to find in text.\n   * Events arriving during the scan supersede its older reads. Consumers coordinate any domain scan markers.\n   *\n   * @returns Completion of the bounded full scan.\n   */\n  public async rescan(): Promise<void> {\n    for (const file of this.options.app.vault.getFiles()) {\n      await this.scanFile(file);\n    }\n  }\n\n  private markDirty(): void {\n    this.revision++;\n    if (this.isBuiltValue && !this.isUnloaded()) {\n      this.requestSave();\n    }\n  }\n\n  private queueScan(file: TAbstractFile): void {\n    if (file instanceof TFile) {\n      invokeAsyncSafely(() => this.scanFile(file));\n    }\n  }\n\n  private removeRecord(path: string): void {\n    if (!this.records.delete(path)) {\n      return;\n    }\n\n    this.options.onRemove(path);\n    this.markDirty();\n  }\n\n  private removeTree(path: string): void {\n    for (const key of this.records.keys()) {\n      if (!(key === path || key.startsWith(`${path}/`))) {\n        continue;\n      }\n\n      this.removeRecord(key);\n    }\n  }\n\n  private rename(file: TAbstractFile, oldPath: string): void {\n    if (file instanceof TFile) {\n      this.removeRecord(oldPath);\n    } else {\n      this.removeTree(oldPath);\n    }\n    this.queueScan(file);\n    if (file instanceof TFolder) {\n      Vault.recurseChildren(file, this.queueScan.bind(this));\n    }\n  }\n\n  private async saveChanges(): Promise<void> {\n    while (this.isBuiltValue && this.savedRevision !== this.revision) {\n      const revision = this.revision;\n      await this.options.save(new Map(this.records));\n      this.savedRevision = revision;\n    }\n  }\n\n  private async scanFile(file: TFile): Promise<void> {\n    if (this.isUnloaded() || !this.options.accepts(file)) {\n      return;\n    }\n    this.removeRecord(file.path);\n    const token = {};\n    this.revisions.set(file, token);\n    const { path } = file;\n    const { mtime, size } = file.stat;\n    const isCurrent = (): boolean =>\n      !this.isUnloaded() && this.revisions.get(file) === token && file.path === path\n      && file.stat.mtime === mtime && file.stat.size === size && this.options.app.vault.getFileByPath(path) === file;\n    const read = this.readTail.then(async () => {\n      if (!isCurrent()) {\n        return;\n      }\n      const content = await this.options.app.vault.cachedRead(file);\n      if (!isCurrent()) {\n        return;\n      }\n      this.setText(file, content);\n    });\n    this.readTail = read.catch(noop);\n    await read;\n  }\n\n  private setRecord(path: string, entry: IndexedFileRecord<T>): void {\n    this.records.set(path, entry);\n    this.options.onSet(path, entry.record);\n    this.markDirty();\n  }\n\n  private setText(file: TFile, content: string): void {\n    this.revisions.set(file, {});\n    if (!this.isUnloaded() && this.options.accepts(file)) {\n      this.setRecord(file.path, { mtime: file.stat.mtime, record: this.options.indexFile({ content, file }), size: file.stat.size });\n    }\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/lib/esm/components/index.d.mts

@@ -11,6 +11,7 @@ export * as 'disposable-component' from './disposable-component.mjs';
 export * as 'embed-extensions-component' from './embed-extensions-component.mjs';
 export * as 'file-explorer-root-menu-component' from './file-explorer-root-menu-component.mjs';
 export * as 'generate-markdown-link-default-params-component' from './generate-markdown-link-default-params-component.mjs';
+export * as 'incremental-file-index-component' from './incremental-file-index-component.mjs';
 export * as 'layout-ready-component' from './layout-ready-component.mjs';
 export * as 'menu-event-registrar-component' from './menu-event-registrar-component.mjs';
 export * as 'monkey-around-component' from './monkey-around-component.mjs';

package/dist/lib/esm/components/index.mjs

@@ -15,6 +15,7 @@ import * as disposable_component from "./disposable-component.mjs";
 import * as embed_extensions_component from "./embed-extensions-component.mjs";
 import * as file_explorer_root_menu_component from "./file-explorer-root-menu-component.mjs";
 import * as generate_markdown_link_default_params_component from "./generate-markdown-link-default-params-component.mjs";
+import * as incremental_file_index_component from "./incremental-file-index-component.mjs";
 import * as layout_ready_component from "./layout-ready-component.mjs";
 import * as menu_event_registrar_component from "./menu-event-registrar-component.mjs";
 import * as monkey_around_component from "./monkey-around-component.mjs";
@@ -46,6 +47,7 @@ export {
   embed_extensions_component as "embed-extensions-component",
   file_explorer_root_menu_component as "file-explorer-root-menu-component",
   generate_markdown_link_default_params_component as "generate-markdown-link-default-params-component",
+  incremental_file_index_component as "incremental-file-index-component",
   layout_ready_component as "layout-ready-component",
   menu_event_registrar_component as "menu-event-registrar-component",
   monkey_around_component as "monkey-around-component",
@@ -65,4 +67,4 @@ export {
   syntax_highlighting_component as "syntax-highlighting-component",
   templates_language_component as "templates-language-component"
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vc3JjL2NvbXBvbmVudHMvaW5kZXgudHMiXSwKICAic291cmNlc0NvbnRlbnQiOiBbIi8qIFRISVMgSVMgQSBHRU5FUkFURUQvQlVORExFRCBGSUxFIEJZIEJVSUxEIFNDUklQVCAqL1xuXG5leHBvcnQgKiBhcyAnYWJvcnQtc2lnbmFsLWNvbXBvbmVudCcgZnJvbSAnLi9hYm9ydC1zaWduYWwtY29tcG9uZW50LnRzJztcbmV4cG9ydCAqIGFzICdhbGwtd2luZG93cy1ldmVudC1jb21wb25lbnQnIGZyb20gJy4vYWxsLXdpbmRvd3MtZXZlbnQtY29tcG9uZW50LnRzJztcbmV4cG9ydCAqIGFzICdhc3luYy1lcnJvci1oYW5kbGVyLWNvbXBvbmVudCcgZnJvbSAnLi9hc3luYy1lcnJvci1oYW5kbGVyLWNvbXBvbmVudC50cyc7XG5leHBvcnQgKiBhcyAnYXN5bmMtZXZlbnRzLWNvbXBvbmVudCcgZnJvbSAnLi9hc3luYy1ldmVudHMtY29tcG9uZW50LnRzJztcbmV4cG9ydCAqIGFzICdjYXNlLWluc2Vuc2l0aXZlLWZpbGUtaW5kZXgtY29tcG9uZW50JyBmcm9tICcuL2Nhc2UtaW5zZW5zaXRpdmUtZmlsZS1pbmRleC1jb21wb25lbnQudHMnO1xuZXhwb3J0ICogYXMgJ2NvbXBvbmVudC1leCcgZnJvbSAnLi9jb21wb25lbnQtZXgudHMnO1xuZXhwb3J0ICogYXMgJ2NvbnNvbGUtZGVidWctY29tcG9uZW50JyBmcm9tICcuL2NvbnNvbGUtZGVidWctY29tcG9uZW50LnRzJztcbmV4cG9ydCAqIGFzICdjb3JlLXBsdWdpbi10b2dnbGUtY29tcG9uZW50JyBmcm9tICcuL2NvcmUtcGx1Z2luLXRvZ2dsZS1jb21wb25lbnQudHMnO1xuZXhwb3J0ICogYXMgJ2Rpc3Bvc2FibGUtY29tcG9uZW50JyBmcm9tICcuL2Rpc3Bvc2FibGUtY29tcG9uZW50LnRzJztcbmV4cG9ydCAqIGFzICdlbWJlZC1leHRlbnNpb25zLWNvbXBvbmVudCcgZnJvbSAnLi9lbWJlZC1leHRlbnNpb25zLWNvbXBvbmVudC50cyc7XG5leHBvcnQgKiBhcyAnZmlsZS1leHBsb3Jlci1yb290LW1lbnUtY29tcG9uZW50JyBmcm9tICcuL2ZpbGUtZXhwbG9yZXItcm9vdC1tZW51LWNvbXBvbmVudC50cyc7XG5leHBvcnQgKiBhcyAnZ2VuZXJhdGUtbWFya2Rvd24tbGluay1kZWZhdWx0LXBhcmFtcy1jb21wb25lbnQnIGZyb20gJy4vZ2VuZXJhdGUtbWFya2Rvd24tbGluay1kZWZhdWx0LXBhcmFtcy1jb21wb25lbnQudHMnO1xuZXhwb3J0ICogYXMgJ2luY3JlbWVudGFsLWZpbGUtaW5kZXgtY29tcG9uZW50JyBmcm9tICcuL2luY3JlbWVudGFsLWZpbGUtaW5kZXgtY29tcG9uZW50LnRzJztcbmV4cG9ydCAqIGFzICdsYXlvdXQtcmVhZHktY29tcG9uZW50JyBmcm9tICcuL2xheW91dC1yZWFkeS1jb21wb25lbnQudHMnO1xuZXhwb3J0ICogYXMgJ21lbnUtZXZlbnQtcmVnaXN0cmFyLWNvbXBvbmVudCcgZnJvbSAnLi9tZW51LWV2ZW50LXJlZ2lzdHJhci1jb21wb25lbnQudHMnO1xuZXhwb3J0ICogYXMgJ21vbmtleS1hcm91bmQtY29tcG9uZW50JyBmcm9tICcuL21vbmtleS1hcm91bmQtY29tcG9uZW50LnRzJztcbmV4cG9ydCAqIGFzICdub3RlYm9vay1uYXZpZ2F0b3ItbWVudS1ldmVudC1yZWdpc3RyYXItY29tcG9uZW50JyBmcm9tICcuL25vdGVib29rLW5hdmlnYXRvci1tZW51LWV2ZW50LXJlZ2lzdHJhci1jb21wb25lbnQudHMnO1xuZXhwb3J0ICogYXMgJ3BsdWdpbi1jb250ZXh0LWNvbXBvbmVudCcgZnJvbSAnLi9wbHVnaW4tY29udGV4dC1jb21wb25lbnQudHMnO1xuZXhwb3J0ICogYXMgJ3BsdWdpbi1nYXRlLWNvbXBvbmVudCcgZnJvbSAnLi9wbHVnaW4tZ2F0ZS1jb21wb25lbnQudHMnO1xuZXhwb3J0ICogYXMgJ3BsdWdpbi1ub3RpY2UtY29tcG9uZW50JyBmcm9tICcuL3BsdWdpbi1ub3RpY2UtY29tcG9uZW50LnRzJztcbmV4cG9ydCAqIGFzICdwbHVnaW4tc2V0dGluZ3MtY29tcG9uZW50JyBmcm9tICcuL3BsdWdpbi1zZXR0aW5ncy1jb21wb25lbnQudHMnO1xuZXhwb3J0ICogYXMgJ3BsdWdpbi1zZXR0aW5ncy10YWItY29tcG9uZW50JyBmcm9tICcuL3BsdWdpbi1zZXR0aW5ncy10YWItY29tcG9uZW50LnRzJztcbmV4cG9ydCAqIGFzICdwbHVnaW4tc3VnZ2VzdGlvbi1jb21wb25lbnQnIGZyb20gJy4vcGx1Z2luLXN1Z2dlc3Rpb24tY29tcG9uZW50LnRzJztcbmV4cG9ydCAqIGFzICdwb2ludGVyLXBvc2l0aW9uLWNvbXBvbmVudCcgZnJvbSAnLi9wb2ludGVyLXBvc2l0aW9uLWNvbXBvbmVudC50cyc7XG5leHBvcnQgKiBhcyAncmVnaXN0cnktY29tcG9uZW50JyBmcm9tICcuL3JlZ2lzdHJ5LWNvbXBvbmVudC50cyc7XG5leHBvcnQgKiBhcyAncmVsZWFzZS1ub3Rlcy1jb21wb25lbnQnIGZyb20gJy4vcmVsZWFzZS1ub3Rlcy1jb21wb25lbnQudHMnO1xuZXhwb3J0ICogYXMgJ3JlbmFtZS1kZWxldGUtaGFuZGxlci1jb21wb25lbnQnIGZyb20gJy4vcmVuYW1lLWRlbGV0ZS1oYW5kbGVyLWNvbXBvbmVudC50cyc7XG5leHBvcnQgKiBhcyAncm1kaXItZ3VhcmQtY29tcG9uZW50JyBmcm9tICcuL3JtZGlyLWd1YXJkLWNvbXBvbmVudC50cyc7XG5leHBvcnQgKiBhcyAnc2V0dGluZ3MtbWlncmF0aW9uLWNvbXBvbmVudCcgZnJvbSAnLi9zZXR0aW5ncy1taWdyYXRpb24tY29tcG9uZW50LnRzJztcbmV4cG9ydCAqIGFzICdzeW50YXgtaGlnaGxpZ2h0aW5nLWNvbXBvbmVudCcgZnJvbSAnLi9zeW50YXgtaGlnaGxpZ2h0aW5nLWNvbXBvbmVudC50cyc7XG5leHBvcnQgKiBhcyAndGVtcGxhdGVzLWxhbmd1YWdlLWNvbXBvbmVudCcgZnJvbSAnLi90ZW1wbGF0ZXMtbGFuZ3VhZ2UtY29tcG9uZW50LnRzJztcbiJdLAogICJtYXBwaW5ncyI6ICI7Ozs7O0FBRUEsWUFBWUEsNEJBQThCO0FBQzFDLFlBQVlDLGlDQUFtQztBQUMvQyxZQUFZQyxtQ0FBcUM7QUFDakQsWUFBWUMsNEJBQThCO0FBQzFDLFlBQVlDLDJDQUE2QztBQUN6RCxZQUFZQyxrQkFBb0I7QUFDaEMsWUFBWUMsNkJBQStCO0FBQzNDLFlBQVlDLGtDQUFvQztBQUNoRCxZQUFZQywwQkFBNEI7QUFDeEMsWUFBWUMsZ0NBQWtDO0FBQzlDLFlBQVlDLHVDQUF5QztBQUNyRCxZQUFZQyxxREFBdUQ7QUFDbkUsWUFBWUMsc0NBQXdDO0FBQ3BELFlBQVlDLDRCQUE4QjtBQUMxQyxZQUFZQyxvQ0FBc0M7QUFDbEQsWUFBWUMsNkJBQStCO0FBQzNDLFlBQVlDLHVEQUF5RDtBQUNyRSxZQUFZQyw4QkFBZ0M7QUFDNUMsWUFBWUMsMkJBQTZCO0FBQ3pDLFlBQVlDLDZCQUErQjtBQUMzQyxZQUFZQywrQkFBaUM7QUFDN0MsWUFBWUMsbUNBQXFDO0FBQ2pELFlBQVlDLGlDQUFtQztBQUMvQyxZQUFZQyxnQ0FBa0M7QUFDOUMsWUFBWUMsd0JBQTBCO0FBQ3RDLFlBQVlDLDZCQUErQjtBQUMzQyxZQUFZQyxxQ0FBdUM7QUFDbkQsWUFBWUMsMkJBQTZCO0FBQ3pDLFlBQVlDLGtDQUFvQztBQUNoRCxZQUFZQyxtQ0FBcUM7QUFDakQsWUFBWUMsa0NBQW9DOyIsCiAgIm5hbWVzIjogWyJhYm9ydC1zaWduYWwtY29tcG9uZW50IiwgImFsbC13aW5kb3dzLWV2ZW50LWNvbXBvbmVudCIsICJhc3luYy1lcnJvci1oYW5kbGVyLWNvbXBvbmVudCIsICJhc3luYy1ldmVudHMtY29tcG9uZW50IiwgImNhc2UtaW5zZW5zaXRpdmUtZmlsZS1pbmRleC1jb21wb25lbnQiLCAiY29tcG9uZW50LWV4IiwgImNvbnNvbGUtZGVidWctY29tcG9uZW50IiwgImNvcmUtcGx1Z2luLXRvZ2dsZS1jb21wb25lbnQiLCAiZGlzcG9zYWJsZS1jb21wb25lbnQiLCAiZW1iZWQtZXh0ZW5zaW9ucy1jb21wb25lbnQiLCAiZmlsZS1leHBsb3Jlci1yb290LW1lbnUtY29tcG9uZW50IiwgImdlbmVyYXRlLW1hcmtkb3duLWxpbmstZGVmYXVsdC1wYXJhbXMtY29tcG9uZW50IiwgImluY3JlbWVudGFsLWZpbGUtaW5kZXgtY29tcG9uZW50IiwgImxheW91dC1yZWFkeS1jb21wb25lbnQiLCAibWVudS1ldmVudC1yZWdpc3RyYXItY29tcG9uZW50IiwgIm1vbmtleS1hcm91bmQtY29tcG9uZW50IiwgIm5vdGVib29rLW5hdmlnYXRvci1tZW51LWV2ZW50LXJlZ2lzdHJhci1jb21wb25lbnQiLCAicGx1Z2luLWNvbnRleHQtY29tcG9uZW50IiwgInBsdWdpbi1nYXRlLWNvbXBvbmVudCIsICJwbHVnaW4tbm90aWNlLWNvbXBvbmVudCIsICJwbHVnaW4tc2V0dGluZ3MtY29tcG9uZW50IiwgInBsdWdpbi1zZXR0aW5ncy10YWItY29tcG9uZW50IiwgInBsdWdpbi1zdWdnZXN0aW9uLWNvbXBvbmVudCIsICJwb2ludGVyLXBvc2l0aW9uLWNvbXBvbmVudCIsICJyZWdpc3RyeS1jb21wb25lbnQiLCAicmVsZWFzZS1ub3Rlcy1jb21wb25lbnQiLCAicmVuYW1lLWRlbGV0ZS1oYW5kbGVyLWNvbXBvbmVudCIsICJybWRpci1ndWFyZC1jb21wb25lbnQiLCAic2V0dGluZ3MtbWlncmF0aW9uLWNvbXBvbmVudCIsICJzeW50YXgtaGlnaGxpZ2h0aW5nLWNvbXBvbmVudCIsICJ0ZW1wbGF0ZXMtbGFuZ3VhZ2UtY29tcG9uZW50Il0KfQo=

package/dist/lib/esm/data-stores/data-store-replica.d.mts

@@ -0,0 +1,112 @@
+/// <reference path="../library-references.d.mts" />
+/**
+ * @file
+ *
+ * Merge-safe registers and observed-remove sets used by shared data stores.
+ */
+import type { JsonValue } from 'type-fest';
+/**
+ * A store fixes its merge rule for its entire lifetime and schema version.
+ */
+export type DataStoreMergeKind = 'last-write-wins' | 'maximum' | 'minimum' | 'observed-remove-set';
+/**
+ * A version-one journal operation. These fields form a published wire format.
+ */
+export interface DataStoreOperation {
+    /**
+     * Logical counter within the wall-clock millisecond.
+     */
+    readonly counter: number;
+    /**
+     * Whether this is a removal.
+     */
+    readonly deleted: boolean;
+    /**
+     * Unique writer incarnation, stored locally rather than in plugin settings.
+     */
+    readonly device: string;
+    /**
+     * Record key, or set member.
+     */
+    readonly key: string;
+    /**
+     * Strictly increasing writer sequence, starting at one.
+     */
+    readonly sequence: number;
+    /**
+     * Observed addition tags removed by a set operation.
+     */
+    readonly tags?: readonly string[];
+    /**
+     * Hybrid logical clock wall time.
+     */
+    readonly time: number;
+    /**
+     * JSON-compatible value; set members use `true`.
+     */
+    readonly value: unknown;
+}
+/**
+ * In-memory CRDT state. Exported operations can be joined in any order, repeatedly.
+ */
+export declare class DataStoreReplica {
+    protected readonly kind: DataStoreMergeKind;
+    private readonly additions;
+    private readonly registers;
+    private readonly removals;
+    /**
+     * Creates an empty replica.
+     *
+     * @param kind - Immutable merge rule for the store.
+     */
+    constructor(kind: DataStoreMergeKind);
+    /**
+     * Validates and joins one journal or snapshot operation.
+     *
+     * @param value - Untrusted parsed operation.
+     */
+    apply(value: unknown): void;
+    /**
+     * Reads visible records, detached from internal state.
+     *
+     * @returns Pairs in deterministic key order.
+     */
+    entries(): [string, unknown][];
+    /**
+     * Exports mergeable state, retaining tombstones for late or retired replicas.
+     *
+     * @returns Deterministically ordered operations sufficient to reconstruct this state.
+     */
+    export(): DataStoreOperation[];
+    /**
+     * Reads a register or set membership without enumerating register keys.
+     *
+     * @param key - Record key or set member.
+     * @returns A detached value, or `undefined` when absent or deleted.
+     */
+    get(key: string): unknown;
+    /**
+     * Finds additions observed for a set member, for an observed removal.
+     *
+     * @param key - Set member.
+     * @returns Addition identities. Concurrent unseen additions survive removal.
+     */
+    observedTags(key: string): string[];
+    private activeAdditions;
+    private applySet;
+    private wins;
+}
+/**
+ * Checks that a value survives JSON transport without changing its meaning.
+ *
+ * @param value - Candidate data-store value.
+ * @returns Whether it is finite, acyclic JSON data.
+ */
+export declare function isDataStoreJsonValue(value: unknown): value is JsonValue;
+/**
+ * Checks the version-one operation wire shape.
+ *
+ * @param value - Parsed JSON.
+ * @returns Whether the operation has valid identity and clock fields.
+ */
+export declare function isDataStoreOperation(value: unknown): value is DataStoreOperation;