@vrtmrz/livesync-commonlib 0.1.0-rc.0 → 0.1.0-rc.10

package/dist/common/settingConstants.js

@@ -1,4 +1,4 @@
-import { $t } from "./i18n.js";
+import { englishMessageTranslator } from "../services/base/MessageTranslator.js";
 import {
   DEFAULT_SETTINGS,
   configurationNames
@@ -324,12 +324,12 @@ const SettingInformation = {
     desc: "If this enabled, All files are handled as case-Sensitive (Previous behaviour)."
   },
   doNotUseFixedRevisionForChunks: {
-    name: "Compute revisions for chunks",
-    desc: "If this enabled, all chunks will be stored with the revision made from its content."
+    name: "Content-derived chunk revisions (obsolete setting)",
+    desc: "Chunk revisions are always derived from their content. This stored key is retained only for compatibility."
   },
   sendChunksBulkMaxSize: {
-    name: "Maximum size of chunks to send in one request",
-    desc: "MB"
+    name: "Maximum request size for manually resending chunks",
+    desc: "MB per request"
   },
   useAdvancedMode: {
     name: "Enable advanced features"
@@ -399,7 +399,7 @@ const SettingInformation = {
     desc: "Files with modification times greater than this value (in seconds since the Unix epoch) will not have their events reflected. Set to 0 to disable this limit."
   }
 };
-function translateInfo(infoSrc, translate = (message) => $t(message)) {
+function translateInfo(infoSrc, translate = englishMessageTranslator) {
   if (!infoSrc) return false;
   const info = { ...infoSrc };
   info.name = translate(info.name);

package/dist/common/types.d.ts

@@ -10,7 +10,8 @@ import { IDPrefixes, LEAF_WAIT_ONLY_REMOTE, LEAF_WAIT_TIMEOUT, LEAF_WAIT_TIMEOUT
 import { AutoAccepting, type BucketSyncSetting, type ChunkSplitterVersion, type ConfigPassphraseStore, type CouchDBConnection, type E2EEAlgorithm, type EncryptionSettings, type HashAlgorithm, type HasSettings, type LocalDBSettings, type ObsidianLiveSyncSettings, type P2PConnectionInfo, type P2PSyncSetting, type PluginSyncSettingEntry, type RemoteDBSettings, type RemoteType, type RemoteTypeSettings, type SYNC_MODE } from "./models/setting.type.js";
 import { ChunkAlgorithmNames, ChunkAlgorithms, CURRENT_SETTING_VERSION, E2EEAlgorithmNames, E2EEAlgorithms, HashAlgorithms, REMOTE_COUCHDB, REMOTE_MINIO, REMOTE_P2P, RemoteTypes, SETTING_VERSION_INITIAL, SETTING_VERSION_SUPPORT_CASE_INSENSITIVE, MODE_AUTOMATIC, MODE_PAUSED, MODE_SELECTIVE, MODE_SHINY } from "./models/setting.const.js";
 import { PREFERRED_BASE, PREFERRED_JOURNAL_SYNC, PREFERRED_SETTING_CLOUDANT, PREFERRED_SETTING_SELF_HOSTED } from "./models/setting.const.preferred.js";
-import { P2P_DEFAULT_SETTINGS, DEFAULT_SETTINGS } from "./models/setting.const.defaults.js";
+import { P2P_DEFAULT_SETTINGS, DEFAULT_SETTINGS, NEW_VAULT_SETTINGS, SETTINGS_SCHEMA_DEFAULTS, createNewVaultSettings } from "./models/setting.const.defaults.js";
+import { prepareSettingsForLoad, SettingsMigrationReviewCodes, type PreparedSettings, type SettingsMigrationReviewCode, type SettingsMigrationReviewReason, type SettingsMigrationState } from "./models/setting.lifecycle.js";
 import { KeyIndexOfSettings } from "./models/setting.const.qr.js";
 import type { DeviceInfo, EntryBody, EntryDoc, EntryDocResponse, EntryMilestoneInfo, EntryNodeInfo, NodeData, NodeKey } from "./models/db.definition.js";
 import { isMetaEntry } from "./models/db.definition.js";
@@ -42,7 +43,8 @@ export type { EncryptionSettings };
 export { HashAlgorithms, type HashAlgorithm, ChunkAlgorithmNames, ChunkAlgorithms, type ChunkSplitterVersion };
 export type { RemoteDBSettings };
 export type { ObsidianLiveSyncSettings };
-export { DEFAULT_SETTINGS };
+export { DEFAULT_SETTINGS, NEW_VAULT_SETTINGS, SETTINGS_SCHEMA_DEFAULTS, createNewVaultSettings };
+export { prepareSettingsForLoad, SettingsMigrationReviewCodes, type PreparedSettings, type SettingsMigrationReviewCode, type SettingsMigrationReviewReason, type SettingsMigrationState, };
 export { KeyIndexOfSettings };
 export { type HasSettings };
 export { PREFERRED_BASE, PREFERRED_SETTING_CLOUDANT, PREFERRED_SETTING_SELF_HOSTED, PREFERRED_JOURNAL_SYNC };

package/dist/common/types.js

@@ -67,7 +67,17 @@ import {
   PREFERRED_SETTING_CLOUDANT,
   PREFERRED_SETTING_SELF_HOSTED
 } from "./models/setting.const.preferred.js";
-import { P2P_DEFAULT_SETTINGS, DEFAULT_SETTINGS } from "./models/setting.const.defaults.js";
+import {
+  P2P_DEFAULT_SETTINGS,
+  DEFAULT_SETTINGS,
+  NEW_VAULT_SETTINGS,
+  SETTINGS_SCHEMA_DEFAULTS,
+  createNewVaultSettings
+} from "./models/setting.const.defaults.js";
+import {
+  prepareSettingsForLoad,
+  SettingsMigrationReviewCodes
+} from "./models/setting.lifecycle.js";
 import { KeyIndexOfSettings } from "./models/setting.const.qr.js";
 import { isMetaEntry } from "./models/db.definition.js";
 import {
@@ -165,6 +175,7 @@ export {
   MODE_PAUSED,
   MODE_SELECTIVE,
   MODE_SHINY,
+  NEW_VAULT_SETTINGS,
   NODEINFO_DOCID,
   NOT_CONFLICTED,
   NoteTypes,
@@ -190,10 +201,12 @@ export {
   SALT_OF_ID,
   SALT_OF_PASSPHRASE,
   SEED_MURMURHASH,
+  SETTINGS_SCHEMA_DEFAULTS,
   SETTING_KEY_P2P_DEVICE_NAME,
   SETTING_VERSION_INITIAL,
   SETTING_VERSION_SUPPORT_CASE_INSENSITIVE,
   SYNCINFO_ID,
+  SettingsMigrationReviewCodes,
   SuffixDatabaseName,
   TIME_ARGUMENT_INFINITY,
   TweakValuesDefault,
@@ -207,6 +220,8 @@ export {
   configURIBase,
   configURIBaseQR,
   configurationNames,
+  createNewVaultSettings,
   isMetaEntry,
+  prepareSettingsForLoad,
   statusDisplay
 };

package/dist/context.d.ts

@@ -5,4 +5,6 @@
  */
 export { ServiceContext, createServiceContext, type ServiceContextContract, type ServiceContextOptions, } from "./services/base/ServiceBase.js";
 export { createLiveSyncEventHub, type LiveSyncEventHub } from "./hub/hub.js";
-export { passthroughMessageTranslator, type MessageTranslator, type TranslationParameters, } from "./services/base/MessageTranslator.js";
+export { englishMessageTranslator, passthroughMessageTranslator, type MessageTranslator, type TranslationParameters, } from "./services/base/MessageTranslator.js";
+export { commonlibEnglishMessages, type CommonlibMessageKey } from "./services/base/CommonlibMessages.js";
+export type { StandardIo, StandardIoChunk } from "./platform/standardIo.js";

package/dist/context.js

@@ -4,11 +4,15 @@ import {
 } from "./services/base/ServiceBase.js";
 import { createLiveSyncEventHub } from "./hub/hub.js";
 import {
+  englishMessageTranslator,
   passthroughMessageTranslator
 } from "./services/base/MessageTranslator.js";
+import { commonlibEnglishMessages } from "./services/base/CommonlibMessages.js";
 export {
   ServiceContext,
+  commonlibEnglishMessages,
   createLiveSyncEventHub,
   createServiceContext,
+  englishMessageTranslator,
   passthroughMessageTranslator
 };

package/dist/interfaces/Confirm.d.ts

@@ -1,3 +1,4 @@
+export type ConfirmActionLayout = "auto" | "vertical";
 export interface Confirm {
     askYesNo(message: string): Promise<"yes" | "no">;
     askString(title: string, key: string, placeholder: string, isPassword?: boolean): Promise<string | false>;
@@ -12,6 +13,13 @@ export interface Confirm {
         defaultAction: T[number];
         timeout?: number;
     }): Promise<T[number] | false>;
-    askInPopup(key: string, dialogText: string, anchorCallback: (anchor: HTMLAnchorElement) => void): void;
-    confirmWithMessage(title: string, contentMd: string, buttons: string[], defaultAction: (typeof buttons)[number], timeout?: number): Promise<(typeof buttons)[number] | false>;
+    /**
+     * Shows a non-blocking message containing one host-rendered action link.
+     *
+     * Hosts which can display transient UI should keep the message visible for
+     * `durationMs`. Headless hosts may report the message without presenting an
+     * interactive action.
+     */
+    askInPopup(key: string, dialogText: string, anchorCallback: (anchor: HTMLAnchorElement) => void, durationMs?: number): void;
+    confirmWithMessage(title: string, contentMd: string, buttons: string[], defaultAction: (typeof buttons)[number], timeout?: number, actionLayout?: ConfirmActionLayout): Promise<(typeof buttons)[number] | false>;
 }

package/dist/interfaces/DatabaseFileAccess.d.ts

@@ -2,10 +2,18 @@ import type { FilePathWithPrefix, LoadedEntry, MetaEntry, UXFileInfo, UXFileInfo
 export interface DatabaseFileAccess {
     delete: (file: UXFileInfoStub | FilePathWithPrefix, rev?: string) => Promise<boolean>;
     store: (file: UXFileInfo, force?: boolean, skipCheck?: boolean) => Promise<boolean>;
+    /** Store a file as a child of an exact revision and return the created revision. */
+    storeWithBaseRevision: (file: UXFileInfo, baseRevision: string | undefined, skipCheck?: boolean) => Promise<string | false>;
     storeAsConflictedRevision: (file: UXFileInfo, currentRev: string, skipCheck?: boolean) => Promise<boolean>;
+    /** Preserve unknown storage content as a conflict and return its exact revision. */
+    storeAsConflictedRevisionWithResult: (file: UXFileInfo, currentRev: string, skipCheck?: boolean) => Promise<string | false>;
+    /** Store a user deletion as a visible logical-deletion child of an exact revision. */
+    storeDeletionWithBaseRevision: (file: UXFileInfoStub | FilePathWithPrefix, baseRevision: string) => Promise<string | false>;
     storeContent(path: FilePathWithPrefix, content: string): Promise<boolean>;
     createChunks: (file: UXFileInfo, force?: boolean, skipCheck?: boolean) => Promise<boolean>;
     hasContentInRevisionHistory: (file: UXFileInfoStub | FilePathWithPrefix, content: string | string[] | Blob | ArrayBuffer, currentRev?: string) => Promise<boolean>;
+    /** Return every available revision whose content exactly matches the supplied bytes. */
+    findContentRevisions: (file: UXFileInfoStub | FilePathWithPrefix, content: string | string[] | Blob | ArrayBuffer, currentRev?: string) => Promise<string[]>;
     fetch: (file: UXFileInfoStub | FilePathWithPrefix, rev?: string, waitForReady?: boolean, skipCheck?: boolean) => Promise<UXFileInfo | false>;
     fetchEntryFromMeta: (meta: MetaEntry, waitForReady?: boolean, skipCheck?: boolean) => Promise<LoadedEntry | false>;
     fetchEntryMeta: (file: UXFileInfoStub | FilePathWithPrefix, rev?: string, skipCheck?: boolean) => Promise<MetaEntry | false>;

package/dist/interfaces/DatabaseRebuilder.d.ts

@@ -4,8 +4,18 @@ export interface Rebuilder {
     $rebuildEverything(): Promise<void>;
     $fetchLocal(makeLocalChunkBeforeSync?: boolean, preventMakeLocalFilesBeforeSync?: boolean): Promise<void>;
     $fetchLocalDBFast(autoResume: boolean): Promise<void>;
-    scheduleRebuild(): Promise<void>;
-    scheduleFetch(): Promise<void>;
+    /**
+     * Writes the Rebuild flag, suspends the current runtime, optionally prepares
+     * persisted state, and requests a restart, in that order.
+     *
+     * The preparation callback runs only after the flag exists. If it fails,
+     * the flag is removed, the current runtime is resumed, and the error is
+     * rethrown. A false result means that the flag could not be written and no
+     * restart was requested.
+     */
+    scheduleRebuild(prepareBeforeRestart?: () => Promise<void>): Promise<boolean>;
+    /** See {@link scheduleRebuild}; this variant writes the Fetch flag. */
+    scheduleFetch(prepareBeforeRestart?: () => Promise<void>): Promise<boolean>;
     /**
      * Declares the finish of the rebuild process and unlock remote, resume reflecting the changes.
      */

package/dist/interfaces/FileReflectionProvenance.d.ts

@@ -0,0 +1,32 @@
+import type { FilePathWithPrefix } from "../common/types.js";
+import type { SimpleStore } from "../common/utils.js";
+export type FileReflectionProvenanceRecord = {
+    /** Exact database revision which most recently produced the storage state. */
+    revision: string;
+    /** Raw modification time observed from this device's storage after reflection. */
+    observedStorageMtime?: number;
+};
+export interface FileReflectionProvenance {
+    get(path: FilePathWithPrefix): Promise<FileReflectionProvenanceRecord | undefined>;
+    set(path: FilePathWithPrefix, record: FileReflectionProvenanceRecord): Promise<void>;
+    delete(path: FilePathWithPrefix): Promise<void>;
+    move(from: FilePathWithPrefix, to: FilePathWithPrefix): Promise<void>;
+}
+/**
+ * Device-local provenance backed by an existing host-owned key-value store.
+ *
+ * The revision is authoritative. The raw storage mtime is diagnostic and may
+ * be used as a fast change hint, but it never proves content or branch identity.
+ * The host may construct this object before opening its store, but it must not
+ * invoke provenance operations until its normal storage lifecycle is ready.
+ * Store failures are reported to the caller rather than hidden by readiness
+ * waits, so lifecycle violations and reset races cannot hang file processing.
+ */
+export declare class StoredFileReflectionProvenance implements FileReflectionProvenance {
+    private readonly store;
+    constructor(store: SimpleStore<FileReflectionProvenanceRecord>);
+    get(path: FilePathWithPrefix): Promise<FileReflectionProvenanceRecord | undefined>;
+    set(path: FilePathWithPrefix, record: FileReflectionProvenanceRecord): Promise<void>;
+    delete(path: FilePathWithPrefix): Promise<void>;
+    move(from: FilePathWithPrefix, to: FilePathWithPrefix): Promise<void>;
+}

package/dist/interfaces/FileReflectionProvenance.js

@@ -0,0 +1,25 @@
+class StoredFileReflectionProvenance {
+  constructor(store) {
+    this.store = store;
+  }
+  store;
+  async get(path) {
+    return await this.store.get(path) ?? void 0;
+  }
+  async set(path, record) {
+    await this.store.set(path, record);
+  }
+  async delete(path) {
+    await this.store.delete(path);
+  }
+  async move(from, to) {
+    const record = await this.get(from);
+    if (record) {
+      await this.set(to, record);
+    }
+    await this.delete(from);
+  }
+}
+export {
+  StoredFileReflectionProvenance
+};

package/dist/managers/ConflictManager.js

@@ -258,13 +258,22 @@ class ConflictManager {
   }
   async tryAutoMergeSensibly(path, test, conflicts) {
     const conflictedRev = conflicts[0];
-    const conflictedRevNo = Number(conflictedRev.split("-")[0]);
-    const revFrom = await this.database.get(await this.options.pathService.path2id(path), {
-      revs_info: true
-    });
-    const commonBase = (revFrom._revs_info || []).filter(
-      (e) => e.status == "available" && Number(e.rev.split("-")[0]) < conflictedRevNo
-    )?.[0]?.rev ?? "";
+    let commonBase = "";
+    try {
+      const documentId = await this.options.pathService.path2id(path);
+      const [currentBranch, conflictedBranch] = await Promise.all([
+        this.database.get(documentId, { rev: test._rev, revs_info: true }),
+        this.database.get(documentId, { rev: conflictedRev, revs_info: true })
+      ]);
+      const currentAvailable = new Set(
+        (currentBranch._revs_info || []).filter((revision) => revision.status === "available").map((revision) => revision.rev)
+      );
+      commonBase = (conflictedBranch._revs_info || []).filter((revision) => revision.status === "available" && currentAvailable.has(revision.rev)).sort((left, right) => Number(right.rev.split("-")[0]) - Number(left.rev.split("-")[0]))[0]?.rev ?? "";
+    } catch (ex) {
+      Logger(`Could not determine the common revision for ${path}`, LOG_LEVEL_VERBOSE);
+      Logger(ex, LOG_LEVEL_VERBOSE);
+      return false;
+    }
     let p = void 0;
     if (commonBase) {
       if (isSensibleMargeApplicable(path)) {

package/dist/managers/EntryManager/EntryManager.d.ts

@@ -33,5 +33,6 @@ export declare class EntryManager {
     getDBEntry(path: FilePathWithPrefix | FilePath, opt?: PouchDB.Core.GetOptions, dump?: boolean, waitForReady?: boolean, includeDeleted?: boolean): Promise<false | LoadedEntry>;
     getDBEntryFromMeta(meta: LoadedEntry | MetaEntry, dump?: boolean, waitForReady?: boolean): Promise<false | LoadedEntry>;
     deleteDBEntry(path: FilePathWithPrefix | FilePath, opt?: PouchDB.Core.GetOptions): Promise<boolean>;
+    storeDeletionAtRevision(path: FilePathWithPrefix | FilePath, baseRevision: string): Promise<false | PouchDB.Core.Response>;
     putDBEntry(note: SavingEntry, onlyChunks?: boolean, conflictBaseRev?: string): Promise<false | PouchDB.Core.Response>;
 }

package/dist/managers/EntryManager/EntryManager.js

@@ -8,7 +8,8 @@ import {
   getDBEntryMetaByPath,
   isTargetFile,
   prepareChunk,
-  putDBEntry
+  putDBEntry,
+  storeDeletionByPathAtRevision
 } from "./EntryManagerImpls.js";
 class EntryManager {
   options;
@@ -64,6 +65,9 @@ class EntryManager {
   async deleteDBEntry(path, opt) {
     return await deleteDBEntryByPath(this.serviceHost, this, path, opt);
   }
+  async storeDeletionAtRevision(path, baseRevision) {
+    return await storeDeletionByPathAtRevision(this.serviceHost, this, path, baseRevision);
+  }
   async putDBEntry(note, onlyChunks, conflictBaseRev) {
     return await putDBEntry(this.serviceHost, this, note, onlyChunks, conflictBaseRev);
   }

package/dist/managers/EntryManager/EntryManagerImpls.d.ts

@@ -71,4 +71,5 @@ export declare function getDBEntryByPath(host: NecessaryServicesInterfaces<"path
     datatype: import("../../common/types.js").EntryTypeNotes;
 } & PouchDB.Core.IdMeta)>;
 export declare function deleteDBEntryByPath(host: NecessaryServicesInterfaces<"path" | "setting", never>, { localDatabase }: NecessaryManagers<"localDatabase">, path: FilePathWithPrefix | FilePath, opt?: PouchDB.Core.GetOptions): Promise<boolean>;
+export declare function storeDeletionByPathAtRevision(host: NecessaryServicesInterfaces<"path" | "setting", never>, { localDatabase }: NecessaryManagers<"localDatabase">, path: FilePathWithPrefix | FilePath, baseRevision: string): Promise<PouchDB.Core.Response | false>;
 export {};

package/dist/managers/EntryManager/EntryManagerImpls.js

@@ -484,6 +484,33 @@ async function deleteDBEntryByPath(host, { localDatabase }, path, opt) {
     throw ex;
   }
 }
+async function storeDeletionByPathAtRevision(host, { localDatabase }, path, baseRevision) {
+  if (!isTargetFile(host, path)) {
+    return false;
+  }
+  const id = await host.services.path.path2id(path);
+  try {
+    return await serialized("file:" + path, async () => {
+      const obj = await localDatabase.get(id, {
+        rev: baseRevision
+      });
+      if (obj.type === "leaf") {
+        return false;
+      }
+      delete obj._deleted;
+      obj.deleted = true;
+      obj.mtime = Date.now();
+      const result = await localDatabase.put(obj, { force: true });
+      Logger(`Entry soft-deleted from revision: ${path} (${obj._id.substring(0, 8)}-${result.rev})`);
+      return result;
+    }) ?? false;
+  } catch (ex) {
+    if (isErrorOfMissingDoc(ex)) {
+      return false;
+    }
+    throw ex;
+  }
+}
 export {
   canUseOnDemandChunking,
   computeChunkRetrievalMethod,
@@ -495,5 +522,6 @@ export {
   isLegacyNote,
   isTargetFile,
   prepareChunk,
-  putDBEntry
+  putDBEntry,
+  storeDeletionByPathAtRevision
 };

package/dist/platform/node/index.d.ts

@@ -21,3 +21,4 @@ export declare const builtinModules: readonly string[];
 /** Returns whether a module specifier refers to a Node built-in. */
 export declare const isBuiltin: typeof nodeIsBuiltin;
 export { NodeStorageAdapter, createNodeStorage, validateStoragePath, type CreateNodeStorageOptions, type NodeStorageStat, } from "./storage.js";
+export { createNodeStandardIo, type CreateNodeStandardIoOptions, type NodeStandardInput, type NodeStandardOutput, } from "./standardIo.js";

package/dist/platform/node/index.js

@@ -17,9 +17,13 @@ import {
   createNodeStorage,
   validateStoragePath
 } from "./storage.js";
+import {
+  createNodeStandardIo
+} from "./standardIo.js";
 export {
   NodeStorageAdapter,
   builtinModules,
+  createNodeStandardIo,
   createNodeStorage,
   fileURLToPath,
   fs,

package/dist/platform/node/standardIo.d.ts

@@ -0,0 +1,24 @@
+import type { StandardIo, StandardIoChunk } from "../standardIo.js";
+/** Minimal readable stream shape accepted by the Node standard-I/O adapter. */
+export type NodeStandardInput = AsyncIterable<unknown> & NodeJS.ReadableStream;
+/** Minimal writable stream shape accepted by the Node standard-I/O adapter. */
+export interface NodeStandardOutput extends NodeJS.WritableStream {
+    write(chunk: StandardIoChunk): boolean;
+}
+/** Streams used by {@link createNodeStandardIo}. */
+export interface CreateNodeStandardIoOptions {
+    /** Defaults to `process.stdin`. */
+    stdin?: NodeStandardInput;
+    /** Defaults to `process.stdout`. */
+    stdout?: NodeStandardOutput;
+    /** Defaults to `process.stderr`. */
+    stderr?: NodeStandardOutput;
+}
+/**
+ * Bind the host-neutral standard-I/O contract to Node streams.
+ *
+ * Supplying streams is useful for embedded command-line hosts and tests. The
+ * caller owns stream lifecycle; this adapter only closes the temporary
+ * readline interface created by {@link StandardIo.prompt}.
+ */
+export declare function createNodeStandardIo(options?: CreateNodeStandardIoOptions): StandardIo;

package/dist/platform/node/standardIo.js

@@ -0,0 +1,39 @@
+import * as nodeReadlinePromises from "node:readline/promises";
+function createNodeStandardIo(options = {}) {
+  const stdin = options.stdin ?? process.stdin;
+  const stdout = options.stdout ?? process.stdout;
+  const stderr = options.stderr ?? process.stderr;
+  return {
+    async readStdin() {
+      const decoder = new TextDecoder();
+      let content = "";
+      for await (const chunk of stdin) {
+        if (typeof chunk === "string") {
+          content += chunk;
+        } else if (chunk instanceof Uint8Array) {
+          content += decoder.decode(chunk, { stream: true });
+        } else {
+          throw new TypeError("Standard input yielded a value which is neither text nor binary data.");
+        }
+      }
+      return content + decoder.decode();
+    },
+    async prompt(question) {
+      const readline = nodeReadlinePromises.createInterface({ input: stdin, output: stdout });
+      try {
+        return await readline.question(question);
+      } finally {
+        readline.close();
+      }
+    },
+    writeStdout(chunk) {
+      stdout.write(chunk);
+    },
+    writeStderr(chunk) {
+      stderr.write(chunk);
+    }
+  };
+}
+export {
+  createNodeStandardIo
+};

package/dist/platform/node/storage.d.ts

@@ -2,7 +2,12 @@ import type { UXDataWriteOptions, UXStat } from "../../common/types.js";
 import type { IStorageAdapter } from "../../serviceModules/adapters/IStorageAdapter.js";
 export type NodeStorageStat = UXStat;
 export interface CreateNodeStorageOptions {
-    /** Absolute or process-relative directory which bounds every adapter operation. */
+    /**
+     * Host-selected root directory. Adapter paths are resolved relative to this root.
+     *
+     * The host owns this trust boundary. The adapter is not a filesystem sandbox against
+     * an untrusted local process which can replace path components concurrently.
+     */
     rootPath: string;
 }
 /** Rooted storage adapter backed by Node's file-system APIs. */
@@ -10,6 +15,7 @@ export declare class NodeStorageAdapter implements IStorageAdapter<NodeStorageSt
     private readonly rootPath;
     constructor(rootPath: string);
     private resolvePath;
+    private assertNoSymbolicLinks;
     exists(path: string): Promise<boolean>;
     trystat(path: string): Promise<NodeStorageStat | null>;
     stat(path: string): Promise<NodeStorageStat | null>;
@@ -20,10 +26,13 @@ export declare class NodeStorageAdapter implements IStorageAdapter<NodeStorageSt
     write(path: string, data: string, options?: UXDataWriteOptions): Promise<void>;
     writeBinary(path: string, data: ArrayBuffer, options?: UXDataWriteOptions): Promise<void>;
     append(path: string, data: string, options?: UXDataWriteOptions): Promise<void>;
+    /** Atomically rename or move an entry without leaving the injected root. */
+    rename(sourcePath: string, targetPath: string): Promise<void>;
     list(basePath: string): Promise<{
         files: string[];
         folders: string[];
     }>;
+    private writeFile;
     private applyTimes;
 }
 /** Bind a Node storage adapter to an explicitly selected root directory. */