@mnaoumov/obsidian-lib 10.12.0 → 11.0.0

package/dist/lib/esm/data-handler.mjs

@@ -31,6 +31,12 @@ ensureBrowserProcess();
 })();
 
 import { normalizePath } from "obsidian";
+import { PluginNoticeComponent } from "./components/plugin-notice-component.mjs";
+import { t } from "./i18n/i18n.mjs";
+import {
+  LocalSettingsRecoveryStore,
+  SettingsRecoveryReason
+} from "./settings-recovery.mjs";
 const OBSIDIAN_JSON_INDENT = 2;
 const DEFAULT_PLUGIN_DATA_MAX_SIZE_IN_BYTES = 16777216;
 var PluginDataOperation = /* @__PURE__ */ ((PluginDataOperation2) => {
@@ -52,8 +58,13 @@ class PluginDataHandler {
       throw new RangeError(`maxSizeInBytes must be a non-negative number, got ${String(maxSizeInBytes)}.`);
     }
     this.maxSizeInBytes = maxSizeInBytes;
+    this.recoveryStore = options.recoveryStore === void 0 ? new LocalSettingsRecoveryStore({ app: plugin.app, pluginId: plugin.manifest.id }) : options.recoveryStore;
   }
   plugin;
+  /**
+   * Where recovery copies of `data.json` are kept, or `null` when none are.
+   */
+  recoveryStore;
   /**
    * The maximum size of `data.json`, in bytes.
    */
@@ -62,17 +73,45 @@ class PluginDataHandler {
    * Loads data from the plugin's data file.
    *
    * The file's size is read through the adapter BEFORE Obsidian reads and parses it, so an oversized file is never
-   * loaded into memory.
+   * loaded into memory. When Obsidian answers `undefined` or `null`, the file is read raw and parsed here, because
+   * Obsidian answers `undefined` for a file that exists but does not parse too.
    *
    * @returns The loaded data.
    * @throws {@link PluginDataSizeLimitExceededError} If the existing file is larger than the limit.
+   * @throws {@link PluginDataParseError} If the existing file is not valid JSON. The file is left untouched, and a
+   * recovery copy of it is kept first when the handler has a recovery store.
    */
   async loadData() {
     const sizeInBytes = await this.getExistingFileSize();
     if (sizeInBytes !== null && sizeInBytes > this.maxSizeInBytes) {
       throw this.createError("load" /* Load */, sizeInBytes);
     }
-    return this.plugin.loadData();
+    const data = await this.plugin.loadData();
+    if (data !== void 0 && data !== null) {
+      return data;
+    }
+    const path = this.getDataFilePath();
+    if (path === null) {
+      return data;
+    }
+    const rawText = await this.readRawFile(path);
+    if (rawText === null) {
+      return data;
+    }
+    try {
+      const parsed = JSON.parse(rawText);
+      return parsed;
+    } catch (parseError) {
+      const error = new PluginDataParseError({
+        cause: parseError,
+        path,
+        pluginId: this.plugin.manifest.id,
+        pluginName: this.plugin.manifest.name,
+        recoveryCopy: await this.keepRecoveryCopy(path, rawText)
+      });
+      this.reportParseError(error);
+      throw error;
+    }
   }
   /**
    * Saves data to the plugin's data file.
@@ -105,6 +144,21 @@ class PluginDataHandler {
     const directory = this.plugin.manifest.dir;
     return directory ? normalizePath(`${directory}/data.json`) : null;
   }
+  /**
+   * Tells the user that `data.json` could not be parsed: a notice naming the plugin and the path, and the error in the
+   * console.
+   *
+   * @param error - The parse error.
+   */
+  reportParseError(error) {
+    console.error(error);
+    new PluginNoticeComponent({
+      app: this.plugin.app,
+      pluginName: this.plugin.manifest.name
+    }).showNotice(
+      error.recoveryCopy === null ? t(($) => $.obsidianLib.notices.dataFileUnparseable, { path: error.path }) : t(($) => $.obsidianLib.notices.dataFileUnparseableCopyKept, { path: error.path })
+    );
+  }
   createError(operation, sizeInBytes) {
     return new PluginDataSizeLimitExceededError({
       maxSizeInBytes: this.maxSizeInBytes,
@@ -130,6 +184,60 @@ class PluginDataHandler {
       return null;
     }
   }
+  async keepRecoveryCopy(path, rawText) {
+    if (this.recoveryStore === null) {
+      return null;
+    }
+    try {
+      return await this.recoveryStore.keep({ path, rawText, reason: SettingsRecoveryReason.InvalidJson });
+    } catch (error) {
+      console.error(new Error(`Could not keep a recovery copy of "${path}"`, { cause: error }));
+      return null;
+    }
+  }
+  async readRawFile(path) {
+    const adapter = this.plugin.app.vault.adapter;
+    try {
+      return await adapter.exists(path) ? await adapter.read(path) : null;
+    } catch {
+      return null;
+    }
+  }
+}
+class PluginDataParseError extends Error {
+  /**
+   * The path of the plugin's `data.json`.
+   */
+  path;
+  /**
+   * The `manifest.id` of the plugin.
+   */
+  pluginId;
+  /**
+   * The `manifest.name` of the plugin.
+   */
+  pluginName;
+  /**
+   * The recovery copy kept of the file, or `null` when none could be kept.
+   */
+  recoveryCopy;
+  /**
+   * Creates a {@link PluginDataParseError}.
+   *
+   * @param params - The parameters for the error.
+   */
+  constructor(params) {
+    const copy = params.recoveryCopy === null ? "No recovery copy could be kept." : `A recovery copy was kept on this device as "${params.recoveryCopy.id}".`;
+    super(
+      `Plugin "${params.pluginName}" (${params.pluginId}): "${params.path}" is not valid JSON, so it could not be loaded. The file was left untouched. ${copy}`,
+      { cause: params.cause }
+    );
+    this.name = "PluginDataParseError";
+    this.path = params.path;
+    this.pluginId = params.pluginId;
+    this.pluginName = params.pluginName;
+    this.recoveryCopy = params.recoveryCopy;
+  }
 }
 class PluginDataSizeLimitExceededError extends Error {
   /**
@@ -180,6 +288,7 @@ export {
   DEFAULT_PLUGIN_DATA_MAX_SIZE_IN_BYTES,
   PluginDataHandler,
   PluginDataOperation,
+  PluginDataParseError,
   PluginDataSizeLimitExceededError
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/data-handler.ts"],"sourcesContent":["/**\n * @file\n *\n * A module for handling data loading and saving to the plugin's data file.\n *\n * {@link PluginDataHandler} bounds the plugin's `data.json` in bytes, in both directions, because Obsidian does\n * not. Read from Obsidian `1.15.1`: `Plugin.loadData` reads the whole file and `JSON.parse`s it with no limit, so an\n * oversized file is fully read and parsed into memory on every startup, and `Plugin.saveData` writes\n * `JSON.stringify(data, undefined, 2)` with no limit either. Obsidian also swallows a failed read or write: its\n * `readJson` logs a parse failure and resolves `undefined`, and its `writeJson` catches every error. So the guard\n * has to decide BEFORE handing the call to Obsidian, which is the only point where refusing still changes the\n * outcome.\n */\n\nimport type { Plugin } from 'obsidian';\n\nimport { normalizePath } from 'obsidian';\n\n/**\n * The indentation Obsidian's `Vault.writeJson` passes to `JSON.stringify` for `data.json` (read from `1.15.1`).\n */\nconst OBSIDIAN_JSON_INDENT = 2;\n\n/**\n * The default maximum size of a plugin's `data.json`, in bytes: 16 MiB.\n *\n * This is a protective budget against startup exhaustion, not a sync quota. Obsidian Sync's own per-file limit\n * depends on the plan and is a separate constraint a plugin may want to stay well under.\n */\nexport const DEFAULT_PLUGIN_DATA_MAX_SIZE_IN_BYTES = 16_777_216;\n\n/**\n * The operation a {@link PluginDataSizeLimitExceededError} refused.\n */\nexport enum PluginDataOperation {\n  /**\n   * Loading the existing `data.json`.\n   */\n  Load = 'load',\n\n  /**\n   * Saving a new `data.json`.\n   */\n  Save = 'save'\n}\n\n/**\n * A handler for loading and saving data to the plugin's data file.\n */\nexport interface DataHandler {\n  /**\n   * A function to load data from the plugin's data file.\n   *\n   * @returns The loaded data.\n   */\n  readonly loadData: () => Promise<unknown>;\n\n  /**\n   * A function to save data to the plugin's data file.\n   *\n   * @param data - The data to save.\n   */\n  readonly saveData: (data: unknown) => Promise<void>;\n}\n\n/**\n * Options for {@link PluginDataHandler}.\n */\nexport interface PluginDataHandlerConstructorOptions {\n  /**\n   * The maximum size of `data.json`, in UTF-8 bytes as written to disk. Defaults to\n   * {@link DEFAULT_PLUGIN_DATA_MAX_SIZE_IN_BYTES}. Pass `Infinity` to disable the guard.\n   */\n  readonly maxSizeInBytes?: number;\n}\n\n/**\n * Parameters for {@link PluginDataSizeLimitExceededError}.\n */\nexport interface PluginDataSizeLimitExceededErrorConstructorParams {\n  /**\n   * The size limit, in bytes.\n   */\n  readonly maxSizeInBytes: number;\n\n  /**\n   * The refused operation.\n   */\n  readonly operation: PluginDataOperation;\n\n  /**\n   * The path of the plugin's `data.json`.\n   */\n  readonly path: string;\n\n  /**\n   * The `manifest.id` of the plugin.\n   */\n  readonly pluginId: string;\n\n  /**\n   * The `manifest.name` of the plugin.\n   */\n  readonly pluginName: string;\n\n  /**\n   * The size of the existing file (load) or of the serialized data (save), in bytes.\n   */\n  readonly sizeInBytes: number;\n}\n\n/**\n * A handler for loading and saving data to the plugin's data file, refusing a `data.json` larger than a byte limit.\n */\nexport class PluginDataHandler implements DataHandler {\n  /**\n   * The maximum size of `data.json`, in bytes.\n   */\n  protected readonly maxSizeInBytes: number;\n\n  /**\n   * Creates a new plugin data handler.\n   *\n   * @param plugin - The plugin instance.\n   * @param options - The options.\n   */\n  public constructor(protected readonly plugin: Plugin, options: PluginDataHandlerConstructorOptions = {}) {\n    const maxSizeInBytes = options.maxSizeInBytes ?? DEFAULT_PLUGIN_DATA_MAX_SIZE_IN_BYTES;\n    if (Number.isNaN(maxSizeInBytes) || maxSizeInBytes < 0) {\n      throw new RangeError(`maxSizeInBytes must be a non-negative number, got ${String(maxSizeInBytes)}.`);\n    }\n    this.maxSizeInBytes = maxSizeInBytes;\n  }\n\n  /**\n   * Loads data from the plugin's data file.\n   *\n   * The file's size is read through the adapter BEFORE Obsidian reads and parses it, so an oversized file is never\n   * loaded into memory.\n   *\n   * @returns The loaded data.\n   * @throws {@link PluginDataSizeLimitExceededError} If the existing file is larger than the limit.\n   */\n  public async loadData(): Promise<unknown> {\n    const sizeInBytes = await this.getExistingFileSize();\n    if (sizeInBytes !== null && sizeInBytes > this.maxSizeInBytes) {\n      throw this.createError(PluginDataOperation.Load, sizeInBytes);\n    }\n    return this.plugin.loadData();\n  }\n\n  /**\n   * Saves data to the plugin's data file.\n   *\n   * The data is serialized exactly as Obsidian writes it, and its UTF-8 byte length is checked before anything is\n   * written.\n   *\n   * @param data - The data to save.\n   * @returns A promise that resolves when the data is saved.\n   * @throws {@link PluginDataSizeLimitExceededError} If the serialized data is larger than the limit.\n   */\n  public async saveData(data: unknown): Promise<void> {\n    if (this.maxSizeInBytes !== Infinity) {\n      // Obsidian's `writeJson` would swallow a serialization failure and write nothing; throwing here instead keeps\n      // the disk unchanged too, and tells the caller.\n      const serialized = JSON.stringify(data, undefined, OBSIDIAN_JSON_INDENT);\n      if (serialized !== undefined) {\n        const sizeInBytes = new TextEncoder().encode(serialized).byteLength;\n        if (sizeInBytes > this.maxSizeInBytes) {\n          throw this.createError(PluginDataOperation.Save, sizeInBytes);\n        }\n      }\n    }\n    await this.plugin.saveData(data);\n  }\n\n  /**\n   * Gets the path of the plugin's `data.json`, as Obsidian's `Plugin.loadData` reads it.\n   *\n   * @returns The path, or `null` when the manifest has no folder.\n   */\n  protected getDataFilePath(): null | string {\n    const directory = this.plugin.manifest.dir;\n    return directory ? normalizePath(`${directory}/data.json`) : null;\n  }\n\n  private createError(operation: PluginDataOperation, sizeInBytes: number): PluginDataSizeLimitExceededError {\n    return new PluginDataSizeLimitExceededError({\n      maxSizeInBytes: this.maxSizeInBytes,\n      operation,\n      path: this.getDataFilePath() ?? 'data.json',\n      pluginId: this.plugin.manifest.id,\n      pluginName: this.plugin.manifest.name,\n      sizeInBytes\n    });\n  }\n\n  private async getExistingFileSize(): Promise<null | number> {\n    if (this.maxSizeInBytes === Infinity) {\n      return null;\n    }\n    const path = this.getDataFilePath();\n    if (path === null) {\n      return null;\n    }\n    try {\n      const stat = await this.plugin.app.vault.adapter.stat(path);\n      return stat?.size ?? null;\n    } catch {\n      // The size is unknown, not oversized: Obsidian's own read decides what happens next, as before this guard.\n      return null;\n    }\n  }\n}\n\n/**\n * Thrown when a plugin's `data.json` is, or would become, larger than the configured limit.\n *\n * The file on disk is never touched when this is thrown: an oversized existing file is left intact for the user to\n * inspect or trim, and an oversized save is refused before anything is written, so the last good file remains.\n */\nexport class PluginDataSizeLimitExceededError extends Error {\n  /**\n   * The size limit, in bytes.\n   */\n  public readonly maxSizeInBytes: number;\n\n  /**\n   * The refused operation.\n   */\n  public readonly operation: PluginDataOperation;\n\n  /**\n   * The path of the plugin's `data.json`.\n   */\n  public readonly path: string;\n\n  /**\n   * The `manifest.id` of the plugin.\n   */\n  public readonly pluginId: string;\n\n  /**\n   * The `manifest.name` of the plugin.\n   */\n  public readonly pluginName: string;\n\n  /**\n   * The size of the existing file (load) or of the serialized data (save), in bytes.\n   */\n  public readonly sizeInBytes: number;\n\n  /**\n   * Creates a {@link PluginDataSizeLimitExceededError}.\n   *\n   * @param params - The parameters for the error.\n   */\n  public constructor(params: PluginDataSizeLimitExceededErrorConstructorParams) {\n    const what = params.operation === PluginDataOperation.Load\n      ? `Refusing to load \"${params.path}\": the file is ${String(params.sizeInBytes)} bytes`\n      : `Refusing to save \"${params.path}\": the data would be ${String(params.sizeInBytes)} bytes`;\n    const consequence = params.operation === PluginDataOperation.Load\n      ? 'The file was left untouched.'\n      : 'Nothing was written, so the last saved file remains.';\n    super(\n      `Plugin \"${params.pluginName}\" (${params.pluginId}): ${what}, over the ${String(params.maxSizeInBytes)}-byte limit. ${consequence} `\n        + 'Keep data.json for small settings, and move large or growing state to LocalDataStore or SharedDataStore.'\n    );\n    this.name = 'PluginDataSizeLimitExceededError';\n    this.maxSizeInBytes = params.maxSizeInBytes;\n    this.operation = params.operation;\n    this.path = params.path;\n    this.pluginId = params.pluginId;\n    this.pluginName = params.pluginName;\n    this.sizeInBytes = params.sizeInBytes;\n  }\n}\n"],"mappings":"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","names":["PluginDataOperation"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/data-handler.ts"],"sourcesContent":["/**\n * @file\n *\n * A module for handling data loading and saving to the plugin's data file.\n *\n * {@link PluginDataHandler} bounds the plugin's `data.json` in bytes, in both directions, because Obsidian does\n * not. Read from Obsidian `1.15.1`: `Plugin.loadData` reads the whole file and `JSON.parse`s it with no limit, so an\n * oversized file is fully read and parsed into memory on every startup, and `Plugin.saveData` writes\n * `JSON.stringify(data, undefined, 2)` with no limit either. Obsidian also swallows a failed read or write: its\n * `readJson` logs a parse failure and resolves `undefined`, and its `writeJson` catches every error. So the guard\n * has to decide BEFORE handing the call to Obsidian, which is the only point where refusing still changes the\n * outcome.\n *\n * The same `readJson` makes a `data.json` that EXISTS but does not parse indistinguishable from no file at all: both\n * resolve `undefined`. A settings component reading that as \"nothing stored\" saves its defaults over the file, and\n * the user's settings are gone. So when Obsidian answers `undefined` or `null`, {@link PluginDataHandler.loadData}\n * reads the file raw and parses it itself; a file that does not parse is copied into the device-local\n * {@link SettingsRecoveryStore} and reported as a {@link PluginDataParseError}, never as missing.\n */\n\nimport type { Plugin } from 'obsidian';\n\nimport { normalizePath } from 'obsidian';\n\nimport type {\n  SettingsRecoveryCopy,\n  SettingsRecoveryStore\n} from './settings-recovery.ts';\n\nimport { PluginNoticeComponent } from './components/plugin-notice-component.ts';\nimport { t } from './i18n/i18n.ts';\nimport {\n  LocalSettingsRecoveryStore,\n  SettingsRecoveryReason\n} from './settings-recovery.ts';\n\n/**\n * The indentation Obsidian's `Vault.writeJson` passes to `JSON.stringify` for `data.json` (read from `1.15.1`).\n */\nconst OBSIDIAN_JSON_INDENT = 2;\n\n/**\n * The default maximum size of a plugin's `data.json`, in bytes: 16 MiB.\n *\n * This is a protective budget against startup exhaustion, not a sync quota. Obsidian Sync's own per-file limit\n * depends on the plan and is a separate constraint a plugin may want to stay well under.\n */\nexport const DEFAULT_PLUGIN_DATA_MAX_SIZE_IN_BYTES = 16_777_216;\n\n/**\n * The operation a {@link PluginDataSizeLimitExceededError} refused.\n */\nexport enum PluginDataOperation {\n  /**\n   * Loading the existing `data.json`.\n   */\n  Load = 'load',\n\n  /**\n   * Saving a new `data.json`.\n   */\n  Save = 'save'\n}\n\n/**\n * A handler for loading and saving data to the plugin's data file.\n */\nexport interface DataHandler {\n  /**\n   * A function to load data from the plugin's data file.\n   *\n   * @returns The loaded data.\n   */\n  readonly loadData: () => Promise<unknown>;\n\n  /**\n   * Where a copy of the data file is kept before anything could lose what it held, or `null` (or absent) when the\n   * handler keeps none. A settings component keeps a copy here before a first save that would drop or change a\n   * stored value, and skips that save when the copy cannot be kept.\n   */\n  readonly recoveryStore?: null | SettingsRecoveryStore;\n\n  /**\n   * A function to save data to the plugin's data file.\n   *\n   * @param data - The data to save.\n   */\n  readonly saveData: (data: unknown) => Promise<void>;\n}\n\n/**\n * Options for {@link PluginDataHandler}.\n */\nexport interface PluginDataHandlerConstructorOptions {\n  /**\n   * The maximum size of `data.json`, in UTF-8 bytes as written to disk. Defaults to\n   * {@link DEFAULT_PLUGIN_DATA_MAX_SIZE_IN_BYTES}. Pass `Infinity` to disable the guard.\n   */\n  readonly maxSizeInBytes?: number;\n\n  /**\n   * Where recovery copies of `data.json` are kept. Defaults to a device-local {@link LocalSettingsRecoveryStore}\n   * for the plugin. Pass `null` to keep none: an unparseable file is then still reported and never overwritten, so a\n   * settings component built on this handler fails its load rather than run on defaults, and a first save that drops\n   * or changes a stored value is written with no copy kept, as before recovery copies existed.\n   */\n  readonly recoveryStore?: null | SettingsRecoveryStore;\n}\n\n/**\n * Parameters for {@link PluginDataParseError}.\n */\nexport interface PluginDataParseErrorConstructorParams {\n  /**\n   * The error `JSON.parse` threw.\n   */\n  readonly cause: unknown;\n\n  /**\n   * The path of the plugin's `data.json`.\n   */\n  readonly path: string;\n\n  /**\n   * The `manifest.id` of the plugin.\n   */\n  readonly pluginId: string;\n\n  /**\n   * The `manifest.name` of the plugin.\n   */\n  readonly pluginName: string;\n\n  /**\n   * The recovery copy kept of the file, or `null` when none could be kept.\n   */\n  readonly recoveryCopy: null | SettingsRecoveryCopy;\n}\n\n/**\n * Parameters for {@link PluginDataSizeLimitExceededError}.\n */\nexport interface PluginDataSizeLimitExceededErrorConstructorParams {\n  /**\n   * The size limit, in bytes.\n   */\n  readonly maxSizeInBytes: number;\n\n  /**\n   * The refused operation.\n   */\n  readonly operation: PluginDataOperation;\n\n  /**\n   * The path of the plugin's `data.json`.\n   */\n  readonly path: string;\n\n  /**\n   * The `manifest.id` of the plugin.\n   */\n  readonly pluginId: string;\n\n  /**\n   * The `manifest.name` of the plugin.\n   */\n  readonly pluginName: string;\n\n  /**\n   * The size of the existing file (load) or of the serialized data (save), in bytes.\n   */\n  readonly sizeInBytes: number;\n}\n\n/**\n * A handler for loading and saving data to the plugin's data file, refusing a `data.json` larger than a byte limit.\n */\nexport class PluginDataHandler implements DataHandler {\n  /**\n   * Where recovery copies of `data.json` are kept, or `null` when none are.\n   */\n  public readonly recoveryStore: null | SettingsRecoveryStore;\n\n  /**\n   * The maximum size of `data.json`, in bytes.\n   */\n  protected readonly maxSizeInBytes: number;\n\n  /**\n   * Creates a new plugin data handler.\n   *\n   * @param plugin - The plugin instance.\n   * @param options - The options.\n   */\n  public constructor(protected readonly plugin: Plugin, options: PluginDataHandlerConstructorOptions = {}) {\n    const maxSizeInBytes = options.maxSizeInBytes ?? DEFAULT_PLUGIN_DATA_MAX_SIZE_IN_BYTES;\n    if (Number.isNaN(maxSizeInBytes) || maxSizeInBytes < 0) {\n      throw new RangeError(`maxSizeInBytes must be a non-negative number, got ${String(maxSizeInBytes)}.`);\n    }\n    this.maxSizeInBytes = maxSizeInBytes;\n    this.recoveryStore = options.recoveryStore === undefined\n      ? new LocalSettingsRecoveryStore({ app: plugin.app, pluginId: plugin.manifest.id })\n      : options.recoveryStore;\n  }\n\n  /**\n   * Loads data from the plugin's data file.\n   *\n   * The file's size is read through the adapter BEFORE Obsidian reads and parses it, so an oversized file is never\n   * loaded into memory. When Obsidian answers `undefined` or `null`, the file is read raw and parsed here, because\n   * Obsidian answers `undefined` for a file that exists but does not parse too.\n   *\n   * @returns The loaded data.\n   * @throws {@link PluginDataSizeLimitExceededError} If the existing file is larger than the limit.\n   * @throws {@link PluginDataParseError} If the existing file is not valid JSON. The file is left untouched, and a\n   * recovery copy of it is kept first when the handler has a recovery store.\n   */\n  public async loadData(): Promise<unknown> {\n    const sizeInBytes = await this.getExistingFileSize();\n    if (sizeInBytes !== null && sizeInBytes > this.maxSizeInBytes) {\n      throw this.createError(PluginDataOperation.Load, sizeInBytes);\n    }\n    const data: unknown = await this.plugin.loadData();\n    if (data !== undefined && data !== null) {\n      return data;\n    }\n\n    const path = this.getDataFilePath();\n    if (path === null) {\n      return data;\n    }\n    const rawText = await this.readRawFile(path);\n    if (rawText === null) {\n      return data;\n    }\n\n    try {\n      const parsed: unknown = JSON.parse(rawText);\n      return parsed;\n    } catch (parseError) {\n      const error = new PluginDataParseError({\n        cause: parseError,\n        path,\n        pluginId: this.plugin.manifest.id,\n        pluginName: this.plugin.manifest.name,\n        recoveryCopy: await this.keepRecoveryCopy(path, rawText)\n      });\n      this.reportParseError(error);\n      throw error;\n    }\n  }\n\n  /**\n   * Saves data to the plugin's data file.\n   *\n   * The data is serialized exactly as Obsidian writes it, and its UTF-8 byte length is checked before anything is\n   * written.\n   *\n   * @param data - The data to save.\n   * @returns A promise that resolves when the data is saved.\n   * @throws {@link PluginDataSizeLimitExceededError} If the serialized data is larger than the limit.\n   */\n  public async saveData(data: unknown): Promise<void> {\n    if (this.maxSizeInBytes !== Infinity) {\n      // Obsidian's `writeJson` would swallow a serialization failure and write nothing; throwing here instead keeps\n      // the disk unchanged too, and tells the caller.\n      const serialized = JSON.stringify(data, undefined, OBSIDIAN_JSON_INDENT);\n      if (serialized !== undefined) {\n        const sizeInBytes = new TextEncoder().encode(serialized).byteLength;\n        if (sizeInBytes > this.maxSizeInBytes) {\n          throw this.createError(PluginDataOperation.Save, sizeInBytes);\n        }\n      }\n    }\n    await this.plugin.saveData(data);\n  }\n\n  /**\n   * Gets the path of the plugin's `data.json`, as Obsidian's `Plugin.loadData` reads it.\n   *\n   * @returns The path, or `null` when the manifest has no folder.\n   */\n  protected getDataFilePath(): null | string {\n    const directory = this.plugin.manifest.dir;\n    return directory ? normalizePath(`${directory}/data.json`) : null;\n  }\n\n  /**\n   * Tells the user that `data.json` could not be parsed: a notice naming the plugin and the path, and the error in the\n   * console.\n   *\n   * @param error - The parse error.\n   */\n  protected reportParseError(error: PluginDataParseError): void {\n    console.error(error);\n    new PluginNoticeComponent({\n      app: this.plugin.app,\n      pluginName: this.plugin.manifest.name\n    }).showNotice(\n      error.recoveryCopy === null\n        ? t(($) => $.obsidianLib.notices.dataFileUnparseable, { path: error.path })\n        : t(($) => $.obsidianLib.notices.dataFileUnparseableCopyKept, { path: error.path })\n    );\n  }\n\n  private createError(operation: PluginDataOperation, sizeInBytes: number): PluginDataSizeLimitExceededError {\n    return new PluginDataSizeLimitExceededError({\n      maxSizeInBytes: this.maxSizeInBytes,\n      operation,\n      path: this.getDataFilePath() ?? 'data.json',\n      pluginId: this.plugin.manifest.id,\n      pluginName: this.plugin.manifest.name,\n      sizeInBytes\n    });\n  }\n\n  private async getExistingFileSize(): Promise<null | number> {\n    if (this.maxSizeInBytes === Infinity) {\n      return null;\n    }\n    const path = this.getDataFilePath();\n    if (path === null) {\n      return null;\n    }\n    try {\n      const stat = await this.plugin.app.vault.adapter.stat(path);\n      return stat?.size ?? null;\n    } catch {\n      // The size is unknown, not oversized: Obsidian's own read decides what happens next, as before this guard.\n      return null;\n    }\n  }\n\n  private async keepRecoveryCopy(path: string, rawText: string): Promise<null | SettingsRecoveryCopy> {\n    if (this.recoveryStore === null) {\n      return null;\n    }\n    try {\n      return await this.recoveryStore.keep({ path, rawText, reason: SettingsRecoveryReason.InvalidJson });\n    } catch (error) {\n      console.error(new Error(`Could not keep a recovery copy of \"${path}\"`, { cause: error }));\n      return null;\n    }\n  }\n\n  private async readRawFile(path: string): Promise<null | string> {\n    const adapter = this.plugin.app.vault.adapter;\n    try {\n      return await adapter.exists(path) ? await adapter.read(path) : null;\n    } catch {\n      // Unreadable is not unparseable: Obsidian's own answer stands, as before this check.\n      return null;\n    }\n  }\n}\n\n/**\n * Thrown when a plugin's `data.json` exists but is not valid JSON.\n *\n * The file is never touched when this is thrown. When {@link recoveryCopy} is not `null`, a copy of the file's raw text\n * was kept on this device first, so even a later save over the file loses nothing.\n */\nexport class PluginDataParseError extends Error {\n  /**\n   * The path of the plugin's `data.json`.\n   */\n  public readonly path: string;\n\n  /**\n   * The `manifest.id` of the plugin.\n   */\n  public readonly pluginId: string;\n\n  /**\n   * The `manifest.name` of the plugin.\n   */\n  public readonly pluginName: string;\n\n  /**\n   * The recovery copy kept of the file, or `null` when none could be kept.\n   */\n  public readonly recoveryCopy: null | SettingsRecoveryCopy;\n\n  /**\n   * Creates a {@link PluginDataParseError}.\n   *\n   * @param params - The parameters for the error.\n   */\n  public constructor(params: PluginDataParseErrorConstructorParams) {\n    const copy = params.recoveryCopy === null\n      ? 'No recovery copy could be kept.'\n      : `A recovery copy was kept on this device as \"${params.recoveryCopy.id}\".`;\n    super(\n      `Plugin \"${params.pluginName}\" (${params.pluginId}): \"${params.path}\" is not valid JSON, so it could not be loaded. The file was left untouched. ${copy}`,\n      { cause: params.cause }\n    );\n    this.name = 'PluginDataParseError';\n    this.path = params.path;\n    this.pluginId = params.pluginId;\n    this.pluginName = params.pluginName;\n    this.recoveryCopy = params.recoveryCopy;\n  }\n}\n\n/**\n * Thrown when a plugin's `data.json` is, or would become, larger than the configured limit.\n *\n * The file on disk is never touched when this is thrown: an oversized existing file is left intact for the user to\n * inspect or trim, and an oversized save is refused before anything is written, so the last good file remains.\n */\nexport class PluginDataSizeLimitExceededError extends Error {\n  /**\n   * The size limit, in bytes.\n   */\n  public readonly maxSizeInBytes: number;\n\n  /**\n   * The refused operation.\n   */\n  public readonly operation: PluginDataOperation;\n\n  /**\n   * The path of the plugin's `data.json`.\n   */\n  public readonly path: string;\n\n  /**\n   * The `manifest.id` of the plugin.\n   */\n  public readonly pluginId: string;\n\n  /**\n   * The `manifest.name` of the plugin.\n   */\n  public readonly pluginName: string;\n\n  /**\n   * The size of the existing file (load) or of the serialized data (save), in bytes.\n   */\n  public readonly sizeInBytes: number;\n\n  /**\n   * Creates a {@link PluginDataSizeLimitExceededError}.\n   *\n   * @param params - The parameters for the error.\n   */\n  public constructor(params: PluginDataSizeLimitExceededErrorConstructorParams) {\n    const what = params.operation === PluginDataOperation.Load\n      ? `Refusing to load \"${params.path}\": the file is ${String(params.sizeInBytes)} bytes`\n      : `Refusing to save \"${params.path}\": the data would be ${String(params.sizeInBytes)} bytes`;\n    const consequence = params.operation === PluginDataOperation.Load\n      ? 'The file was left untouched.'\n      : 'Nothing was written, so the last saved file remains.';\n    super(\n      `Plugin \"${params.pluginName}\" (${params.pluginId}): ${what}, over the ${String(params.maxSizeInBytes)}-byte limit. ${consequence} `\n        + 'Keep data.json for small settings, and move large or growing state to LocalDataStore or SharedDataStore.'\n    );\n    this.name = 'PluginDataSizeLimitExceededError';\n    this.maxSizeInBytes = params.maxSizeInBytes;\n    this.operation = params.operation;\n    this.path = params.path;\n    this.pluginId = params.pluginId;\n    this.pluginName = params.pluginName;\n    this.sizeInBytes = params.sizeInBytes;\n  }\n}\n"],"mappings":"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","names":["PluginDataOperation"]}

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

@@ -55,6 +55,21 @@ export declare class DataStoreLocations {
      * @returns A promise that resolves when the new writer is ready.
      */
     relocate(location: DataStoreLocation): Promise<void>;
+    private buildChain;
     private createTransport;
+    /**
+     * Maps the records of an anchor folder that was moved (or sits under a moved folder) onto the folder the store is open
+     * at, because records name absolute folders.
+     *
+     * A transition that names its `anchor` is remapped from that folder exactly, so several successive moves resolve too.
+     * A transition written before that field existed names no anchor, and a moved anchor then looks the same as a chain whose
+     * first record has not arrived yet. So the former folder is inferred only when nothing starts at the initial identity,
+     * exactly one candidate folder (one the legacy records start from, in the initial format) yields a complete chain, and
+     * that folder no longer holds this store. Anything else is left for `buildChain` to reject.
+     *
+     * @param transitions - The transitions recorded at the anchor.
+     * @returns The transitions to build the chain from.
+     */
+    private resolveMovedAnchor;
     private validateLocation;
 }

package/dist/lib/esm/data-stores/data-store-locations.mjs

@@ -77,25 +77,7 @@ class DataStoreLocations {
       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 = 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);
-      }
-    }
+    const locations = this.buildChain(await this.resolveMovedAnchor(transitions));
     for (const location of locations) {
       this.validateLocation(location, locations);
     }
@@ -128,13 +110,73 @@ class DataStoreLocations {
     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 };
+    const value = { anchor: this.initial, format: 1, from, to: location };
     await this.anchor.write(`${this.anchor.root}/locations-v1/${window.crypto.randomUUID()}.json`, value);
     await this.refresh();
   }
+  buildChain(transitions) {
+    const remaining = [...transitions];
+    const locations = [this.initial];
+    let currentIdentity = identity(this.initial);
+    while (remaining.length > 0) {
+      const sourceIdentity = currentIdentity;
+      const next = remaining.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 = 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) {
+        remaining.splice(remaining.indexOf(transition), 1);
+      }
+    }
+    return locations;
+  }
   createTransport(location) {
     return new DataStoreTransport({ ...this.params, folder: location.folder, format: location.format ?? "markdown" });
   }
+  /**
+   * Maps the records of an anchor folder that was moved (or sits under a moved folder) onto the folder the store is open
+   * at, because records name absolute folders.
+   *
+   * A transition that names its `anchor` is remapped from that folder exactly, so several successive moves resolve too.
+   * A transition written before that field existed names no anchor, and a moved anchor then looks the same as a chain whose
+   * first record has not arrived yet. So the former folder is inferred only when nothing starts at the initial identity,
+   * exactly one candidate folder (one the legacy records start from, in the initial format) yields a complete chain, and
+   * that folder no longer holds this store. Anything else is left for `buildChain` to reject.
+   *
+   * @param transitions - The transitions recorded at the anchor.
+   * @returns The transitions to build the chain from.
+   */
+  async resolveMovedAnchor(transitions) {
+    const anchored = transitions.map((transition) => transition.anchor ? remapTransition(transition, transition.anchor.folder, this.initial.folder) : transition);
+    const initialIdentity = identity(this.initial);
+    if (anchored.some((transition) => identity(transition.from) === initialIdentity)) {
+      return anchored;
+    }
+    const candidates = new Set(anchored.filter((transition) => !transition.anchor).map((transition) => transition.from.folder));
+    const resolved = [];
+    for (const formerFolder of candidates) {
+      const remapped = anchored.map((transition) => transition.anchor ? transition : remapTransition(transition, formerFolder, this.initial.folder));
+      try {
+        this.buildChain(remapped);
+      } catch {
+        continue;
+      }
+      resolved.push({ formerFolder, transitions: remapped });
+    }
+    const match = resolved.length === 1 ? ensureNonNullable(resolved[0]) : null;
+    if (!match) {
+      return anchored;
+    }
+    const formerFiles = await this.createTransport({ ...this.initial, folder: match.formerFolder }).list();
+    return formerFiles.length > 0 ? anchored : match.transitions;
+  }
   validateLocation(location, locations = this.locations) {
     const transport = this.createTransport(location);
     for (const previous of locations) {
@@ -152,9 +194,25 @@ 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);
+  return typeof value === "object" && value !== null && "format" in value && value.format === 1 && "from" in value && isLocation(value.from) && "to" in value && isLocation(value.to) && (!("anchor" in value) || isLocation(value.anchor));
+}
+function remapLocation(location, formerFolder, folder) {
+  if (location.folder === formerFolder) {
+    return { ...location, folder };
+  }
+  if (location.folder.startsWith(`${formerFolder}/`)) {
+    return { ...location, folder: `${folder}${location.folder.slice(formerFolder.length)}` };
+  }
+  return location;
+}
+function remapTransition(transition, formerFolder, folder) {
+  return {
+    ...transition,
+    from: remapLocation(transition.from, formerFolder, folder),
+    to: remapLocation(transition.to, formerFolder, folder)
+  };
 }
 export {
   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":[]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/data-stores/data-store-locations.ts"],"sourcesContent":["/**\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 InferredChain {\n  readonly formerFolder: string;\n  readonly transitions: readonly Transition[];\n}\n\ninterface Transition {\n  /**\n   * The anchor the transition was written at. Absent from transitions written before it was added.\n   */\n  readonly anchor?: DataStoreLocation;\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.buildChain(await this.resolveMovedAnchor(transitions));\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 = { anchor: this.initial, 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 buildChain(transitions: readonly Transition[]): DataStoreLocation[] {\n    const remaining = [...transitions];\n    const locations = [this.initial];\n    let currentIdentity = identity(this.initial);\n    while (remaining.length > 0) {\n      const sourceIdentity = currentIdentity;\n      const next = remaining.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        remaining.splice(remaining.indexOf(transition), 1);\n      }\n    }\n    return locations;\n  }\n\n  private createTransport(location: DataStoreLocation): DataStoreTransport {\n    return new DataStoreTransport({ ...this.params, folder: location.folder, format: location.format ?? 'markdown' });\n  }\n\n  /**\n   * Maps the records of an anchor folder that was moved (or sits under a moved folder) onto the folder the store is open\n   * at, because records name absolute folders.\n   *\n   * A transition that names its `anchor` is remapped from that folder exactly, so several successive moves resolve too.\n   * A transition written before that field existed names no anchor, and a moved anchor then looks the same as a chain whose\n   * first record has not arrived yet. So the former folder is inferred only when nothing starts at the initial identity,\n   * exactly one candidate folder (one the legacy records start from, in the initial format) yields a complete chain, and\n   * that folder no longer holds this store. Anything else is left for `buildChain` to reject.\n   *\n   * @param transitions - The transitions recorded at the anchor.\n   * @returns The transitions to build the chain from.\n   */\n  private async resolveMovedAnchor(transitions: readonly Transition[]): Promise<readonly Transition[]> {\n    const anchored = transitions.map((transition) => transition.anchor ? remapTransition(transition, transition.anchor.folder, this.initial.folder) : transition);\n    const initialIdentity = identity(this.initial);\n    if (anchored.some((transition) => identity(transition.from) === initialIdentity)) {\n      return anchored;\n    }\n    // A candidate that cannot produce a transition from the initial identity fails `buildChain` below.\n    const candidates = new Set(anchored.filter((transition) => !transition.anchor).map((transition) => transition.from.folder));\n    const resolved: InferredChain[] = [];\n    for (const formerFolder of candidates) {\n      const remapped = anchored.map((transition) => transition.anchor ? transition : remapTransition(transition, formerFolder, this.initial.folder));\n      try {\n        this.buildChain(remapped);\n      } catch {\n        continue;\n      }\n      resolved.push({ formerFolder, transitions: remapped });\n    }\n    const match = resolved.length === 1 ? ensureNonNullable(resolved[0]) : null;\n    if (!match) {\n      return anchored;\n    }\n    const formerFiles = await this.createTransport({ ...this.initial, folder: match.formerFolder }).list();\n    return formerFiles.length > 0 ? anchored : match.transitions;\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\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    && (!('anchor' in value) || isLocation(value.anchor));\n}\n\nfunction remapLocation(location: DataStoreLocation, formerFolder: string, folder: string): DataStoreLocation {\n  if (location.folder === formerFolder) {\n    return { ...location, folder };\n  }\n  if (location.folder.startsWith(`${formerFolder}/`)) {\n    return { ...location, folder: `${folder}${location.folder.slice(formerFolder.length)}` };\n  }\n  return location;\n}\n\nfunction remapTransition(transition: Transition, formerFolder: string, folder: string): Transition {\n  return {\n    ...transition,\n    from: remapLocation(transition.from, formerFolder, folder),\n    to: remapLocation(transition.to, formerFolder, folder)\n  };\n}\n"],"mappings":"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","names":[]}