@poe-platform/safe-bash 0.1.546 → 0.1.548

package/dist/safe-bash/core.browser.js

@@ -2,48 +2,49 @@ import {
   createTsortCommand,
   createTsortCommands,
   tsortCommands
-} from "./chunks/chunk-YFFFBLBC.js";
+} from "./chunks/chunk-TJVKGNKA.js";
 import {
   createFactorCommand,
   createFactorCommands,
   factorCommands
-} from "./chunks/chunk-4V3NGZAG.js";
+} from "./chunks/chunk-IYFB6VED.js";
 import {
   createGetoptCommand,
   createGetoptCommands,
   getoptCommands
-} from "./chunks/chunk-DKT746UJ.js";
+} from "./chunks/chunk-PE5NZIA2.js";
 import {
   createHdCommand,
   createHexdumpCommand,
   createHexdumpCommands,
   hexdumpCommands
-} from "./chunks/chunk-IDJQT32M.js";
+} from "./chunks/chunk-HQCBEAFK.js";
 import {
   createIconvCommand,
   createIconvCommands,
   iconvCommands
-} from "./chunks/chunk-WJWYJDQE.js";
+} from "./chunks/chunk-XYVCXUGM.js";
 import {
   createDos2unixCommand,
   createLineEndingCommands,
   createUnix2dosCommand,
   lineEndingCommands
-} from "./chunks/chunk-AWP6Z3RR.js";
+} from "./chunks/chunk-E3NZKSTA.js";
 import {
-  classify,
   createLlmCommands,
   llmCommands
-} from "./chunks/chunk-F5AOPLRZ.js";
+} from "./chunks/chunk-KJYVSFGF.js";
+import "./chunks/chunk-C7QNJ3D4.js";
 import {
+  classify,
   createElevenLabsProvider,
   createOpenAiProvider
-} from "./chunks/chunk-BZUQJTOZ.js";
+} from "./chunks/chunk-LR32SJ3D.js";
 import {
   createXmlCommands,
   defaultXmlQueryLimits,
   xmlCommands
-} from "./chunks/chunk-WISNTI7E.js";
+} from "./chunks/chunk-3Y5PKSHX.js";
 import {
   Interpreter,
   createYqCommand,
@@ -54,7 +55,7 @@ import {
   rawValues,
   stringify,
   yqCommands
-} from "./chunks/chunk-FIY2BMTU.js";
+} from "./chunks/chunk-W3TLNFDB.js";
 import {
   Budget,
   JqError,
@@ -67,8 +68,10 @@ import {
   resolveJqLimits,
   truth,
   wellFormed
-} from "./chunks/chunk-PPFWG34Y.js";
+} from "./chunks/chunk-XBLVOMEJ.js";
 import {
+  CurlError,
+  cloudflareWorkerNetworkLimits,
   createCurlCommand,
   createCurlCommands,
   createFetchTransport,
@@ -76,13 +79,9 @@ import {
   createOriginAuthorizer,
   createWgetCommand,
   curlCommands,
+  defaultNetworkLimits,
   networkCommands
-} from "./chunks/chunk-VY5N6O6I.js";
-import {
-  CurlError,
-  cloudflareWorkerNetworkLimits,
-  defaultNetworkLimits
-} from "./chunks/chunk-EUTSYRNM.js";
+} from "./chunks/chunk-BXVGCJXW.js";
 import {
   RecordBuffer,
   UsageError,
@@ -98,6 +97,7 @@ import {
   emptyInput,
   encoder,
   escapeBytes,
+  escapeText,
   evaluateCommandSupport,
   input,
   inputRequirements,
@@ -111,12 +111,9 @@ import {
   replaceArgument,
   requireOperands,
   textOutputRequirements,
-  value
-} from "./chunks/chunk-O7BRWSKX.js";
-import {
-  escapeText,
+  value,
   writeDiagnostic
-} from "./chunks/chunk-KYU6MXVK.js";
+} from "./chunks/chunk-LHKAA57T.js";
 import {
   AvailableRecords,
   EreLedger,
@@ -136,24 +133,20 @@ import {
   exprMatchCeilings,
   matchEre,
   withRegexSession
-} from "./chunks/chunk-X7C3PN2T.js";
+} from "./chunks/chunk-PMBBUNNN.js";
 import {
   bindFileOutputBudget,
   openFileOutput,
   writeFileOutput
-} from "./chunks/chunk-WXUZXY35.js";
+} from "./chunks/chunk-FMTBJ7SG.js";
 import {
   createPrCommand,
   createPrCommands,
   prCommands
-} from "./chunks/chunk-QX2X5EC5.js";
+} from "./chunks/chunk-H6E6F5KJ.js";
 import {
   createOutputOperation
-} from "./chunks/chunk-EUNOVYVT.js";
-import {
-  PublicDiagnostic,
-  publicDiagnosticMessage
-} from "./chunks/chunk-TTTOMUAY.js";
+} from "./chunks/chunk-OECKXHVJ.js";
 import {
   basename,
   dirname,
@@ -167,37 +160,37 @@ import {
 import {
   CommandArgumentIdentityError,
   CommandRegistry,
-  concatShellValues,
-  createCommandArguments,
-  getCommandArguments,
-  shellValueByteLength,
-  shellValueBytes,
-  shellValueFromBytes,
-  shellValueRetainedBytes,
-  shellValueText,
-  validateExitCode
-} from "./chunks/chunk-UO33SQJU.js";
-import {
   FsError,
+  PublicDiagnostic,
   cancelTurn,
   collectBytes,
   collectText,
+  concatShellValues,
   createBytePipe,
+  createCommandArguments,
+  getCommandArguments,
   inheritYieldCheckpoint,
   isErrnoCode,
   isFsError,
   monotonicNow,
   outputFailure,
   pipeBytes,
+  publicDiagnosticMessage,
   readBytes,
   registerYieldCheckpoint,
   scheduleTurn,
+  shellValueByteLength,
+  shellValueBytes,
+  shellValueFromBytes,
+  shellValueRetainedBytes,
+  shellValueText,
   toByteSource,
   toFsError,
+  validateExitCode,
   writeBytes,
   writeText,
   yieldTurn
-} from "./chunks/chunk-FDGESHPB.js";
+} from "./chunks/chunk-2PQ3XOCQ.js";
 import {
   import_buffer,
   init_platform
@@ -27147,47 +27140,29 @@ var ZipScope = class {
 };
 async function publishZip(scope, prepared) {
   const { fs, signal } = scope.context;
-  const capabilities = await scope.operation(() => fs.capabilitiesFor?.(prepared.output, { signal }) ?? fs.capabilities);
-  if (capabilities.atomicRename !== true || capabilities.exclusiveCreate !== true || capabilities.explicitDirectories !== true || capabilities.permissions !== true || !fs.rmdir || (prepared.existing ? !fs.chmod : capabilities.atomicRenameNoReplace !== true)) fail("ZIP publication requires atomic rename, exclusive creation, private directories and mode preservation");
-  let directory2;
-  let temporary = "";
-  let identity2;
-  let published = false;
-  let collision = false;
+  const capabilities = await scope.operation(() => fs.capabilitiesFor?.(prepared.output, { signal, create: true }) ?? fs.capabilities);
+  if (capabilities.atomicFileStaging !== true || !fs.createStagedFile || !fs.publishStagedFile || !fs.removeStagedFile) fail("ZIP publication requires atomic owned file staging");
+  let staging;
   let failure;
-  const checkOwner = async () => {
-    const parent = await scope.operation(() => fs.realpath(prepared.parentName, { signal }));
-    const owner = directory2 && await scope.stat(directory2.path);
-    if (parent !== prepared.parent || !owner || owner.type !== "directory" || !sameIdentity2(owner, directory2.stat)) fail("ZIP temporary ownership changed before mutation");
-  };
   const close = retainFileSystemCleanup2(fs, async (cleanup) => {
-    if (!directory2 || !hasIdentity(directory2.stat)) return;
-    const parent = await cleanup.realpath(prepared.parentName);
-    const owner = await cleanup.lstat(directory2.path);
-    if (parent !== prepared.parent || owner.type !== "directory" || !sameIdentity2(owner, directory2.stat)) fail("ZIP temporary ownership changed before cleanup");
-    if (temporary && !published && !collision) {
-      let current;
-      try {
-        current = await cleanup.lstat(temporary);
-      } catch (error) {
-        if (typeof error !== "object" || error === null || !("code" in error) || error.code !== "ENOENT") throw error;
-      }
-      if (current) {
-        if (!identity2 || !sameIdentity2(current, identity2) || current.type !== "file" || current.nlink !== 1) fail("ZIP temporary file changed before cleanup");
-        await cleanup.rm(temporary);
-      }
+    if (staging) {
+      if (!cleanup.removeStagedFile) fail("ZIP atomic cleanup unavailable");
+      await cleanup.removeStagedFile(staging);
     }
-    await cleanup.rmdir(directory2.path);
   }, { maxOperations: 16 });
   try {
     for (let attempt = 0; attempt < Math.min(64, scope.limits.maxMembers); attempt++) {
       const path = `${prepared.parent === "/" ? "" : prepared.parent}/.zip-${attempt + 1}`;
       checkPath(path, scope.limits);
+      checkPath(`${path}/archive.zip`, scope.limits);
       if (path === prepared.output) continue;
       try {
         await scope.operation(async () => {
-          await fs.mkdir(path, { signal, mode: 448 });
-          directory2 = { path, stat: await fs.lstat(path) };
+          staging = await fs.createStagedFile(path, "archive.zip", { type: "file", data: prepared.bytes }, {
+            signal,
+            parent: prepared.parentStat,
+            ...prepared.existing ? { mode: prepared.existing.mode & 4095 } : {}
+          });
         });
         break;
       } catch (error) {
@@ -27195,44 +27170,14 @@ async function publishZip(scope, prepared) {
         if (typeof error !== "object" || error === null || !("code" in error) || error.code !== "EEXIST") throw error;
       }
     }
-    if (!directory2) fail("ZIP temporary directory attempt limit exceeded");
-    if (directory2.stat.type !== "directory" || !hasIdentity(directory2.stat) || (directory2.stat.mode & 511) !== 448) fail("ZIP temporary directory ownership unavailable");
-    temporary = `${directory2.path}/archive.zip`;
-    checkPath(temporary, scope.limits);
-    await checkOwner();
-    await scope.operation(async () => {
-      let writeFailure;
-      try {
-        await fs.writeFile(temporary, prepared.bytes, { signal, flag: "wx", ...prepared.existing ? { mode: prepared.existing.mode & 4095 } : {} });
-      } catch (error) {
-        collision = typeof error === "object" && error !== null && "code" in error && error.code === "EEXIST";
-        writeFailure = { reason: error };
-      }
-      if (!collision) {
-        await checkOwner();
-        try {
-          identity2 = await fs.lstat(temporary);
-        } catch (error) {
-          if (typeof error !== "object" || error === null || !("code" in error) || error.code !== "ENOENT") throw error;
-        }
-      }
-      if (writeFailure) throw writeFailure.reason;
-    });
-    if (!identity2 || !hasIdentity(identity2) || identity2.type !== "file" || identity2.nlink !== 1 || identity2.size !== prepared.bytes.length) fail("ZIP staged archive identity or size changed");
-    if (prepared.existing) {
-      await checkOwner();
-      await scope.operation(() => fs.chmod(temporary, prepared.existing.mode & 4095, { signal }));
-    }
+    if (!staging) fail("ZIP temporary directory attempt limit exceeded");
     const parent = await scope.operation(() => fs.realpath(prepared.parentName, { signal }));
-    const current = await scope.stat(prepared.output);
-    if (parent !== prepared.parent || (prepared.existing ? !current || !sameIdentity2(prepared.existing, current) || current.type !== "file" || current.nlink !== 1 || current.size !== prepared.existing.size || current.mode !== prepared.existing.mode || current.mtimeMs !== prepared.existing.mtimeMs || current.ctimeMs !== prepared.existing.ctimeMs : current !== void 0)) fail("archive backing entry changed before publication");
-    const staging = await scope.stat(temporary);
-    const owner = await scope.stat(directory2.path);
-    if (!staging || !sameIdentity2(staging, identity2) || staging.type !== "file" || staging.nlink !== 1 || staging.size !== prepared.bytes.length || !owner || !sameIdentity2(owner, directory2.stat) || owner.type !== "directory") fail("ZIP temporary ownership changed before publication");
-    await scope.operation(async () => {
-      await fs.rename(temporary, prepared.output, { signal, ...!prepared.existing ? { noReplace: true } : {} });
-      published = true;
-    });
+    if (parent !== prepared.parent) fail("archive parent changed before publication");
+    await scope.operation(() => fs.publishStagedFile(staging, prepared.output, {
+      signal,
+      parent: prepared.parentStat,
+      destination: prepared.existing ?? null
+    }));
   } catch (error) {
     failure = { reason: error };
   }
@@ -27318,6 +27263,7 @@ async function prepare(scope, parsed, budget) {
   const outputName = vfsPath(context2.cwd, parsed.archive);
   const parentName = dirname(outputName);
   const parent = await scope.operation(() => context2.fs.realpath(parentName, { signal: context2.signal }));
+  const parentStat = await scope.operation(() => context2.fs.lstat(parent, { signal: context2.signal }));
   const output2 = `${parent === "/" ? "" : parent}/${outputName.slice(outputName.lastIndexOf("/") + 1)}`;
   checkPath(output2, limits);
   const existing2 = await scope.stat(output2);
@@ -27443,7 +27389,7 @@ async function prepare(scope, parsed, budget) {
     append(entry, false);
   }
   const bytes3 = await writeZipArchive({ entries: entries2, comment: archive.comment }, limits, context2.signal);
-  return { output: output2, parentName, parent, existing: existing2, bytes: bytes3, progress };
+  return { output: output2, parentName, parent, parentStat, existing: existing2, bytes: bytes3, progress };
 }
 function createZipCommand(options2 = {}) {
   const limits = settings2(options2);
@@ -27758,13 +27704,25 @@ var Extraction = class {
     const { fs, signal } = this.context;
     for (const component of raw.split("/")) {
       if (!component || component === ".") continue;
+      const parent = await this.operation(() => fs.lstat(current, { signal }));
       current = resolvePath(current, component);
       const stat = await this.stat(current);
-      if (!stat && create) await this.operation(() => fs.mkdir(current, { signal, mode: 493 }));
+      if (!stat && create) await this.createDirectory(current, parent);
       else if (!stat || stat.type !== "directory") fail(`unsafe non-directory or symlink ancestor: ${display(current)}`);
     }
     return current;
   }
+  async createDirectory(path, parent) {
+    const { fs, signal } = this.context;
+    const capabilities = await this.operation(async () => await fs.capabilitiesFor?.(path, { signal, create: true }) ?? fs.capabilities);
+    if (capabilities.atomicDirectoryMetadata !== true || !fs.prepareDirectory) fail("extraction requires atomic directory creation");
+    return this.operation(() => fs.prepareDirectory(path, {
+      signal,
+      parent,
+      expected: null,
+      ...capabilities.permissions === false ? {} : { mode: 493 }
+    }));
+  }
   async parents(root, path, create) {
     if (!isPathWithin(root, path)) fail("extraction path escapes root");
     await this.directory(dirname(path), create);
@@ -27828,74 +27786,65 @@ var Extraction = class {
     const current = await this.stat(path);
     if (!current || current.type !== expected.type || !sameIdentity2(current, expected)) fail("extraction entry changed before mutation");
   }
-  async metadata(root, path, identity2, mode, modified) {
+  async metadata(root, path, identity2, parent, mode, modified) {
     const { fs, signal } = this.context;
-    if (fs.chmod && fs.capabilities.permissions !== false) {
-      await this.checked(root, path, identity2);
-      await this.operation(() => fs.chmod(path, mode & 511, { signal }));
-    }
-    if (fs.utimes && fs.capabilities.timestamps !== false) {
-      await this.checked(root, path, identity2);
-      await this.operation(() => fs.utimes(path, modified.getTime(), modified.getTime(), { signal }));
-    }
+    await this.parents(root, path, false);
+    const capabilities = await this.operation(async () => await fs.capabilitiesFor?.(path, { signal }) ?? fs.capabilities);
+    if (capabilities.permissions === false && capabilities.timestamps === false) return;
+    if (capabilities.atomicDirectoryMetadata !== true || !fs.prepareDirectory) fail("extraction metadata requires atomic entry conditions");
+    await this.operation(() => fs.prepareDirectory(path, {
+      signal,
+      expected: identity2,
+      parent,
+      ...capabilities.permissions === false ? {} : { mode: mode & 511 },
+      ...capabilities.timestamps === false ? {} : { atimeMs: modified.getTime(), mtimeMs: modified.getTime() }
+    }));
   }
-  publish(root, path, chunks, expected, mode, modified, target) {
-    const publication = this.stage(root, path, chunks, expected, mode, modified, target);
+  publish(root, path, chunks, expected, parent, mode, modified, target) {
+    const publication = this.stage(root, path, chunks, expected, parent, mode, modified, target);
     this.publications.add(publication);
     return publication.finally(() => {
       this.publications.delete(publication);
     });
   }
-  async stage(root, path, chunks, expected, mode, modified, target) {
+  async stage(root, path, chunks, expected, parent, mode, modified, target) {
     const { fs, signal } = this.context;
-    let temporary = "";
-    let identity2;
-    let created = false;
+    const capabilities = await this.operation(async () => await fs.capabilitiesFor?.(path, { signal, create: true }) ?? fs.capabilities);
+    if (capabilities.atomicFileStaging !== true || !fs.createStagedFile || !fs.publishStagedFile || !fs.removeStagedFile) fail("extraction requires atomic owned file staging");
+    let staging;
     let failure;
     const cleanup = retainFileSystemCleanup3(fs, async (view) => {
-      if (!created || !identity2) return;
-      try {
-        let parent = "/";
-        for (const component of dirname(temporary).split("/").filter(Boolean)) {
-          parent = resolvePath(parent, component);
-          if ((await view.lstat(parent)).type !== "directory") return;
-        }
-        const current = await view.lstat(temporary);
-        if (current.type === identity2.type && sameIdentity2(current, identity2)) await view.rm(temporary);
-      } catch (error) {
-        if (typeof error !== "object" || error === null || !("code" in error) || error.code !== "ENOENT") throw error;
+      if (staging) {
+        if (!view.removeStagedFile) fail("extraction atomic cleanup unavailable");
+        await view.removeStagedFile(staging);
       }
     }, { maxOperations: Math.min(4096, this.limits.maxDepth + 3) });
     try {
-      await this.parents(root, path, true);
+      await this.parents(root, path, false);
+      const content = target === void 0 ? { type: "file", data: import_buffer.Buffer.concat(chunks) } : { type: "symlink", target };
       for (let attempt = 0; attempt < this.limits.maxMembers; attempt++) {
-        temporary = resolvePath(dirname(path), `.unzip-${++this.serial}`);
+        const temporary = resolvePath(dirname(path), `.unzip-${++this.serial}`);
         checkPath(temporary, this.limits);
-        if (temporary === path || await this.stat(temporary)) continue;
-        await this.operation(async () => {
-          if (target === void 0) await fs.writeFile(temporary, new Uint8Array(), { signal, flag: "wx", mode: 384 });
-          else await fs.symlink(target, temporary, { signal });
-          created = true;
-          identity2 = await fs.lstat(temporary);
-        });
-        if (!identity2 || !hasIdentity(identity2)) fail("temporary file backing identity unavailable");
-        break;
-      }
-      if (!created) fail("temporary file attempt limit exceeded");
-      if (target === void 0) {
-        for (const chunk of chunks) {
-          await this.checked(root, temporary, identity2);
-          await this.operation(() => fs.appendFile(temporary, chunk, { signal }));
+        checkPath(`${temporary}/entry`, this.limits);
+        if (temporary === path) continue;
+        try {
+          await this.operation(async () => {
+            staging = await fs.createStagedFile(temporary, "entry", content, {
+              signal,
+              parent,
+              ...target !== void 0 || capabilities.permissions === false ? {} : { mode: mode & 511 },
+              ...target !== void 0 || capabilities.timestamps === false ? {} : { atimeMs: modified.getTime(), mtimeMs: modified.getTime() }
+            });
+          });
+          break;
+        } catch (error) {
+          signal.throwIfAborted();
+          if (typeof error !== "object" || error === null || !("code" in error) || error.code !== "EEXIST") throw error;
         }
-        await this.metadata(root, temporary, identity2, mode, modified);
       }
+      if (!staging) fail("temporary file attempt limit exceeded");
       await this.parents(root, path, false);
-      const current = await this.stat(path);
-      if (current ? !expected || !sameIdentity2(current, expected) || current.type !== "file" : expected !== void 0) fail("destination changed before publication");
-      const staging = await this.stat(temporary);
-      if (!staging || !identity2 || !sameIdentity2(staging, identity2) || staging.type !== (target === void 0 ? "file" : "symlink")) fail("temporary file changed before publication");
-      await this.operation(() => fs.rename(temporary, path, { signal }));
-      created = false;
+      await this.operation(() => fs.publishStagedFile(staging, path, { signal, parent, destination: expected ?? null }));
     } catch (error) {
       failure = { reason: error };
     }
@@ -28032,18 +27981,20 @@ function createUnzipCommand(options2 = {}) {
               if (chunk.length) fail("directory has nonempty payload");
             });
           }
+          const parent2 = await extraction.operation(() => context2.fs.lstat(dirname(path), { signal: context2.signal }));
           const existing3 = await extraction.stat(path);
+          let identity2 = existing3;
           if (existing3 && existing3.type !== "directory") fail("directory destination is not a directory");
           if (!existing3) {
-            await extraction.operation(() => context2.fs.mkdir(path, { signal: context2.signal, mode: 493 }));
+            identity2 = await extraction.createDirectory(path, parent2);
             await budget.output(`   creating: ${filtered(shown)}
 `);
           }
-          const identity2 = await extraction.stat(path);
           if (!identity2 || identity2.type !== "directory") fail("directory changed during creation");
-          directories.push({ path, entry, identity: identity2 });
+          directories.push({ path, entry, identity: identity2, parent: parent2 });
           continue;
         }
+        let parent = await extraction.operation(() => context2.fs.lstat(dirname(path), { signal: context2.signal }));
         let existing2 = await extraction.destination(path, archivePath, archiveStat);
         let skip = false;
         let prompting = 0;
@@ -28084,6 +28035,7 @@ function createUnzipCommand(options2 = {}) {
             path = extraction.member(root, renamed);
             shown = parsed.destination === void 0 ? renamed : `${parsed.destination.endsWith("/") ? parsed.destination : `${parsed.destination}/`}${renamed}`;
             await extraction.parents(root, path, true);
+            parent = await extraction.operation(() => context2.fs.lstat(dirname(path), { signal: context2.signal }));
             existing2 = await extraction.destination(path, archivePath, archiveStat);
             continue;
           }
@@ -28107,11 +28059,11 @@ function createUnzipCommand(options2 = {}) {
           const target = text2(import_buffer.Buffer.concat(chunks));
           await extraction.target(root, path, target);
           if (!context2.fs.symlink || context2.fs.capabilities.symlinks === false) fail("filesystem does not support symlinks");
-          links.push({ path, shown, target, existing: existing2, entry });
+          links.push({ path, shown, target, existing: existing2, parent, entry });
           await budget.output(`    linking: ${padded(filtered(shown))}  -> ${filtered(target)} 
 `);
         } else {
-          await extraction.publish(root, path, chunks, existing2, entry.mode, entry.modified);
+          await extraction.publish(root, path, chunks, existing2, parent, entry.mode, entry.modified);
           await budget.output(`${entry.method === 0 ? " extracting" : "  inflating"}: ${padded(filtered(shown))}  
 `);
         }
@@ -28125,12 +28077,12 @@ ${String(total).padStart(9)}                     ${selected} file${selected ===
           await extraction.parents(root, link.path, false);
           await extraction.target(root, link.path, link.target);
           await extraction.destination(link.path, archivePath, archiveStat);
-          await extraction.publish(root, link.path, [], link.existing, link.entry.mode, link.entry.modified, link.target);
+          await extraction.publish(root, link.path, [], link.existing, link.parent, link.entry.mode, link.entry.modified, link.target);
           await budget.output(`  ${padded(filtered(link.shown))} -> ${filtered(link.target)}
 `);
         }
-        for (const { path, entry, identity: identity2 } of directories.reverse()) {
-          await extraction.metadata(root, path, identity2, entry.mode, entry.modified);
+        for (const { path, entry, identity: identity2, parent } of directories.reverse()) {
+          await extraction.metadata(root, path, identity2, parent, entry.mode, entry.modified);
         }
         for (let index = 0; index < parsed.patterns.length; index++) if (!selection.matched.has(index)) {
           await budget.output(`caution: filename not matched:  ${filtered(parsed.patterns[index])}
@@ -49342,7 +49294,7 @@ init_platform();
 // packages/safe-js/dist/browser/safe-fs.js
 init_platform();
 
-// packages/safe-js/dist/browser/chunks/chunk-BAO3TSWI.js
+// packages/safe-js/dist/browser/chunks/chunk-SB2GDI2R.js
 init_platform();
 var platform = Object.freeze({
   errno(_code) {
@@ -50015,6 +49967,9 @@ var MemoryFileSystem = class _MemoryFileSystem {
       permissions: true,
       timestamps: true,
       atomicRename: true,
+      atomicFileStaging: true,
+      atomicFileMutation: true,
+      atomicDirectoryMetadata: true,
       streamingRead: true,
       retainedRead: true,
       get retainedResize() {
@@ -50067,6 +50022,7 @@ var MemoryFileSystem = class _MemoryFileSystem {
       ino: this.nextInode++,
       nlink: 1,
       references: 0,
+      revision: 0,
       atimeMs: now,
       mtimeMs: now,
       ctimeMs: now,
@@ -50124,6 +50080,7 @@ var MemoryFileSystem = class _MemoryFileSystem {
     if (!Number.isSafeInteger(value2) || value2 < 0) this.fail("EINVAL", syscall, path);
   }
   changed(node) {
+    node.revision = Math.min(Number.MAX_SAFE_INTEGER + 1, node.revision + 1);
     node.mtimeMs = node.ctimeMs = Date.now();
   }
   resolve(path, syscall, options2 = {}) {
@@ -50192,6 +50149,7 @@ var MemoryFileSystem = class _MemoryFileSystem {
   snapshot(node) {
     return {
       type: node.type,
+      ...Number.isSafeInteger(node.revision) ? { revision: node.revision } : {},
       preferredIoBlockSize: 4096,
       size: node.type === "file" ? node.data.byteLength : node.type === "symlink" ? new TextEncoder().encode(node.target).byteLength : 0,
       mode: node.mode,
@@ -50333,6 +50291,145 @@ var MemoryFileSystem = class _MemoryFileSystem {
     node.atimeMs = Date.now();
     return new Uint8Array(node.data);
   }
+  expectEntry(node, expected, path, unchanged5 = true) {
+    if (expected === null) {
+      if (node) this.fail("EAGAIN", "fileStaging", path);
+      return;
+    }
+    if (!node) this.fail("EAGAIN", "fileStaging", path);
+    const current = this.snapshot(node);
+    if (!expected.identityScope || expected.identityScope !== current.identityScope || !Number.isSafeInteger(expected.ino) || !Number.isSafeInteger(expected.dev)) this.fail("ENOTSUP", "fileStaging", path);
+    if (current.ino !== expected.ino || current.dev !== expected.dev || current.type !== expected.type) this.fail("EAGAIN", "fileStaging", path);
+    if (unchanged5) {
+      if (!Number.isSafeInteger(expected.revision) || !Number.isSafeInteger(current.revision)) this.fail("ENOTSUP", "fileStaging", path);
+      if (current.revision !== expected.revision || current.size !== expected.size || current.mode !== expected.mode || current.nlink !== expected.nlink || current.mtimeMs !== expected.mtimeMs || current.ctimeMs !== expected.ctimeMs) this.fail("EAGAIN", "fileStaging", path);
+    }
+  }
+  stagingLocations(staging) {
+    const parent = this.entry(staging.parent.path, "fileStaging");
+    this.expectEntry(parent.node, staging.parent.stat, staging.parent.path, false);
+    if (parent.node.type !== "directory") this.fail("ENOTDIR", "fileStaging", staging.parent.path);
+    const directory2 = this.entry(staging.directory.path, "fileStaging");
+    this.expectEntry(directory2.node, staging.directory.stat, staging.directory.path, false);
+    if (directory2.parent !== parent.node || directory2.node.type !== "directory" || (directory2.node.mode & 511) !== 448) this.fail("EAGAIN", "fileStaging", staging.directory.path);
+    const file = this.entry(staging.file.path, "fileStaging", true);
+    if (file.parent !== directory2.node || !["file", "symlink"].includes(staging.file.stat.type)) this.fail("EAGAIN", "fileStaging", staging.file.path);
+    return { directory: directory2, file };
+  }
+  async createStagedFile(directoryPath, name2, content, options2) {
+    options2.signal?.throwIfAborted();
+    if (!name2 || name2 === "." || name2 === ".." || name2.includes("/") || name2.includes("\0")) this.fail("EINVAL", "createStagedFile", directoryPath);
+    const location = this.entry(directoryPath, "createStagedFile", true);
+    if (location.node) this.fail("EEXIST", "createStagedFile", directoryPath);
+    this.expectEntry(location.parent, options2.parent, directoryPath, false);
+    this.permission(location.parent, 3, "createStagedFile", directoryPath);
+    const mode2 = this.mode(options2.mode, content.type === "file" ? 438 : 511, "createStagedFile", directoryPath);
+    for (const time of [options2.atimeMs, options2.mtimeMs]) if (time !== void 0 && !Number.isFinite(time)) this.fail("EINVAL", "createStagedFile", directoryPath);
+    if (content.type === "file" && !(content.data instanceof Uint8Array)) throw new TypeError("Staged files require Uint8Array data");
+    if (content.type === "symlink") this.validatePath(content.target, "createStagedFile");
+    const retained = (location.name.length + name2.length) * 2 + (content.type === "symlink" ? content.target.length * 2 : 0);
+    this.ledger.reserve(retained, 4, "createStagedFile", directoryPath);
+    let allocation;
+    let directory2;
+    let file;
+    try {
+      if (content.type === "file") allocation = this.bytes(content.data, "createStagedFile", directoryPath);
+      directory2 = this.directory(448);
+      file = content.type === "file" ? { ...this.metadata(typeModes.file | mode2), type: "file", data: allocation.data, allocation } : { ...this.metadata(typeModes.symlink | mode2), type: "symlink", target: content.target };
+      if (options2.atimeMs !== void 0) file.atimeMs = options2.atimeMs;
+      if (options2.mtimeMs !== void 0) file.mtimeMs = options2.mtimeMs;
+      directory2.entries.set(name2, file);
+      location.parent.entries.set(location.name, directory2);
+    } catch (error) {
+      allocation?.release();
+      this.ledger.release(retained, 4);
+      throw error;
+    }
+    this.changed(location.parent);
+    const parentPath = location.path.slice(0, location.path.lastIndexOf("/")) || "/";
+    const receipt = (path, node) => Object.freeze({ path, stat: Object.freeze(this.snapshot(node)) });
+    return Object.freeze({ parent: receipt(parentPath, location.parent), directory: receipt(location.path, directory2), file: receipt(`${location.path}/${name2}`, file) });
+  }
+  async publishStagedFile(staging, destination2, options2) {
+    options2.signal?.throwIfAborted();
+    const { directory: directory2, file } = this.stagingLocations(staging);
+    this.expectEntry(file.node, staging.file.stat, staging.file.path);
+    const target = this.entry(destination2, "publishStagedFile", true);
+    this.expectEntry(target.parent, options2.parent, destination2, false);
+    this.expectEntry(target.node, options2.destination, destination2);
+    if (target.parent === directory2.node || target.node === directory2.node || target.node === file.node) this.fail("EINVAL", "publishStagedFile", destination2);
+    if (target.node && (target.node.type !== "file" || target.node.nlink !== 1)) this.fail("EAGAIN", "publishStagedFile", destination2);
+    return _MemoryFileSystem.prototype.rename.call(this, staging.file.path, destination2, { ...options2, noReplace: options2.destination === null });
+  }
+  async removeStagedFile(staging, options2 = {}) {
+    options2.signal?.throwIfAborted();
+    const { directory: directory2, file } = this.stagingLocations(staging);
+    if (file.node) this.expectEntry(file.node, staging.file.stat, staging.file.path);
+    const node = directory2.node;
+    if (node.entries.size !== (file.node ? 1 : 0)) this.fail("ENOTEMPTY", "removeStagedFile", staging.directory.path);
+    this.permission(directory2.parent, 3, "removeStagedFile", staging.directory.path);
+    this.permission(node, 3, "removeStagedFile", staging.file.path);
+    directory2.parent.entries.delete(directory2.name);
+    if (file.node) {
+      node.entries.delete(file.name);
+      this.ledger.release(file.name.length * 2, 1);
+      file.node.nlink--;
+      file.node.ctimeMs = Date.now();
+      file.node.revision = Math.min(Number.MAX_SAFE_INTEGER + 1, file.node.revision + 1);
+      this.releaseNode(file.node);
+    }
+    this.ledger.release(directory2.name.length * 2, 1);
+    node.nlink = 0;
+    node.ctimeMs = Date.now();
+    node.revision = Math.min(Number.MAX_SAFE_INTEGER + 1, node.revision + 1);
+    this.releaseNode(node);
+    this.changed(directory2.parent);
+  }
+  async prepareDirectory(path, options2) {
+    options2.signal?.throwIfAborted();
+    const location = this.entry(path, "prepareDirectory", true);
+    this.expectEntry(location.parent, options2.parent, path, false);
+    this.expectEntry(location.node, options2.expected, path, false);
+    const mode2 = options2.mode === void 0 ? void 0 : this.mode(options2.mode, 0, "prepareDirectory", path);
+    for (const time of [options2.atimeMs, options2.mtimeMs]) if (time !== void 0 && !Number.isFinite(time)) this.fail("EINVAL", "prepareDirectory", path);
+    let node = location.node;
+    if (!node) {
+      this.permission(location.parent, 3, "prepareDirectory", path);
+      node = this.addNode(location.parent, location.name, () => this.directory(mode2 ?? 511), "prepareDirectory", path);
+    }
+    if (node.type !== "directory") this.fail("ENOTDIR", "prepareDirectory", path);
+    if (mode2 !== void 0) node.mode = typeModes.directory | mode2;
+    if (options2.atimeMs !== void 0) node.atimeMs = options2.atimeMs;
+    if (options2.mtimeMs !== void 0) node.mtimeMs = options2.mtimeMs;
+    node.ctimeMs = Date.now();
+    node.revision = Math.min(Number.MAX_SAFE_INTEGER + 1, node.revision + 1);
+    return Object.freeze(this.snapshot(node));
+  }
+  async writeFileConditional(path, data2, options2) {
+    options2.signal?.throwIfAborted();
+    const location = this.entry(path, "writeFileConditional", true);
+    this.expectEntry(location.parent, options2.parent, path, false);
+    this.expectEntry(location.node, options2.expected, path);
+    if (location.node && location.node.type !== "file") this.fail("EINVAL", "writeFileConditional", path);
+    this.writeData(path, data2, { ...options2.mode === void 0 ? {} : { mode: options2.mode }, flag: options2.append ? "a" : "w" }, "writeFileConditional");
+    return Object.freeze(this.snapshot(location.parent.entries.get(location.name)));
+  }
+  async removeFileConditional(path, options2) {
+    options2.signal?.throwIfAborted();
+    const location = this.entry(path, "removeFileConditional", true);
+    this.expectEntry(location.parent, options2.parent, path, false);
+    this.expectEntry(location.node, options2.expected, path);
+    const node = location.node;
+    if (node.type !== "file") this.fail("EINVAL", "removeFileConditional", path);
+    this.permission(location.parent, 3, "removeFileConditional", path);
+    location.parent.entries.delete(location.name);
+    this.ledger.release(location.name.length * 2, 1);
+    node.nlink--;
+    node.ctimeMs = Date.now();
+    node.revision = Math.min(Number.MAX_SAFE_INTEGER + 1, node.revision + 1);
+    this.releaseNode(node);
+    this.changed(location.parent);
+  }
   async writeFile(path, data2, options2 = {}) {
     options2.signal?.throwIfAborted();
     this.writeData(path, data2, options2, "writeFile");
@@ -50387,6 +50484,7 @@ var MemoryFileSystem = class _MemoryFileSystem {
     this.ledger.release(location.name.length * 2, 1);
     node.nlink = 0;
     node.ctimeMs = Date.now();
+    node.revision = Math.min(Number.MAX_SAFE_INTEGER + 1, node.revision + 1);
     this.releaseNode(node);
     this.changed(location.parent);
   }
@@ -50421,6 +50519,7 @@ var MemoryFileSystem = class _MemoryFileSystem {
       }
       entry.nlink--;
       entry.ctimeMs = Date.now();
+      entry.revision = Math.min(Number.MAX_SAFE_INTEGER + 1, entry.revision + 1);
       this.releaseNode(entry);
     }
     this.changed(location.parent);
@@ -50457,11 +50556,13 @@ var MemoryFileSystem = class _MemoryFileSystem {
         this.ledger.release(origin.name.length * 2, 1);
         target.node.nlink--;
         target.node.ctimeMs = Date.now();
+        target.node.revision = Math.min(Number.MAX_SAFE_INTEGER + 1, target.node.revision + 1);
         this.releaseNode(target.node);
       } else if (nameGrowth < 0) this.ledger.release(-nameGrowth, 0);
       this.changed(origin.parent);
       this.changed(target.parent);
       node.ctimeMs = Date.now();
+      node.revision = Math.min(Number.MAX_SAFE_INTEGER + 1, node.revision + 1);
     } catch (error) {
       if (error instanceof FsError2) throw new FsError2(error.code, { syscall: "rename", path: source2, dest: destination2, cause: error });
       throw error;
@@ -50527,6 +50628,7 @@ var MemoryFileSystem = class _MemoryFileSystem {
     }
     node.nlink++;
     node.ctimeMs = Date.now();
+    node.revision = Math.min(Number.MAX_SAFE_INTEGER + 1, node.revision + 1);
     this.changed(target.parent);
   }
   async chmod(path, mode2, options2 = {}) {
@@ -50535,6 +50637,7 @@ var MemoryFileSystem = class _MemoryFileSystem {
     const node = this.resolve(path, "chmod").node;
     node.mode = typeModes[node.type] | permissions;
     node.ctimeMs = Date.now();
+    node.revision = Math.min(Number.MAX_SAFE_INTEGER + 1, node.revision + 1);
   }
   async utimes(path, atimeMs, mtimeMs, options2 = {}) {
     options2.signal?.throwIfAborted();
@@ -50543,6 +50646,7 @@ var MemoryFileSystem = class _MemoryFileSystem {
     node.atimeMs = atimeMs;
     node.mtimeMs = mtimeMs;
     node.ctimeMs = Date.now();
+    node.revision = Math.min(Number.MAX_SAFE_INTEGER + 1, node.revision + 1);
   }
   async truncate(path, length = 0, options2 = {}) {
     options2.signal?.throwIfAborted();
@@ -50831,6 +50935,9 @@ var deviceCapabilities = Object.freeze({
   timestamps: false,
   truncate: false,
   randomAccessWrite: false,
+  atomicFileMutation: false,
+  atomicFileStaging: false,
+  atomicDirectoryMetadata: false,
   atomicRename: false,
   atomicRenameNoReplace: false,
   descriptorWriteStream: true,