@mnaoumov/obsidian-lib 10.7.0 → 10.9.0

package/dist/lib/cjs/data-stores/data-store-locations.cjs

@@ -0,0 +1,248 @@
+/*
+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();
+})();
+(function patchObsidianRequire() {
+  const originalRequire = require;
+  if (!originalRequire || originalRequire.__isPatched) {
+    return;
+  }
+  require = Object.assign(
+    (id) => requirePatched(id),
+    originalRequire,
+    {
+      __isPatched: true
+    }
+  );
+  function extractDefault($module) {
+    return $module && $module.__esModule && "default" in $module ? $module.default : $module;
+  }
+  const OBSIDIAN_BUILT_IN_MODULE_NAMES = /* @__PURE__ */ new Set([
+    "@codemirror/autocomplete",
+    "@codemirror/collab",
+    "@codemirror/commands",
+    "@codemirror/language",
+    "@codemirror/lint",
+    "@codemirror/search",
+    "@codemirror/state",
+    "@codemirror/text",
+    "@codemirror/view",
+    "@lezer/common",
+    "@lezer/highlight",
+    "@lezer/lr",
+    "obsidian"
+  ]);
+  const DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES = /* @__PURE__ */ new Set([
+    "@codemirror/closebrackets",
+    "@codemirror/comment",
+    "@codemirror/fold",
+    "@codemirror/gutter",
+    "@codemirror/highlight",
+    "@codemirror/history",
+    "@codemirror/matchbrackets",
+    "@codemirror/panel",
+    "@codemirror/rangeset",
+    "@codemirror/rectangular-selection",
+    "@codemirror/stream-parser",
+    "@codemirror/tooltip"
+  ]);
+  function requirePatched(id) {
+    if (OBSIDIAN_BUILT_IN_MODULE_NAMES.has(id) || DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES.has(id)) {
+      return originalRequire?.(id);
+    }
+    const app = globalThis.app;
+    if (app?.isMobile) {
+      if (id === "process" || id === "node:process") {
+        console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Fake process object is returned instead.`);
+        return process;
+      }
+    } else {
+      const $module = originalRequire?.(id);
+      if ($module) {
+        return extractDefault($module);
+      }
+    }
+    console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Empty object is returned instead.`);
+    return {};
+  }
+})();
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var data_store_locations_exports = {};
+__export(data_store_locations_exports, {
+  DataStoreLocations: () => DataStoreLocations
+});
+module.exports = __toCommonJS(data_store_locations_exports);
+var import_type_guards = require('@mnaoumov/typescript-lib/type-guards');
+var import_data_store_transport = require('./data-store-transport.cjs');
+const MAX_LOCATIONS = 32;
+class DataStoreLocations {
+  /**
+   * Creates a coordinator without adapter calls.
+   *
+   * @param params - Permanent discovery anchor and store identity.
+   */
+  constructor(params) {
+    this.params = params;
+    this.anchor = new import_data_store_transport.DataStoreTransport(params);
+    this.initial = { folder: params.folder ?? "Plugin data", format: params.format ?? "markdown" };
+    this.locations = [this.initial];
+  }
+  params;
+  /**
+  All readers, oldest first; the last transport is the active writer.
+   *
+   * @returns All retained reader transports in transition order.
+   */
+  get transports() {
+    return this.locations.map((location) => this.createTransport(location));
+  }
+  anchor;
+  initial;
+  locations;
+  /**
+   * Discovers and finishes pending copies before allowing a writer to switch destinations.
+   * Conflicting branches and reordered incomplete chains fail closed until delivery is complete.
+   *
+   * @returns A promise that resolves after discovery and verification.
+   */
+  async refresh() {
+    const transitions = [];
+    for (const path of await this.anchor.list()) {
+      if (!path.startsWith(`${this.anchor.root}/locations-v1/`) || !path.endsWith(".json")) {
+        continue;
+      }
+      const value = await this.anchor.read(path);
+      if (!isTransition(value)) {
+        throw new Error("Incomplete or invalid data-store transition");
+      }
+      this.validateLocation(value.from);
+      this.validateLocation(value.to);
+      transitions.push(value);
+    }
+    const locations = [this.initial];
+    let currentIdentity = identity(this.initial);
+    while (transitions.length > 0) {
+      const sourceIdentity = currentIdentity;
+      const next = transitions.filter((transition) => identity(transition.from) === sourceIdentity);
+      const targets = new Set(next.map((transition) => identity(transition.to)));
+      if (targets.size !== 1) {
+        throw new Error("Conflicting or incomplete data-store relocation chain");
+      }
+      const target = (0, import_type_guards.ensureNonNullable)(next[0]);
+      if (locations.some((location) => identity(location) === identity(target.to)) || locations.length >= MAX_LOCATIONS) {
+        throw new Error("Data-store relocation loop or location limit");
+      }
+      locations.push(target.to);
+      currentIdentity = identity(target.to);
+      for (const transition of next) {
+        transitions.splice(transitions.indexOf(transition), 1);
+      }
+    }
+    for (const location of locations) {
+      this.validateLocation(location, locations);
+    }
+    for (const location of locations.slice(1)) {
+      const target = this.createTransport(location);
+      for (const source of locations.slice(0, locations.indexOf(location))) {
+        const transport = this.createTransport(source);
+        if (transport.root !== target.root) {
+          await transport.copyHistoryTo(target);
+        }
+      }
+    }
+    this.locations = locations;
+  }
+  /**
+   * Announces a transition durably at the anchor, then copies and verifies before activation.
+   * Retrying the same destination finishes an interrupted copy.
+   *
+   * @param location - Requested destination.
+   * @returns A promise that resolves when the new writer is ready.
+   */
+  async relocate(location) {
+    this.validateLocation(location);
+    await this.refresh();
+    this.validateLocation(location);
+    const from = (0, import_type_guards.ensureNonNullable)(this.locations.at(-1));
+    if (identity(from) === identity(location)) {
+      return;
+    }
+    if (this.locations.some((previous) => identity(previous) === identity(location)) || this.locations.length >= MAX_LOCATIONS) {
+      throw new Error("Data-store relocation loop or location limit");
+    }
+    const value = { format: 1, from, to: location };
+    await this.anchor.write(`${this.anchor.root}/locations-v1/${window.crypto.randomUUID()}.json`, value);
+    await this.refresh();
+  }
+  createTransport(location) {
+    return new import_data_store_transport.DataStoreTransport({ ...this.params, folder: location.folder, format: location.format ?? "markdown" });
+  }
+  validateLocation(location, locations = this.locations) {
+    const transport = this.createTransport(location);
+    for (const previous of locations) {
+      const root = this.createTransport(previous).root;
+      if (transport.root !== root && (transport.root.startsWith(`${root}/`) || root.startsWith(`${transport.root}/`))) {
+        throw new Error("Overlapping data-store relocation roots");
+      }
+    }
+  }
+}
+function identity(location) {
+  return `${location.folder}:${location.format ?? "markdown"}`;
+}
+function isLocation(value) {
+  return typeof value === "object" && value !== null && "folder" in value && typeof value.folder === "string" && (!("format" in value) || value.format === "json" || value.format === "markdown");
+}
+function isTransition(value) {
+  return typeof value === "object" && value !== null && "format" in value && value.format === 1 && "from" in value && isLocation(value.from) && "to" in value && isLocation(value.to);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DataStoreLocations
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/data-stores/data-store-locations.ts"],"sourcesContent":["/* eslint-disable n/no-unsupported-features/node-builtins -- These are Obsidian renderer Web APIs, not Node builtins. */\n/**\n * @file\n * Append-only, anchored discovery of history-preserving transport transitions.\n */\n\nimport { ensureNonNullable } from '@mnaoumov/typescript-lib/type-guards';\n\nimport type { DataStoreTransportConstructorParams } from './data-store-transport.ts';\n\nimport { DataStoreTransport } from './data-store-transport.ts';\n\nconst MAX_LOCATIONS = 32;\n\n/**\nA transport destination. Keep the original open parameters as the discovery anchor.\n */\nexport interface DataStoreLocation {\n  /**\n  Vault-relative parent of the plugin/store subtree.\n   */\n  readonly folder: string;\n  /**\n   * New document encoding.\n   *\n   * @default `'markdown'`\n   */\n  readonly format?: 'json' | 'markdown';\n}\n\ninterface Transition {\n  readonly format: 1;\n  readonly from: DataStoreLocation;\n  readonly to: DataStoreLocation;\n}\n\n/**\nAnchored relocation coordinator; source histories are never removed.\n */\nexport class DataStoreLocations {\n  /**\n  All readers, oldest first; the last transport is the active writer.\n   *\n   * @returns All retained reader transports in transition order.\n   */\n  public get transports(): DataStoreTransport[] {\n    return this.locations.map((location) => this.createTransport(location));\n  }\n\n  private readonly anchor: DataStoreTransport;\n  private readonly initial: DataStoreLocation;\n\n  private locations: DataStoreLocation[];\n\n  /**\n   * Creates a coordinator without adapter calls.\n   *\n   * @param params - Permanent discovery anchor and store identity.\n   */\n  public constructor(private readonly params: DataStoreTransportConstructorParams) {\n    this.anchor = new DataStoreTransport(params);\n    this.initial = { folder: params.folder ?? 'Plugin data', format: params.format ?? 'markdown' };\n    this.locations = [this.initial];\n  }\n\n  /**\n   * Discovers and finishes pending copies before allowing a writer to switch destinations.\n   * Conflicting branches and reordered incomplete chains fail closed until delivery is complete.\n   *\n   * @returns A promise that resolves after discovery and verification.\n   */\n  public async refresh(): Promise<void> {\n    const transitions: Transition[] = [];\n    for (const path of await this.anchor.list()) {\n      if (!path.startsWith(`${this.anchor.root}/locations-v1/`) || !path.endsWith('.json')) {\n        continue;\n      }\n      const value = await this.anchor.read(path);\n      if (!isTransition(value)) {\n        throw new Error('Incomplete or invalid data-store transition');\n      }\n      this.validateLocation(value.from);\n      this.validateLocation(value.to);\n      transitions.push(value);\n    }\n    const locations = [this.initial];\n    let currentIdentity = identity(this.initial);\n    while (transitions.length > 0) {\n      const sourceIdentity = currentIdentity;\n      const next = transitions.filter((transition) => identity(transition.from) === sourceIdentity);\n      const targets = new Set(next.map((transition) => identity(transition.to)));\n      if (targets.size !== 1) {\n        throw new Error('Conflicting or incomplete data-store relocation chain');\n      }\n      const target = ensureNonNullable(next[0]);\n      if (locations.some((location) => identity(location) === identity(target.to)) || locations.length >= MAX_LOCATIONS) {\n        throw new Error('Data-store relocation loop or location limit');\n      }\n      locations.push(target.to);\n      currentIdentity = identity(target.to);\n      for (const transition of next) {\n        transitions.splice(transitions.indexOf(transition), 1);\n      }\n    }\n    // Validate the entire chain before making any copies or activating a writer.\n    for (const location of locations) {\n      this.validateLocation(location, locations);\n    }\n    for (const location of locations.slice(1)) {\n      const target = this.createTransport(location);\n      for (const source of locations.slice(0, locations.indexOf(location))) {\n        const transport = this.createTransport(source);\n        if (transport.root !== target.root) {\n          await transport.copyHistoryTo(target);\n        }\n      }\n    }\n    this.locations = locations;\n  }\n\n  /**\n   * Announces a transition durably at the anchor, then copies and verifies before activation.\n   * Retrying the same destination finishes an interrupted copy.\n   *\n   * @param location - Requested destination.\n   * @returns A promise that resolves when the new writer is ready.\n   */\n  public async relocate(location: DataStoreLocation): Promise<void> {\n    this.validateLocation(location);\n    await this.refresh();\n    this.validateLocation(location);\n    const from = ensureNonNullable(this.locations.at(-1));\n    if (identity(from) === identity(location)) {\n      return;\n    }\n    if (this.locations.some((previous) => identity(previous) === identity(location)) || this.locations.length >= MAX_LOCATIONS) {\n      throw new Error('Data-store relocation loop or location limit');\n    }\n    const value: Transition = { format: 1, from, to: location };\n    await this.anchor.write(`${this.anchor.root}/locations-v1/${window.crypto.randomUUID()}.json`, value);\n    await this.refresh();\n  }\n\n  private createTransport(location: DataStoreLocation): DataStoreTransport {\n    return new DataStoreTransport({ ...this.params, folder: location.folder, format: location.format ?? 'markdown' });\n  }\n\n  private validateLocation(location: DataStoreLocation, locations: readonly DataStoreLocation[] = this.locations): void {\n    const transport = this.createTransport(location);\n    for (const previous of locations) {\n      const root = this.createTransport(previous).root;\n      if (transport.root !== root && (transport.root.startsWith(`${root}/`) || root.startsWith(`${transport.root}/`))) {\n        throw new Error('Overlapping data-store relocation roots');\n      }\n    }\n  }\n}\n\n/* eslint-enable n/no-unsupported-features/node-builtins -- These are Obsidian renderer Web APIs, not Node builtins. */\n\nfunction identity(location: DataStoreLocation): string {\n  return `${location.folder}:${location.format ?? 'markdown'}`;\n}\n\nfunction isLocation(value: unknown): value is DataStoreLocation {\n  return typeof value === 'object' && value !== null && 'folder' in value && typeof value.folder === 'string'\n    && (!('format' in value) || value.format === 'json' || value.format === 'markdown');\n}\n\nfunction isTransition(value: unknown): value is Transition {\n  return typeof value === 'object' && value !== null && 'format' in value && value.format === 1\n    && 'from' in value && isLocation(value.from) && 'to' in value && isLocation(value.to);\n}\n"],"mappings":"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","names":[]}

package/dist/lib/cjs/data-stores/data-store-locations.d.cts

@@ -0,0 +1,60 @@
+/// <reference path="../library-references.d.cts" />
+/**
+ * @file
+ * Append-only, anchored discovery of history-preserving transport transitions.
+ */
+import type { DataStoreTransportConstructorParams } from './data-store-transport.cjs';
+import { DataStoreTransport } from './data-store-transport.cjs';
+/**
+A transport destination. Keep the original open parameters as the discovery anchor.
+ */
+export interface DataStoreLocation {
+    /**
+    Vault-relative parent of the plugin/store subtree.
+     */
+    readonly folder: string;
+    /**
+     * New document encoding.
+     *
+     * @default `'markdown'`
+     */
+    readonly format?: 'json' | 'markdown';
+}
+/**
+Anchored relocation coordinator; source histories are never removed.
+ */
+export declare class DataStoreLocations {
+    private readonly params;
+    /**
+    All readers, oldest first; the last transport is the active writer.
+     *
+     * @returns All retained reader transports in transition order.
+     */
+    get transports(): DataStoreTransport[];
+    private readonly anchor;
+    private readonly initial;
+    private locations;
+    /**
+     * Creates a coordinator without adapter calls.
+     *
+     * @param params - Permanent discovery anchor and store identity.
+     */
+    constructor(params: DataStoreTransportConstructorParams);
+    /**
+     * Discovers and finishes pending copies before allowing a writer to switch destinations.
+     * Conflicting branches and reordered incomplete chains fail closed until delivery is complete.
+     *
+     * @returns A promise that resolves after discovery and verification.
+     */
+    refresh(): Promise<void>;
+    /**
+     * Announces a transition durably at the anchor, then copies and verifies before activation.
+     * Retrying the same destination finishes an interrupted copy.
+     *
+     * @param location - Requested destination.
+     * @returns A promise that resolves when the new writer is ready.
+     */
+    relocate(location: DataStoreLocation): Promise<void>;
+    private createTransport;
+    private validateLocation;
+}

package/dist/lib/cjs/data-stores/data-store-seeds.cjs

@@ -156,7 +156,7 @@ class DataStoreSeeds {
     let newest = -Infinity;
     let entries;
     for (const path of files) {
-      if (!/\/seed-[\w-]+-manifest\.md$/.test(path)) {
+      if (!/\/seed-[\w-]+-manifest\.(?:md|json)$/.test(path)) {
         continue;
       }
       let seed;
@@ -201,4 +201,4 @@ function isSeed(value) {
   DataStoreSeeds,
   validateDataStoreSeed
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/data-stores/data-store-seeds.ts"],"sourcesContent":["/* eslint-disable n/no-unsupported-features/node-builtins -- These are Obsidian renderer Web APIs, not Node builtins. */\n/**\n * @file\n *\n * Optional chunked seeds for expensive derived caches, with per-file validation before reuse.\n */\n\nimport type { JsonValue } from 'type-fest';\n\nimport type { LocalDataStore } from './local-data-store.ts';\n\nimport { isDataStoreJsonValue } from './data-store-replica.ts';\nimport { DataStoreTransport } from './data-store-transport.ts';\n\n/**\n * A derived record tagged with both cheap statistics and a content hash.\n */\nexport interface DataStoreSeedEntry extends DataStoreSeedFile {\n  /**\n   * Content hash, using the same algorithm on every device.\n   */\n  readonly hash: string;\n  /**\n   * Consumer-defined JSON cache record.\n   */\n  readonly value: JsonValue;\n}\n\n/**\n * Cheap file identity already available from the vault's file tree.\n */\nexport interface DataStoreSeedFile {\n  /**\n   * Last modification time.\n   */\n  readonly mtime: number;\n  /**\n   * Vault-relative path.\n   */\n  readonly path: string;\n  /**\n   * File size in bytes.\n   */\n  readonly size: number;\n}\n\n/**\n * Parameters for optional cache-seed sharing.\n */\nexport interface DataStoreSeedsConstructorParams {\n  /**\n   * Dedicated device-local store that owns the seed publisher identity.\n   */\n  readonly local: LocalDataStore;\n  /**\n   * Per-store user setting. Disabled means neither publishing nor adopting seeds.\n   */\n  readonly share: boolean;\n  /**\n   * Store-scoped, bounded Markdown transport. Include the consumer schema version in its store id.\n   */\n  readonly transport: DataStoreTransport;\n}\n\n/**\n * Results of validating a shared cache seed against the local vault.\n */\nexport interface DataStoreSeedValidation {\n  /**\n   * Files absent from the seed, or with different content.\n   */\n  readonly rebuild: string[];\n  /**\n   * Validated seed records, with local file statistics.\n   */\n  readonly reusable: DataStoreSeedEntry[];\n}\n\n/**\n * Parameters for per-file seed validation.\n */\nexport interface ValidateDataStoreSeedParams {\n  /**\n   * Seed entries from a recognized consumer schema.\n   */\n  readonly entries: readonly DataStoreSeedEntry[];\n  /**\n   * Current file tree, available without reading note text.\n   */\n  readonly files: readonly DataStoreSeedFile[];\n  /**\n   * Hashes text only when size matches but mtime differs.\n   *\n   * @param path - File requiring validation.\n   * @returns Its content hash.\n   */\n  readonly hashFile: (path: string) => Promise<string>;\n}\n\ninterface Seed {\n  readonly entries: DataStoreSeedEntry[];\n  readonly format: 1;\n  readonly time: number;\n}\n\n/**\n * Optional performance hints. Seeds are never authoritative state and must be validated before reuse.\n */\nexport class DataStoreSeeds {\n  /**\n   * Device-local identity and serialization boundary.\n   */\n  protected readonly local: LocalDataStore;\n  /**\n   * Whether this store shares cache seeds.\n   */\n  protected readonly share: boolean;\n  /**\n   * Store-scoped snapshot transport.\n   */\n  protected readonly transport: DataStoreTransport;\n  /**\n   * Creates a cache-seed publisher and reader.\n   *\n   * @param params - Local identity, transport and the per-store sharing setting.\n   */\n  public constructor(params: DataStoreSeedsConstructorParams) {\n    this.local = params.local;\n    this.share = params.share;\n    this.transport = params.transport;\n  }\n\n  /**\n   * Publishes a bounded seed, replacing only this device's earlier publications.\n   *\n   * @param entries - Derived records with file statistics and hashes.\n   * @returns Whether sharing was enabled and the seed was published.\n   */\n  public async publish(entries: readonly DataStoreSeedEntry[]): Promise<boolean> {\n    if (!this.share) {\n      return false;\n    }\n    return await this.local.exclusive(async () => {\n      const device = await this.local.getOrCreate('seed-device-v1', window.crypto.randomUUID());\n      if (typeof device !== 'string' || !/^[\\w-]+$/.test(device)) {\n        throw new Error('Invalid local seed identity');\n      }\n      const root = `${this.transport.root}/seeds/${device}`;\n      const files = await this.transport.list();\n      const base = `${root}/seed-${window.crypto.randomUUID()}-manifest`;\n      await this.transport.writeSnapshot({ base, payload: { entries, format: 1, time: Date.now() } });\n      for (const path of files) {\n        if (path.startsWith(`${root}/seed-`)) {\n          await this.transport.remove(path);\n        }\n      }\n      return true;\n    });\n  }\n\n  /**\n   * Reads the newest complete seed for this transport's schema.\n   *\n   * @returns Seed records, or `undefined` if sharing is disabled or no complete seed is available yet.\n   */\n  public async readLatest(): Promise<DataStoreSeedEntry[] | undefined> {\n    if (!this.share) {\n      return undefined;\n    }\n    const files = await this.transport.list();\n    let newest = -Infinity;\n    let entries: DataStoreSeedEntry[] | undefined;\n    for (const path of files) {\n      if (!/\\/seed-[\\w-]+-manifest\\.md$/.test(path)) {\n        continue;\n      }\n      let seed: unknown;\n      try {\n        seed = await this.transport.readSnapshot(path);\n      } catch (error) {\n        if (error instanceof SyntaxError) {\n          continue;\n        }\n        throw error;\n      }\n      if (!(isSeed(seed) && seed.time > newest)) {\n        continue;\n      }\n\n      newest = seed.time;\n      entries = seed.entries;\n    }\n    return entries;\n  }\n}\n\n/**\n * Validates a seed using free file statistics first, hashing only size-equal mtime mismatches.\n * Files absent locally are discarded. Consumers index only the returned rebuild paths.\n *\n * @param params - Seed, current file tree and content-hash reader.\n * @returns Reusable records and the paths that still need indexing.\n */\nexport async function validateDataStoreSeed(params: ValidateDataStoreSeedParams): Promise<DataStoreSeedValidation> {\n  const seed = new Map(params.entries.map((entry) => [entry.path, entry]));\n  const reusable: DataStoreSeedEntry[] = [];\n  const rebuild: string[] = [];\n  for (const file of params.files) {\n    const entry = seed.get(file.path);\n    if (entry?.size === file.size && (entry.mtime === file.mtime || entry.hash === await params.hashFile(file.path))) {\n      reusable.push({ ...entry, ...file });\n    } else {\n      rebuild.push(file.path);\n    }\n  }\n  return { rebuild, reusable };\n}\n\nfunction isSeed(value: unknown): value is Seed {\n  return typeof value === 'object' && value !== null && 'format' in value && value.format === 1\n    && 'time' in value && typeof value.time === 'number' && Number.isFinite(value.time)\n    && 'entries' in value && Array.isArray(value.entries) && value.entries.every((entry: unknown) =>\n      typeof entry === 'object' && entry !== null && 'path' in entry && typeof entry.path === 'string'\n      && 'mtime' in entry && typeof entry.mtime === 'number' && Number.isFinite(entry.mtime)\n      && 'size' in entry && typeof entry.size === 'number' && Number.isFinite(entry.size)\n      && 'hash' in entry && typeof entry.hash === 'string' && 'value' in entry && isDataStoreJsonValue(entry.value)\n    );\n}\n\n/* eslint-enable n/no-unsupported-features/node-builtins -- These are Obsidian renderer Web APIs, not Node builtins. */\n"],"mappings":"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","names":[]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/data-stores/data-store-seeds.ts"],"sourcesContent":["/* eslint-disable n/no-unsupported-features/node-builtins -- These are Obsidian renderer Web APIs, not Node builtins. */\n/**\n * @file\n *\n * Optional chunked seeds for expensive derived caches, with per-file validation before reuse.\n */\n\nimport type { JsonValue } from 'type-fest';\n\nimport type { LocalDataStore } from './local-data-store.ts';\n\nimport { isDataStoreJsonValue } from './data-store-replica.ts';\nimport { DataStoreTransport } from './data-store-transport.ts';\n\n/**\n * A derived record tagged with both cheap statistics and a content hash.\n */\nexport interface DataStoreSeedEntry extends DataStoreSeedFile {\n  /**\n   * Content hash, using the same algorithm on every device.\n   */\n  readonly hash: string;\n  /**\n   * Consumer-defined JSON cache record.\n   */\n  readonly value: JsonValue;\n}\n\n/**\n * Cheap file identity already available from the vault's file tree.\n */\nexport interface DataStoreSeedFile {\n  /**\n   * Last modification time.\n   */\n  readonly mtime: number;\n  /**\n   * Vault-relative path.\n   */\n  readonly path: string;\n  /**\n   * File size in bytes.\n   */\n  readonly size: number;\n}\n\n/**\n * Parameters for optional cache-seed sharing.\n */\nexport interface DataStoreSeedsConstructorParams {\n  /**\n   * Dedicated device-local store that owns the seed publisher identity.\n   */\n  readonly local: LocalDataStore;\n  /**\n   * Per-store user setting. Disabled means neither publishing nor adopting seeds.\n   */\n  readonly share: boolean;\n  /**\n   * Store-scoped, bounded transport. Include the consumer schema version in its store id.\n   */\n  readonly transport: DataStoreTransport;\n}\n\n/**\n * Results of validating a shared cache seed against the local vault.\n */\nexport interface DataStoreSeedValidation {\n  /**\n   * Files absent from the seed, or with different content.\n   */\n  readonly rebuild: string[];\n  /**\n   * Validated seed records, with local file statistics.\n   */\n  readonly reusable: DataStoreSeedEntry[];\n}\n\n/**\n * Parameters for per-file seed validation.\n */\nexport interface ValidateDataStoreSeedParams {\n  /**\n   * Seed entries from a recognized consumer schema.\n   */\n  readonly entries: readonly DataStoreSeedEntry[];\n  /**\n   * Current file tree, available without reading note text.\n   */\n  readonly files: readonly DataStoreSeedFile[];\n  /**\n   * Hashes text only when size matches but mtime differs.\n   *\n   * @param path - File requiring validation.\n   * @returns Its content hash.\n   */\n  readonly hashFile: (path: string) => Promise<string>;\n}\n\ninterface Seed {\n  readonly entries: DataStoreSeedEntry[];\n  readonly format: 1;\n  readonly time: number;\n}\n\n/**\n * Optional performance hints. Seeds are never authoritative state and must be validated before reuse.\n */\nexport class DataStoreSeeds {\n  /**\n   * Device-local identity and serialization boundary.\n   */\n  protected readonly local: LocalDataStore;\n  /**\n   * Whether this store shares cache seeds.\n   */\n  protected readonly share: boolean;\n  /**\n   * Store-scoped snapshot transport.\n   */\n  protected readonly transport: DataStoreTransport;\n  /**\n   * Creates a cache-seed publisher and reader.\n   *\n   * @param params - Local identity, transport and the per-store sharing setting.\n   */\n  public constructor(params: DataStoreSeedsConstructorParams) {\n    this.local = params.local;\n    this.share = params.share;\n    this.transport = params.transport;\n  }\n\n  /**\n   * Publishes a bounded seed, replacing only this device's earlier publications.\n   *\n   * @param entries - Derived records with file statistics and hashes.\n   * @returns Whether sharing was enabled and the seed was published.\n   */\n  public async publish(entries: readonly DataStoreSeedEntry[]): Promise<boolean> {\n    if (!this.share) {\n      return false;\n    }\n    return await this.local.exclusive(async () => {\n      const device = await this.local.getOrCreate('seed-device-v1', window.crypto.randomUUID());\n      if (typeof device !== 'string' || !/^[\\w-]+$/.test(device)) {\n        throw new Error('Invalid local seed identity');\n      }\n      const root = `${this.transport.root}/seeds/${device}`;\n      const files = await this.transport.list();\n      const base = `${root}/seed-${window.crypto.randomUUID()}-manifest`;\n      await this.transport.writeSnapshot({ base, payload: { entries, format: 1, time: Date.now() } });\n      for (const path of files) {\n        if (path.startsWith(`${root}/seed-`)) {\n          await this.transport.remove(path);\n        }\n      }\n      return true;\n    });\n  }\n\n  /**\n   * Reads the newest complete seed for this transport's schema.\n   *\n   * @returns Seed records, or `undefined` if sharing is disabled or no complete seed is available yet.\n   */\n  public async readLatest(): Promise<DataStoreSeedEntry[] | undefined> {\n    if (!this.share) {\n      return undefined;\n    }\n    const files = await this.transport.list();\n    let newest = -Infinity;\n    let entries: DataStoreSeedEntry[] | undefined;\n    for (const path of files) {\n      if (!/\\/seed-[\\w-]+-manifest\\.(?:md|json)$/.test(path)) {\n        continue;\n      }\n      let seed: unknown;\n      try {\n        seed = await this.transport.readSnapshot(path);\n      } catch (error) {\n        if (error instanceof SyntaxError) {\n          continue;\n        }\n        throw error;\n      }\n      if (!(isSeed(seed) && seed.time > newest)) {\n        continue;\n      }\n\n      newest = seed.time;\n      entries = seed.entries;\n    }\n    return entries;\n  }\n}\n\n/**\n * Validates a seed using free file statistics first, hashing only size-equal mtime mismatches.\n * Files absent locally are discarded. Consumers index only the returned rebuild paths.\n *\n * @param params - Seed, current file tree and content-hash reader.\n * @returns Reusable records and the paths that still need indexing.\n */\nexport async function validateDataStoreSeed(params: ValidateDataStoreSeedParams): Promise<DataStoreSeedValidation> {\n  const seed = new Map(params.entries.map((entry) => [entry.path, entry]));\n  const reusable: DataStoreSeedEntry[] = [];\n  const rebuild: string[] = [];\n  for (const file of params.files) {\n    const entry = seed.get(file.path);\n    if (entry?.size === file.size && (entry.mtime === file.mtime || entry.hash === await params.hashFile(file.path))) {\n      reusable.push({ ...entry, ...file });\n    } else {\n      rebuild.push(file.path);\n    }\n  }\n  return { rebuild, reusable };\n}\n\nfunction isSeed(value: unknown): value is Seed {\n  return typeof value === 'object' && value !== null && 'format' in value && value.format === 1\n    && 'time' in value && typeof value.time === 'number' && Number.isFinite(value.time)\n    && 'entries' in value && Array.isArray(value.entries) && value.entries.every((entry: unknown) =>\n      typeof entry === 'object' && entry !== null && 'path' in entry && typeof entry.path === 'string'\n      && 'mtime' in entry && typeof entry.mtime === 'number' && Number.isFinite(entry.mtime)\n      && 'size' in entry && typeof entry.size === 'number' && Number.isFinite(entry.size)\n      && 'hash' in entry && typeof entry.hash === 'string' && 'value' in entry && isDataStoreJsonValue(entry.value)\n    );\n}\n\n/* eslint-enable n/no-unsupported-features/node-builtins -- These are Obsidian renderer Web APIs, not Node builtins. */\n"],"mappings":"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","names":[]}

package/dist/lib/cjs/data-stores/data-store-seeds.d.cts

@@ -50,7 +50,7 @@ export interface DataStoreSeedsConstructorParams {
      */
     readonly share: boolean;
     /**
-     * Store-scoped, bounded Markdown transport. Include the consumer schema version in its store id.
+     * Store-scoped, bounded transport. Include the consumer schema version in its store id.
      */
     readonly transport: DataStoreTransport;
 }