@soda-gql/common 0.11.10 → 0.11.11

package/dist/portable-B3K3IE7E.cjs

@@ -0,0 +1,239 @@
+const require_canonical_id = require('./canonical-id-DHdeYIsT.cjs');
+let node_crypto = require("node:crypto");
+
+//#region packages/common/src/portable/fs.ts
+let nodeFsPromises = null;
+const getNodeFS = async () => {
+	if (!nodeFsPromises) {
+		const fs = await import("node:fs/promises");
+		nodeFsPromises = fs;
+	}
+	return nodeFsPromises;
+};
+let nodeFsSync = null;
+const getNodeFSSync = () => {
+	if (!nodeFsSync) {
+		nodeFsSync = require("node:fs");
+	}
+	return nodeFsSync;
+};
+let pathModule = null;
+const getPathModule = () => {
+	if (!pathModule) {
+		pathModule = require("node:path");
+	}
+	return pathModule;
+};
+/**
+* Generate a unique temp file path for atomic write.
+*/
+const getTempPath = (targetPath) => {
+	return `${targetPath}.${process.pid}.${Date.now()}.tmp`;
+};
+function createPortableFS() {
+	return {
+		async readFile(path) {
+			const nodeFS = await getNodeFS();
+			return await nodeFS.readFile(path, "utf-8");
+		},
+		async writeFile(path, content) {
+			const nodeFS = await getNodeFS();
+			const pathModule$1 = await import("node:path");
+			const dir = pathModule$1.dirname(path);
+			await nodeFS.mkdir(dir, { recursive: true });
+			await nodeFS.writeFile(path, content, "utf-8");
+		},
+		async writeFileAtomic(path, content) {
+			const nodeFS = await getNodeFS();
+			const pathMod = await import("node:path");
+			const dir = pathMod.dirname(path);
+			const tempPath = getTempPath(path);
+			try {
+				await nodeFS.mkdir(dir, { recursive: true });
+				await nodeFS.writeFile(tempPath, content, "utf-8");
+				await nodeFS.rename(tempPath, path);
+			} catch (error) {
+				try {
+					await nodeFS.unlink(tempPath);
+				} catch {}
+				throw error;
+			}
+		},
+		async exists(path) {
+			const nodeFS = await getNodeFS();
+			try {
+				await nodeFS.access(path);
+				return true;
+			} catch {
+				return false;
+			}
+		},
+		async stat(path) {
+			const nodeFS = await getNodeFS();
+			const stats = await nodeFS.stat(path);
+			return {
+				mtime: stats.mtime,
+				size: stats.size
+			};
+		},
+		async rename(oldPath, newPath) {
+			const nodeFS = await getNodeFS();
+			await nodeFS.rename(oldPath, newPath);
+		},
+		async mkdir(path, options) {
+			const nodeFS = await getNodeFS();
+			await nodeFS.mkdir(path, options);
+		},
+		writeFileSyncAtomic(path, content) {
+			const fsSync = getNodeFSSync();
+			const pathMod = getPathModule();
+			const tempPath = getTempPath(path);
+			const dir = pathMod.dirname(path);
+			fsSync.mkdirSync(dir, { recursive: true });
+			try {
+				fsSync.writeFileSync(tempPath, content, "utf-8");
+				fsSync.renameSync(tempPath, path);
+			} catch (error) {
+				try {
+					fsSync.unlinkSync(tempPath);
+				} catch {}
+				throw error;
+			}
+		},
+		async unlink(path) {
+			const nodeFS = await getNodeFS();
+			try {
+				await nodeFS.unlink(path);
+			} catch (error) {
+				if (error.code !== "ENOENT") {
+					throw error;
+				}
+			}
+		},
+		unlinkSync(path) {
+			const fsSync = getNodeFSSync();
+			try {
+				fsSync.unlinkSync(path);
+			} catch (error) {
+				if (error.code !== "ENOENT") {
+					throw error;
+				}
+			}
+		},
+		readFileSync(path) {
+			const fsSync = getNodeFSSync();
+			return fsSync.readFileSync(path, "utf-8");
+		}
+	};
+}
+let fsInstance = null;
+function getPortableFS() {
+	if (!fsInstance) {
+		fsInstance = createPortableFS();
+	}
+	return fsInstance;
+}
+/**
+* Reset the filesystem singleton for testing
+* @internal
+*/
+function __resetPortableFSForTests() {
+	fsInstance = null;
+}
+
+//#endregion
+//#region packages/common/src/portable/hash.ts
+/**
+* Portable hashing API using Node.js crypto
+*/
+function createPortableHasher() {
+	return { hash(content, algorithm = "xxhash") {
+		if (algorithm === "sha256") {
+			return (0, node_crypto.createHash)("sha256").update(content).digest("hex");
+		}
+		const sha256Hash = (0, node_crypto.createHash)("sha256").update(content).digest("hex");
+		return sha256Hash.substring(0, 16);
+	} };
+}
+let hasherInstance = null;
+function getPortableHasher() {
+	if (!hasherInstance) {
+		hasherInstance = createPortableHasher();
+	}
+	return hasherInstance;
+}
+/**
+* Reset the hasher singleton for testing
+* @internal
+*/
+function __resetPortableHasherForTests() {
+	hasherInstance = null;
+}
+
+//#endregion
+//#region packages/common/src/portable/runtime.ts
+/**
+* Runtime detection utilities for portable API implementation
+* Note: Bun-specific code has been removed. Node.js APIs are always used.
+*/
+const runtime = {
+	isBun: false,
+	isNode: typeof process !== "undefined",
+	supportsWebCrypto: typeof crypto !== "undefined" && typeof crypto.subtle !== "undefined"
+};
+/**
+* Reset runtime state for testing purposes only
+* @internal
+*/
+function resetPortableForTests() {}
+
+//#endregion
+Object.defineProperty(exports, '__resetPortableFSForTests', {
+  enumerable: true,
+  get: function () {
+    return __resetPortableFSForTests;
+  }
+});
+Object.defineProperty(exports, '__resetPortableHasherForTests', {
+  enumerable: true,
+  get: function () {
+    return __resetPortableHasherForTests;
+  }
+});
+Object.defineProperty(exports, 'createPortableFS', {
+  enumerable: true,
+  get: function () {
+    return createPortableFS;
+  }
+});
+Object.defineProperty(exports, 'createPortableHasher', {
+  enumerable: true,
+  get: function () {
+    return createPortableHasher;
+  }
+});
+Object.defineProperty(exports, 'getPortableFS', {
+  enumerable: true,
+  get: function () {
+    return getPortableFS;
+  }
+});
+Object.defineProperty(exports, 'getPortableHasher', {
+  enumerable: true,
+  get: function () {
+    return getPortableHasher;
+  }
+});
+Object.defineProperty(exports, 'resetPortableForTests', {
+  enumerable: true,
+  get: function () {
+    return resetPortableForTests;
+  }
+});
+Object.defineProperty(exports, 'runtime', {
+  enumerable: true,
+  get: function () {
+    return runtime;
+  }
+});
+//# sourceMappingURL=portable-B3K3IE7E.cjs.map

package/dist/portable-B3K3IE7E.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"portable-B3K3IE7E.cjs","names":["nodeFsPromises: FSPromises | null","nodeFsSync: FSSync | null","pathModule: { dirname: (path: string) => string } | null","pathModule","fsInstance: PortableFS | null","hasherInstance: PortableHasher | null"],"sources":["../src/portable/fs.ts","../src/portable/hash.ts","../src/portable/runtime.ts"],"sourcesContent":["/**\n * Portable filesystem API using Node.js fs\n */\n\nexport interface PortableFS {\n  readFile(path: string): Promise<string>;\n  writeFile(path: string, content: string): Promise<void>;\n  /**\n   * Write a file atomically using temp file + rename pattern.\n   * This prevents partial/corrupt writes on crash.\n   */\n  writeFileAtomic(path: string, content: string): Promise<void>;\n  exists(path: string): Promise<boolean>;\n  stat(path: string): Promise<{ mtime: Date; size: number }>;\n  rename(oldPath: string, newPath: string): Promise<void>;\n  mkdir(path: string, options?: { recursive?: boolean }): Promise<void>;\n  /**\n   * Write a file synchronously and atomically using temp file + rename pattern.\n   * Safe for use in beforeExit handlers.\n   */\n  writeFileSyncAtomic(path: string, content: string): void;\n  /**\n   * Remove a file. Does not throw if file doesn't exist.\n   */\n  unlink(path: string): Promise<void>;\n  /**\n   * Remove a file synchronously. Does not throw if file doesn't exist.\n   */\n  unlinkSync(path: string): void;\n  /**\n   * Read a file synchronously.\n   */\n  readFileSync(path: string): string;\n}\n\ninterface FSPromises {\n  readFile: (path: string, encoding: string) => Promise<string>;\n  writeFile: (path: string, content: string, encoding: string) => Promise<void>;\n  access: (path: string) => Promise<void>;\n  stat: (path: string) => Promise<{\n    mtime: Date;\n    size: number;\n    isDirectory: () => boolean;\n  }>;\n  rename: (oldPath: string, newPath: string) => Promise<void>;\n  mkdir: (path: string, options?: { recursive?: boolean }) => Promise<void>;\n  unlink: (path: string) => Promise<void>;\n}\n\ninterface FSSync {\n  writeFileSync: (path: string, content: string, encoding: string) => void;\n  renameSync: (oldPath: string, newPath: string) => void;\n  unlinkSync: (path: string) => void;\n  readFileSync: (path: string, encoding: string) => string;\n  mkdirSync: (path: string, options?: { recursive?: boolean }) => void;\n}\n\n// Cache the fs/promises import\nlet nodeFsPromises: FSPromises | null = null;\nconst getNodeFS = async (): Promise<FSPromises> => {\n  if (!nodeFsPromises) {\n    const fs = await import(\"node:fs/promises\");\n    nodeFsPromises = fs as FSPromises;\n  }\n  return nodeFsPromises;\n};\n\n// Cache the sync fs import\nlet nodeFsSync: FSSync | null = null;\nconst getNodeFSSync = (): FSSync => {\n  if (!nodeFsSync) {\n    // Use require for sync loading\n    // eslint-disable-next-line @typescript-eslint/no-require-imports\n    nodeFsSync = require(\"node:fs\") as FSSync;\n  }\n  return nodeFsSync;\n};\n\n// Cache path module\nlet pathModule: { dirname: (path: string) => string } | null = null;\nconst getPathModule = (): { dirname: (path: string) => string } => {\n  if (!pathModule) {\n    // eslint-disable-next-line @typescript-eslint/no-require-imports\n    pathModule = require(\"node:path\") as { dirname: (path: string) => string };\n  }\n  return pathModule;\n};\n\n/**\n * Generate a unique temp file path for atomic write.\n */\nconst getTempPath = (targetPath: string): string => {\n  return `${targetPath}.${process.pid}.${Date.now()}.tmp`;\n};\n\nexport function createPortableFS(): PortableFS {\n  return {\n    async readFile(path) {\n      const nodeFS = await getNodeFS();\n      return await nodeFS.readFile(path, \"utf-8\");\n    },\n\n    async writeFile(path, content) {\n      const nodeFS = await getNodeFS();\n      // Auto-create parent directories like Bun.write does\n      const pathModule = await import(\"node:path\");\n      const dir = pathModule.dirname(path);\n      await nodeFS.mkdir(dir, { recursive: true });\n      await nodeFS.writeFile(path, content, \"utf-8\");\n    },\n\n    async writeFileAtomic(path, content) {\n      const nodeFS = await getNodeFS();\n      const pathMod = await import(\"node:path\");\n      const dir = pathMod.dirname(path);\n      const tempPath = getTempPath(path);\n\n      try {\n        await nodeFS.mkdir(dir, { recursive: true });\n        await nodeFS.writeFile(tempPath, content, \"utf-8\");\n        await nodeFS.rename(tempPath, path);\n      } catch (error) {\n        // Clean up temp file on failure\n        try {\n          await nodeFS.unlink(tempPath);\n        } catch {\n          // Ignore cleanup errors\n        }\n        throw error;\n      }\n    },\n\n    async exists(path) {\n      const nodeFS = await getNodeFS();\n      try {\n        await nodeFS.access(path);\n        return true;\n      } catch {\n        return false;\n      }\n    },\n\n    async stat(path) {\n      const nodeFS = await getNodeFS();\n      const stats = await nodeFS.stat(path);\n      return { mtime: stats.mtime, size: stats.size };\n    },\n\n    async rename(oldPath, newPath) {\n      const nodeFS = await getNodeFS();\n      await nodeFS.rename(oldPath, newPath);\n    },\n\n    async mkdir(path, options) {\n      const nodeFS = await getNodeFS();\n      await nodeFS.mkdir(path, options);\n    },\n\n    writeFileSyncAtomic(path, content) {\n      const fsSync = getNodeFSSync();\n      const pathMod = getPathModule();\n      const tempPath = getTempPath(path);\n\n      // Ensure parent directory exists\n      const dir = pathMod.dirname(path);\n      fsSync.mkdirSync(dir, { recursive: true });\n\n      try {\n        fsSync.writeFileSync(tempPath, content, \"utf-8\");\n        fsSync.renameSync(tempPath, path);\n      } catch (error) {\n        // Clean up temp file on failure\n        try {\n          fsSync.unlinkSync(tempPath);\n        } catch {\n          // Ignore cleanup errors\n        }\n        throw error;\n      }\n    },\n\n    async unlink(path) {\n      const nodeFS = await getNodeFS();\n      try {\n        await nodeFS.unlink(path);\n      } catch (error) {\n        // Ignore ENOENT (file not found)\n        if ((error as NodeJS.ErrnoException).code !== \"ENOENT\") {\n          throw error;\n        }\n      }\n    },\n\n    unlinkSync(path) {\n      const fsSync = getNodeFSSync();\n      try {\n        fsSync.unlinkSync(path);\n      } catch (error) {\n        // Ignore ENOENT (file not found)\n        if ((error as NodeJS.ErrnoException).code !== \"ENOENT\") {\n          throw error;\n        }\n      }\n    },\n\n    readFileSync(path) {\n      const fsSync = getNodeFSSync();\n      return fsSync.readFileSync(path, \"utf-8\");\n    },\n  };\n}\n\n// Singleton to avoid recreating instances\nlet fsInstance: PortableFS | null = null;\n\nexport function getPortableFS(): PortableFS {\n  if (!fsInstance) {\n    fsInstance = createPortableFS();\n  }\n  return fsInstance;\n}\n\n/**\n * Reset the filesystem singleton for testing\n * @internal\n */\nexport function __resetPortableFSForTests(): void {\n  fsInstance = null;\n}\n","/**\n * Portable hashing API using Node.js crypto\n */\n\nimport { createHash } from \"node:crypto\";\n\nexport type HashAlgorithm = \"sha256\" | \"xxhash\";\n\nexport interface PortableHasher {\n  hash(content: string, algorithm?: HashAlgorithm): string;\n}\n\nexport function createPortableHasher(): PortableHasher {\n  return {\n    hash(content, algorithm = \"xxhash\") {\n      if (algorithm === \"sha256\") {\n        return createHash(\"sha256\").update(content).digest(\"hex\");\n      }\n      // xxhash fallback: use sha256 truncated to 16 chars\n      const sha256Hash = createHash(\"sha256\").update(content).digest(\"hex\");\n      return sha256Hash.substring(0, 16);\n    },\n  };\n}\n\n// Singleton to avoid recreating instances\nlet hasherInstance: PortableHasher | null = null;\n\nexport function getPortableHasher(): PortableHasher {\n  if (!hasherInstance) {\n    hasherInstance = createPortableHasher();\n  }\n  return hasherInstance;\n}\n\n/**\n * Reset the hasher singleton for testing\n * @internal\n */\nexport function __resetPortableHasherForTests(): void {\n  hasherInstance = null;\n}\n","/**\n * Runtime detection utilities for portable API implementation\n * Note: Bun-specific code has been removed. Node.js APIs are always used.\n */\n\nexport const runtime = {\n  isBun: false,\n  isNode: typeof process !== \"undefined\",\n  supportsWebCrypto: typeof crypto !== \"undefined\" && typeof crypto.subtle !== \"undefined\",\n} as const;\n\n/**\n * Reset runtime state for testing purposes only\n * @internal\n */\nexport function resetPortableForTests(): void {\n  // This is a marker function that portable modules can use\n  // to reset their singleton state in tests\n}\n"],"mappings":"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"}

package/dist/portable-BFrcBOaX.mjs

@@ -0,0 +1,196 @@
+import { createRequire } from "node:module";
+import { createHash } from "node:crypto";
+
+//#region rolldown:runtime
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+//#endregion
+//#region packages/common/src/portable/fs.ts
+let nodeFsPromises = null;
+const getNodeFS = async () => {
+	if (!nodeFsPromises) {
+		const fs = await import("node:fs/promises");
+		nodeFsPromises = fs;
+	}
+	return nodeFsPromises;
+};
+let nodeFsSync = null;
+const getNodeFSSync = () => {
+	if (!nodeFsSync) {
+		nodeFsSync = __require("node:fs");
+	}
+	return nodeFsSync;
+};
+let pathModule = null;
+const getPathModule = () => {
+	if (!pathModule) {
+		pathModule = __require("node:path");
+	}
+	return pathModule;
+};
+/**
+* Generate a unique temp file path for atomic write.
+*/
+const getTempPath = (targetPath) => {
+	return `${targetPath}.${process.pid}.${Date.now()}.tmp`;
+};
+function createPortableFS() {
+	return {
+		async readFile(path) {
+			const nodeFS = await getNodeFS();
+			return await nodeFS.readFile(path, "utf-8");
+		},
+		async writeFile(path, content) {
+			const nodeFS = await getNodeFS();
+			const pathModule$1 = await import("node:path");
+			const dir = pathModule$1.dirname(path);
+			await nodeFS.mkdir(dir, { recursive: true });
+			await nodeFS.writeFile(path, content, "utf-8");
+		},
+		async writeFileAtomic(path, content) {
+			const nodeFS = await getNodeFS();
+			const pathMod = await import("node:path");
+			const dir = pathMod.dirname(path);
+			const tempPath = getTempPath(path);
+			try {
+				await nodeFS.mkdir(dir, { recursive: true });
+				await nodeFS.writeFile(tempPath, content, "utf-8");
+				await nodeFS.rename(tempPath, path);
+			} catch (error) {
+				try {
+					await nodeFS.unlink(tempPath);
+				} catch {}
+				throw error;
+			}
+		},
+		async exists(path) {
+			const nodeFS = await getNodeFS();
+			try {
+				await nodeFS.access(path);
+				return true;
+			} catch {
+				return false;
+			}
+		},
+		async stat(path) {
+			const nodeFS = await getNodeFS();
+			const stats = await nodeFS.stat(path);
+			return {
+				mtime: stats.mtime,
+				size: stats.size
+			};
+		},
+		async rename(oldPath, newPath) {
+			const nodeFS = await getNodeFS();
+			await nodeFS.rename(oldPath, newPath);
+		},
+		async mkdir(path, options) {
+			const nodeFS = await getNodeFS();
+			await nodeFS.mkdir(path, options);
+		},
+		writeFileSyncAtomic(path, content) {
+			const fsSync = getNodeFSSync();
+			const pathMod = getPathModule();
+			const tempPath = getTempPath(path);
+			const dir = pathMod.dirname(path);
+			fsSync.mkdirSync(dir, { recursive: true });
+			try {
+				fsSync.writeFileSync(tempPath, content, "utf-8");
+				fsSync.renameSync(tempPath, path);
+			} catch (error) {
+				try {
+					fsSync.unlinkSync(tempPath);
+				} catch {}
+				throw error;
+			}
+		},
+		async unlink(path) {
+			const nodeFS = await getNodeFS();
+			try {
+				await nodeFS.unlink(path);
+			} catch (error) {
+				if (error.code !== "ENOENT") {
+					throw error;
+				}
+			}
+		},
+		unlinkSync(path) {
+			const fsSync = getNodeFSSync();
+			try {
+				fsSync.unlinkSync(path);
+			} catch (error) {
+				if (error.code !== "ENOENT") {
+					throw error;
+				}
+			}
+		},
+		readFileSync(path) {
+			const fsSync = getNodeFSSync();
+			return fsSync.readFileSync(path, "utf-8");
+		}
+	};
+}
+let fsInstance = null;
+function getPortableFS() {
+	if (!fsInstance) {
+		fsInstance = createPortableFS();
+	}
+	return fsInstance;
+}
+/**
+* Reset the filesystem singleton for testing
+* @internal
+*/
+function __resetPortableFSForTests() {
+	fsInstance = null;
+}
+
+//#endregion
+//#region packages/common/src/portable/hash.ts
+/**
+* Portable hashing API using Node.js crypto
+*/
+function createPortableHasher() {
+	return { hash(content, algorithm = "xxhash") {
+		if (algorithm === "sha256") {
+			return createHash("sha256").update(content).digest("hex");
+		}
+		const sha256Hash = createHash("sha256").update(content).digest("hex");
+		return sha256Hash.substring(0, 16);
+	} };
+}
+let hasherInstance = null;
+function getPortableHasher() {
+	if (!hasherInstance) {
+		hasherInstance = createPortableHasher();
+	}
+	return hasherInstance;
+}
+/**
+* Reset the hasher singleton for testing
+* @internal
+*/
+function __resetPortableHasherForTests() {
+	hasherInstance = null;
+}
+
+//#endregion
+//#region packages/common/src/portable/runtime.ts
+/**
+* Runtime detection utilities for portable API implementation
+* Note: Bun-specific code has been removed. Node.js APIs are always used.
+*/
+const runtime = {
+	isBun: false,
+	isNode: typeof process !== "undefined",
+	supportsWebCrypto: typeof crypto !== "undefined" && typeof crypto.subtle !== "undefined"
+};
+/**
+* Reset runtime state for testing purposes only
+* @internal
+*/
+function resetPortableForTests() {}
+
+//#endregion
+export { getPortableHasher as a, getPortableFS as c, createPortableHasher as i, runtime as n, __resetPortableFSForTests as o, __resetPortableHasherForTests as r, createPortableFS as s, resetPortableForTests as t };
+//# sourceMappingURL=portable-BFrcBOaX.mjs.map

package/dist/portable-BFrcBOaX.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"portable-BFrcBOaX.mjs","names":["nodeFsPromises: FSPromises | null","nodeFsSync: FSSync | null","pathModule: { dirname: (path: string) => string } | null","pathModule","fsInstance: PortableFS | null","hasherInstance: PortableHasher | null"],"sources":["../src/portable/fs.ts","../src/portable/hash.ts","../src/portable/runtime.ts"],"sourcesContent":["/**\n * Portable filesystem API using Node.js fs\n */\n\nexport interface PortableFS {\n  readFile(path: string): Promise<string>;\n  writeFile(path: string, content: string): Promise<void>;\n  /**\n   * Write a file atomically using temp file + rename pattern.\n   * This prevents partial/corrupt writes on crash.\n   */\n  writeFileAtomic(path: string, content: string): Promise<void>;\n  exists(path: string): Promise<boolean>;\n  stat(path: string): Promise<{ mtime: Date; size: number }>;\n  rename(oldPath: string, newPath: string): Promise<void>;\n  mkdir(path: string, options?: { recursive?: boolean }): Promise<void>;\n  /**\n   * Write a file synchronously and atomically using temp file + rename pattern.\n   * Safe for use in beforeExit handlers.\n   */\n  writeFileSyncAtomic(path: string, content: string): void;\n  /**\n   * Remove a file. Does not throw if file doesn't exist.\n   */\n  unlink(path: string): Promise<void>;\n  /**\n   * Remove a file synchronously. Does not throw if file doesn't exist.\n   */\n  unlinkSync(path: string): void;\n  /**\n   * Read a file synchronously.\n   */\n  readFileSync(path: string): string;\n}\n\ninterface FSPromises {\n  readFile: (path: string, encoding: string) => Promise<string>;\n  writeFile: (path: string, content: string, encoding: string) => Promise<void>;\n  access: (path: string) => Promise<void>;\n  stat: (path: string) => Promise<{\n    mtime: Date;\n    size: number;\n    isDirectory: () => boolean;\n  }>;\n  rename: (oldPath: string, newPath: string) => Promise<void>;\n  mkdir: (path: string, options?: { recursive?: boolean }) => Promise<void>;\n  unlink: (path: string) => Promise<void>;\n}\n\ninterface FSSync {\n  writeFileSync: (path: string, content: string, encoding: string) => void;\n  renameSync: (oldPath: string, newPath: string) => void;\n  unlinkSync: (path: string) => void;\n  readFileSync: (path: string, encoding: string) => string;\n  mkdirSync: (path: string, options?: { recursive?: boolean }) => void;\n}\n\n// Cache the fs/promises import\nlet nodeFsPromises: FSPromises | null = null;\nconst getNodeFS = async (): Promise<FSPromises> => {\n  if (!nodeFsPromises) {\n    const fs = await import(\"node:fs/promises\");\n    nodeFsPromises = fs as FSPromises;\n  }\n  return nodeFsPromises;\n};\n\n// Cache the sync fs import\nlet nodeFsSync: FSSync | null = null;\nconst getNodeFSSync = (): FSSync => {\n  if (!nodeFsSync) {\n    // Use require for sync loading\n    // eslint-disable-next-line @typescript-eslint/no-require-imports\n    nodeFsSync = require(\"node:fs\") as FSSync;\n  }\n  return nodeFsSync;\n};\n\n// Cache path module\nlet pathModule: { dirname: (path: string) => string } | null = null;\nconst getPathModule = (): { dirname: (path: string) => string } => {\n  if (!pathModule) {\n    // eslint-disable-next-line @typescript-eslint/no-require-imports\n    pathModule = require(\"node:path\") as { dirname: (path: string) => string };\n  }\n  return pathModule;\n};\n\n/**\n * Generate a unique temp file path for atomic write.\n */\nconst getTempPath = (targetPath: string): string => {\n  return `${targetPath}.${process.pid}.${Date.now()}.tmp`;\n};\n\nexport function createPortableFS(): PortableFS {\n  return {\n    async readFile(path) {\n      const nodeFS = await getNodeFS();\n      return await nodeFS.readFile(path, \"utf-8\");\n    },\n\n    async writeFile(path, content) {\n      const nodeFS = await getNodeFS();\n      // Auto-create parent directories like Bun.write does\n      const pathModule = await import(\"node:path\");\n      const dir = pathModule.dirname(path);\n      await nodeFS.mkdir(dir, { recursive: true });\n      await nodeFS.writeFile(path, content, \"utf-8\");\n    },\n\n    async writeFileAtomic(path, content) {\n      const nodeFS = await getNodeFS();\n      const pathMod = await import(\"node:path\");\n      const dir = pathMod.dirname(path);\n      const tempPath = getTempPath(path);\n\n      try {\n        await nodeFS.mkdir(dir, { recursive: true });\n        await nodeFS.writeFile(tempPath, content, \"utf-8\");\n        await nodeFS.rename(tempPath, path);\n      } catch (error) {\n        // Clean up temp file on failure\n        try {\n          await nodeFS.unlink(tempPath);\n        } catch {\n          // Ignore cleanup errors\n        }\n        throw error;\n      }\n    },\n\n    async exists(path) {\n      const nodeFS = await getNodeFS();\n      try {\n        await nodeFS.access(path);\n        return true;\n      } catch {\n        return false;\n      }\n    },\n\n    async stat(path) {\n      const nodeFS = await getNodeFS();\n      const stats = await nodeFS.stat(path);\n      return { mtime: stats.mtime, size: stats.size };\n    },\n\n    async rename(oldPath, newPath) {\n      const nodeFS = await getNodeFS();\n      await nodeFS.rename(oldPath, newPath);\n    },\n\n    async mkdir(path, options) {\n      const nodeFS = await getNodeFS();\n      await nodeFS.mkdir(path, options);\n    },\n\n    writeFileSyncAtomic(path, content) {\n      const fsSync = getNodeFSSync();\n      const pathMod = getPathModule();\n      const tempPath = getTempPath(path);\n\n      // Ensure parent directory exists\n      const dir = pathMod.dirname(path);\n      fsSync.mkdirSync(dir, { recursive: true });\n\n      try {\n        fsSync.writeFileSync(tempPath, content, \"utf-8\");\n        fsSync.renameSync(tempPath, path);\n      } catch (error) {\n        // Clean up temp file on failure\n        try {\n          fsSync.unlinkSync(tempPath);\n        } catch {\n          // Ignore cleanup errors\n        }\n        throw error;\n      }\n    },\n\n    async unlink(path) {\n      const nodeFS = await getNodeFS();\n      try {\n        await nodeFS.unlink(path);\n      } catch (error) {\n        // Ignore ENOENT (file not found)\n        if ((error as NodeJS.ErrnoException).code !== \"ENOENT\") {\n          throw error;\n        }\n      }\n    },\n\n    unlinkSync(path) {\n      const fsSync = getNodeFSSync();\n      try {\n        fsSync.unlinkSync(path);\n      } catch (error) {\n        // Ignore ENOENT (file not found)\n        if ((error as NodeJS.ErrnoException).code !== \"ENOENT\") {\n          throw error;\n        }\n      }\n    },\n\n    readFileSync(path) {\n      const fsSync = getNodeFSSync();\n      return fsSync.readFileSync(path, \"utf-8\");\n    },\n  };\n}\n\n// Singleton to avoid recreating instances\nlet fsInstance: PortableFS | null = null;\n\nexport function getPortableFS(): PortableFS {\n  if (!fsInstance) {\n    fsInstance = createPortableFS();\n  }\n  return fsInstance;\n}\n\n/**\n * Reset the filesystem singleton for testing\n * @internal\n */\nexport function __resetPortableFSForTests(): void {\n  fsInstance = null;\n}\n","/**\n * Portable hashing API using Node.js crypto\n */\n\nimport { createHash } from \"node:crypto\";\n\nexport type HashAlgorithm = \"sha256\" | \"xxhash\";\n\nexport interface PortableHasher {\n  hash(content: string, algorithm?: HashAlgorithm): string;\n}\n\nexport function createPortableHasher(): PortableHasher {\n  return {\n    hash(content, algorithm = \"xxhash\") {\n      if (algorithm === \"sha256\") {\n        return createHash(\"sha256\").update(content).digest(\"hex\");\n      }\n      // xxhash fallback: use sha256 truncated to 16 chars\n      const sha256Hash = createHash(\"sha256\").update(content).digest(\"hex\");\n      return sha256Hash.substring(0, 16);\n    },\n  };\n}\n\n// Singleton to avoid recreating instances\nlet hasherInstance: PortableHasher | null = null;\n\nexport function getPortableHasher(): PortableHasher {\n  if (!hasherInstance) {\n    hasherInstance = createPortableHasher();\n  }\n  return hasherInstance;\n}\n\n/**\n * Reset the hasher singleton for testing\n * @internal\n */\nexport function __resetPortableHasherForTests(): void {\n  hasherInstance = null;\n}\n","/**\n * Runtime detection utilities for portable API implementation\n * Note: Bun-specific code has been removed. Node.js APIs are always used.\n */\n\nexport const runtime = {\n  isBun: false,\n  isNode: typeof process !== \"undefined\",\n  supportsWebCrypto: typeof crypto !== \"undefined\" && typeof crypto.subtle !== \"undefined\",\n} as const;\n\n/**\n * Reset runtime state for testing purposes only\n * @internal\n */\nexport function resetPortableForTests(): void {\n  // This is a marker function that portable modules can use\n  // to reset their singleton state in tests\n}\n"],"mappings":"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"}

package/dist/portable.cjs

@@ -1,13 +1,10 @@
-const require_portable = require('./portable-cJqkfeHw.cjs');
+const require_portable = require('./portable-B3K3IE7E.cjs');
 
 exports.__resetPortableFSForTests = require_portable.__resetPortableFSForTests;
 exports.__resetPortableHasherForTests = require_portable.__resetPortableHasherForTests;
 exports.createPortableFS = require_portable.createPortableFS;
 exports.createPortableHasher = require_portable.createPortableHasher;
-exports.generateId = require_portable.generateId;
 exports.getPortableFS = require_portable.getPortableFS;
 exports.getPortableHasher = require_portable.getPortableHasher;
-exports.once = require_portable.once;
 exports.resetPortableForTests = require_portable.resetPortableForTests;
-exports.runtime = require_portable.runtime;
-exports.spawn = require_portable.spawn;
+exports.runtime = require_portable.runtime;

package/dist/portable.d.cts

@@ -1,2 +1,2 @@
-import { a as resetPortableForTests, c as HashAlgorithm, d as createPortableHasher, f as getPortableHasher, g as getPortableFS, h as createPortableFS, i as once, l as PortableHasher, m as __resetPortableFSForTests, n as SpawnResult, o as runtime, p as PortableFS, r as spawn, s as generateId, t as SpawnOptions, u as __resetPortableHasherForTests } from "./index-D1tzB3W5.cjs";
-export { HashAlgorithm, PortableFS, PortableHasher, SpawnOptions, SpawnResult, __resetPortableFSForTests, __resetPortableHasherForTests, createPortableFS, createPortableHasher, generateId, getPortableFS, getPortableHasher, once, resetPortableForTests, runtime, spawn };
+import { a as __resetPortableHasherForTests, c as PortableFS, d as getPortableFS, i as PortableHasher, l as __resetPortableFSForTests, n as runtime, o as createPortableHasher, r as HashAlgorithm, s as getPortableHasher, t as resetPortableForTests, u as createPortableFS } from "./index-CbQyueYV.cjs";
+export { HashAlgorithm, PortableFS, PortableHasher, __resetPortableFSForTests, __resetPortableHasherForTests, createPortableFS, createPortableHasher, getPortableFS, getPortableHasher, resetPortableForTests, runtime };

package/dist/portable.d.mts

@@ -1,2 +1,2 @@
-import { a as resetPortableForTests, c as HashAlgorithm, d as createPortableHasher, f as getPortableHasher, g as getPortableFS, h as createPortableFS, i as once, l as PortableHasher, m as __resetPortableFSForTests, n as SpawnResult, o as runtime, p as PortableFS, r as spawn, s as generateId, t as SpawnOptions, u as __resetPortableHasherForTests } from "./index-B424kKYS.mjs";
-export { HashAlgorithm, PortableFS, PortableHasher, SpawnOptions, SpawnResult, __resetPortableFSForTests, __resetPortableHasherForTests, createPortableFS, createPortableHasher, generateId, getPortableFS, getPortableHasher, once, resetPortableForTests, runtime, spawn };
+import { a as __resetPortableHasherForTests, c as PortableFS, d as getPortableFS, i as PortableHasher, l as __resetPortableFSForTests, n as runtime, o as createPortableHasher, r as HashAlgorithm, s as getPortableHasher, t as resetPortableForTests, u as createPortableFS } from "./index-BMa2_rDb.mjs";
+export { HashAlgorithm, PortableFS, PortableHasher, __resetPortableFSForTests, __resetPortableHasherForTests, createPortableFS, createPortableHasher, getPortableFS, getPortableHasher, resetPortableForTests, runtime };

package/dist/portable.mjs

@@ -1,3 +1,3 @@
-import { a as getPortableHasher, c as getPortableFS, d as runtime, i as createPortableHasher, l as once, n as generateId, o as __resetPortableFSForTests, r as __resetPortableHasherForTests, s as createPortableFS, t as spawn, u as resetPortableForTests } from "./portable-BT3ahkQN.mjs";
+import { a as getPortableHasher, c as getPortableFS, i as createPortableHasher, n as runtime, o as __resetPortableFSForTests, r as __resetPortableHasherForTests, s as createPortableFS, t as resetPortableForTests } from "./portable-BFrcBOaX.mjs";
 
-export { __resetPortableFSForTests, __resetPortableHasherForTests, createPortableFS, createPortableHasher, generateId, getPortableFS, getPortableHasher, once, resetPortableForTests, runtime, spawn };
+export { __resetPortableFSForTests, __resetPortableHasherForTests, createPortableFS, createPortableHasher, getPortableFS, getPortableHasher, resetPortableForTests, runtime };