@poe-platform/safe-bash 0.1.501 → 0.1.503

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

@@ -4962,7 +4962,8 @@ async function* input(context2, name2 = "-") {
   } else {
     await assertInputRequirements(context2, [name2]);
     const path = pathOf(context2, name2);
-    if (context2.fs.readStream && context2.fs.capabilities.streamingRead !== false) {
+    const capabilities = await context2.fs.capabilitiesFor?.(path, { signal: context2.signal }) ?? context2.fs.capabilities;
+    if (context2.fs.readStream && capabilities.streamingRead !== false) {
       let emitted = false;
       let reading = true;
       try {
@@ -4978,7 +4979,7 @@ async function* input(context2, name2 = "-") {
         if (!reading || emitted || !(error instanceof FsError) || error.code !== "ENOTSUP") throw error;
       }
     }
-    if (context2.fs.capabilities.read === false) throw new FsError("ENOTSUP", { syscall: "readFile", path });
+    if (capabilities.read === false) throw new FsError("ENOTSUP", { syscall: "readFile", path });
     yield* readBytes2({
       async *[Symbol.asyncIterator]() {
         const bytes3 = await context2.fs.readFile(path, { signal: context2.signal, maxBytes: bufferLimit });
@@ -5381,6 +5382,7 @@ var filesystemCommandRequirements = {
   ],
   mv: [
     { id: "rename", description: "Rename files or directories", capabilities: ["stat", "rename"], mutates: true },
+    { id: "no-replace", description: "Atomically preserve an existing destination (-n)", capabilities: ["stat", "rename", "atomicRenameNoReplace"], mutates: true },
     { id: "cross-source", description: "Remove file sources after an existing cross-device transfer", capabilities: ["stat", "remove"], mutates: true },
     { id: "cross-directory-source", description: "Traverse and remove cross-device source directories", capabilities: ["stat", "readdir", "removeDirectory"], mutates: true },
     { id: "cross-link-source", description: "Inspect and remove cross-device source links", capabilities: ["stat", "readlink", "remove"], mutates: true },
@@ -5559,8 +5561,9 @@ async function moveAcrossDevices(context2, source2, target, noClobber, budget) {
   for (const entry of [...plan].reverse()) {
     context2.signal.throwIfAborted();
     if (entry.stat.type !== "symlink") {
-      if (context2.fs.capabilities.permissions === true && context2.fs.chmod) await context2.fs.chmod(entry.target, entry.stat.mode & 4095, { signal: context2.signal });
-      if (context2.fs.capabilities.timestamps === true && context2.fs.utimes) {
+      const capabilities = await context2.fs.capabilitiesFor?.(entry.target, { signal: context2.signal }) ?? context2.fs.capabilities;
+      if (capabilities.permissions === true && context2.fs.chmod) await context2.fs.chmod(entry.target, entry.stat.mode & 4095, { signal: context2.signal });
+      if (capabilities.timestamps === true && context2.fs.utimes) {
         try {
           await context2.fs.utimes(entry.target, entry.stat.atimeMs, entry.stat.mtimeMs, { signal: context2.signal });
         } catch (error) {
@@ -5627,6 +5630,23 @@ async function maybeStat(context2, path, follow = true) {
     throw error;
   }
 }
+async function admitNoReplaceRename(context2, target) {
+  let candidate = target;
+  while (true) {
+    try {
+      const capabilities = await context2.fs.capabilitiesFor?.(candidate, { signal: context2.signal }) ?? context2.fs.capabilities;
+      context2.signal.throwIfAborted();
+      if (capabilities.atomicRenameNoReplace !== true) {
+        throw new FsError("ENOTSUP", { syscall: "mv", path: target, message: "atomic no-replace rename is unavailable" });
+      }
+      return;
+    } catch (error) {
+      context2.signal.throwIfAborted();
+      if (codeOf(error) !== "ENOENT" || candidate === "/") throw error;
+      candidate = dirname(candidate);
+    }
+  }
+}
 async function canonicalMissing(context2, path, mode = "copy") {
   if (mode !== "copy") {
     context2.signal.throwIfAborted();
@@ -5668,6 +5688,8 @@ function needCapability(context2, capability) {
   if (!context2.fs[capability]) throw new FsError("ENOTSUP", { syscall: capability });
 }
 async function admitEmptyDirectory(context2, path, readDirectory) {
+  const stat = await maybeStat(context2, path, false);
+  if (stat && stat.type !== "directory") throw new FsError("ENOTDIR", { syscall: "rmdir", path });
   try {
     await admitFilesystemModes(context2, "rmdir", ["directory"], [path]);
   } catch (error) {
@@ -5746,14 +5768,15 @@ async function copy(context2, source2, target, flags3, readDirectory, top = true
     }
     if (!preflight) await context2.fs.symlink(linkTarget, target, { signal: context2.signal });
   } else {
-    await admitFilesystemModes(context2, "cp", ["file", ...flags3.has("f") && targetStat ? ["replace", "exclusive"] : []], [target]);
+    const replace = flags3.has("f") && targetStat !== void 0 && targetStat.type !== "character";
+    await admitFilesystemModes(context2, "cp", ["file", ...replace ? ["replace", "exclusive"] : []], [target]);
     if (targetStat?.type === "directory") throw new FsError("EISDIR", { path: target });
     if (preflight) return;
     try {
       await context2.fs.copyFile(source2, target, { signal: context2.signal });
     } catch (error) {
       context2.signal.throwIfAborted();
-      if (!flags3.has("f") || !targetStat || codeOf(error) !== "EACCES") throw error;
+      if (!replace || codeOf(error) !== "EACCES") throw error;
       const existing2 = await maybeStat(context2, target, false);
       if (existing2) {
         const sourceEntry = await context2.fs.lstat(source2, { signal: context2.signal });
@@ -5772,7 +5795,7 @@ async function copy(context2, source2, target, flags3, readDirectory, top = true
 `);
 }
 function modeText(stat) {
-  let text3 = stat.type === "directory" ? "d" : stat.type === "symlink" ? "l" : "-";
+  let text3 = stat.type === "directory" ? "d" : stat.type === "symlink" ? "l" : stat.type === "character" ? "c" : "-";
   for (const shift of [6, 3, 0]) {
     const mode = stat.mode >> shift;
     text3 += (mode & 4 ? "r" : "-") + (mode & 2 ? "w" : "-") + (mode & 1 ? "x" : "-");
@@ -5790,17 +5813,23 @@ function filesystemCommands(maxDirectoryEntries) {
       requireOperands(parsed.operands);
       const mode = value(parsed, "m");
       if (mode !== void 0 && !/^[0-7]{1,4}$/u.test(mode)) throw new UsageError(`invalid mode '${mode}' (octal required)`);
-      await preflightOperands(context2, parsed.operands, (operand) => admitFilesystemModes(
-        context2,
-        "mkdir",
-        [parsed.flags.has("p") ? "parents" : "directory"],
-        [pathOf(context2, operand)]
-      ));
-      return eachOperand(context2, parsed.operands, async (operand) => {
-        await context2.fs.mkdir(pathOf(context2, operand), { recursive: parsed.flags.has("p"), ...mode === void 0 ? {} : { mode: parseInt(mode, 8) }, signal: context2.signal });
-        if (parsed.flags.has("v")) await output(context2, `mkdir: created directory '${escapeText(operand, "display")}'
+      const createDirectory = async (operand, preflight) => {
+        const path = pathOf(context2, operand);
+        const recursive = parsed.flags.has("p");
+        const stat = await maybeStat(context2, path, recursive);
+        if (stat) {
+          if (recursive && stat.type === "directory") return;
+          throw new FsError("EEXIST", { syscall: "mkdir", path });
+        }
+        await admitFilesystemModes(context2, "mkdir", [recursive ? "parents" : "directory"], [path]);
+        if (!preflight) {
+          await context2.fs.mkdir(path, { recursive, ...mode === void 0 ? {} : { mode: parseInt(mode, 8) }, signal: context2.signal });
+          if (parsed.flags.has("v")) await output(context2, `mkdir: created directory '${escapeText(operand, "display")}'
 `);
-      });
+        }
+      };
+      await preflightOperands(context2, parsed.operands, (operand) => createDirectory(operand, true));
+      return eachOperand(context2, parsed.operands, (operand) => createDirectory(operand, false));
     }),
     define("touch", async (context2) => {
       const parsed = options2(context2.args, "camr:", { "no-create": "c", reference: "r" });
@@ -5868,15 +5897,21 @@ function filesystemCommands(maxDirectoryEntries) {
         const target = destination2.directory ? joinPath(destination2.target, basename(source2)) : destination2.target;
         if (parsed.flags.has("n") && await maybeStat(context2, target, false)) return;
         await admitFilesystemModes(context2, "mv", ["rename"], [source2, target]);
+        if (parsed.flags.has("n")) await admitNoReplaceRename(context2, target);
       });
       return eachOperand(context2, destination2.sources, async (operand) => {
         const source2 = pathOf(context2, operand);
         const target = destination2.directory ? joinPath(destination2.target, basename(source2)) : destination2.target;
         if (parsed.flags.has("n") && await maybeStat(context2, target, false)) return;
+        if (parsed.flags.has("n")) await admitNoReplaceRename(context2, target);
         try {
-          await context2.fs.rename(source2, target, { signal: context2.signal });
+          await context2.fs.rename(source2, target, { signal: context2.signal, ...parsed.flags.has("n") ? { noReplace: true } : {} });
         } catch (error) {
           context2.signal.throwIfAborted();
+          if (parsed.flags.has("n")) {
+            if (codeOf(error) === "EEXIST") return;
+            throw error;
+          }
           if (codeOf(error) !== "EXDEV") throw error;
           if (!await moveAcrossDevices(context2, source2, target, parsed.flags.has("n"), budget)) {
             if (!parsed.flags.has("n")) throw new FsError("EINVAL", { path: source2, dest: target, message: "source and destination are the same file" });
@@ -7170,8 +7205,15 @@ function streamCommands(maxTeeTargets = 64, maxTailFollowHandles = 64) {
       try {
         for (const operand of parsed.operands) {
           try {
-            assertCommandRequirements(context2, teeRequirements, [parsed.flags.has("a") ? "append" : "overwrite"]);
-            targets.add(await openFileOutput(context2, pathOf(context2, operand), parsed.flags.has("a") ? "a" : "w"));
+            const path = pathOf(context2, operand);
+            const capabilities = await context2.fs.capabilitiesFor?.(path, { signal: context2.signal }) ?? context2.fs.capabilities;
+            assertCommandRequirements(
+              context2,
+              teeRequirements,
+              [parsed.flags.has("a") ? "append" : "overwrite"],
+              context2.fs.capabilities.readOnly === true ? { ...capabilities, readOnly: true } : capabilities
+            );
+            targets.add(await openFileOutput(context2, path, parsed.flags.has("a") ? "a" : "w"));
           } catch (error) {
             context2.signal.throwIfAborted();
             await diagnostic(context2, error);
@@ -7526,9 +7568,10 @@ async function emitRecords(context2, records4, destination2) {
     return;
   }
   await admitTextOutput(context2, destination2);
-  if (context2.fs.writeStream && context2.fs.capabilities.streamingWrite !== false) await context2.fs.writeStream(pathOf(context2, destination2), records4, { signal: context2.signal });
+  const capabilities = await context2.fs.capabilitiesFor?.(pathOf(context2, destination2), { signal: context2.signal }) ?? context2.fs.capabilities;
+  if (context2.fs.writeStream && capabilities.streamingWrite !== false) await context2.fs.writeStream(pathOf(context2, destination2), records4, { signal: context2.signal });
   else {
-    if (context2.fs.capabilities.write === false) throw new FsError("ENOTSUP", { syscall: "writeFile", path: pathOf(context2, destination2) });
+    if (capabilities.write === false) throw new FsError("ENOTSUP", { syscall: "writeFile", path: pathOf(context2, destination2) });
     let size = 0;
     const chunks = [];
     for await (const bytes3 of records4) {
@@ -7901,7 +7944,7 @@ function predicateCommands() {
     if (!args.length) return { exitCode: 1 };
     if (args.length === 1) return { exitCode: args[0] ? 0 : 1 };
     if (args.length === 2 && args[0] === "!") return { exitCode: args[1] ? 1 : 0 };
-    const unary2 = /* @__PURE__ */ new Set(["-n", "-z", "-e", "-a", "-f", "-d", "-L", "-h", "-s", "-r", "-w", "-x"]);
+    const unary2 = /* @__PURE__ */ new Set(["-n", "-z", "-e", "-a", "-f", "-c", "-d", "-L", "-h", "-s", "-r", "-w", "-x"]);
     const binary3 = /* @__PURE__ */ new Set(["=", "==", "!=", "<", ">", "-eq", "-ne", "-lt", "-le", "-gt", "-ge", "-nt", "-ot", "-ef"]);
     let offset = 0;
     const number4 = (text3) => {
@@ -7936,7 +7979,9 @@ function predicateCommands() {
             const rightStat = await metadata(context2, right);
             if (operator === "-nt") return leftStat !== void 0 && (!rightStat || leftStat.mtimeMs > rightStat.mtimeMs);
             if (operator === "-ot") return rightStat !== void 0 && (!leftStat || leftStat.mtimeMs < rightStat.mtimeMs);
-            return leftStat?.ino !== void 0 && rightStat?.ino !== void 0 && leftStat.ino === rightStat.ino && leftStat.dev === rightStat.dev;
+            const identity2 = compareCopyIdentity(leftStat, rightStat);
+            if (identity2 !== "unknown") return identity2 === "same";
+            return leftStat?.ino !== void 0 && rightStat?.ino !== void 0 && leftStat.type === rightStat.type && leftStat.ino === rightStat.ino && leftStat.dev === rightStat.dev;
           }
           const leftNumber = number4(token);
           const rightNumber = number4(right);
@@ -7974,6 +8019,7 @@ function predicateCommands() {
           const stat = await metadata(context2, operand, token === "-L" || token === "-h");
           if (!stat) return false;
           if (token === "-f") return stat.type === "file";
+          if (token === "-c") return stat.type === "character";
           if (token === "-d") return stat.type === "directory";
           if (token === "-L" || token === "-h") return stat.type === "symlink";
           if (token === "-s") return stat.size > 0;
@@ -8924,7 +8970,7 @@ function findCommands(execute5, maxDirectoryEntries) {
           };
         }
         if (token === "-type") {
-          const types = { f: "file", d: "directory", l: "symlink" };
+          const types = { f: "file", d: "directory", l: "symlink", c: "character" };
           if (!types[operand]) throw new UsageError(`unsupported file type '${operand}'`);
           return async (entry) => entry.stat.type === types[operand];
         }
@@ -11711,8 +11757,14 @@ var AwkRuntime = class {
       const useStdin = file === "-";
       const source2 = (async function* () {
         if (useStdin) yield* context2.stdin;
-        else if (context2.fs.readStream) yield* context2.fs.readStream(name2, { signal: context2.signal });
-        else yield await context2.fs.readFile(name2, { signal: context2.signal, maxBytes: budget.maxBufferBytes });
+        else {
+          budget.step();
+          await budget.checkpoint();
+          const capabilities = await context2.fs.capabilitiesFor?.(name2, { signal: context2.signal }) ?? context2.fs.capabilities;
+          context2.signal.throwIfAborted();
+          if (context2.fs.readStream && capabilities.streamingRead !== false) yield* context2.fs.readStream(name2, { signal: context2.signal });
+          else yield await context2.fs.readFile(name2, { signal: context2.signal, maxBytes: budget.maxBufferBytes });
+        }
       })();
       try {
         reader = new Reader(source2, budget, this.retention);
@@ -14338,10 +14390,12 @@ function argumentsFor(args, budget) {
   return options3;
 }
 async function readProgram2(context2, path, limits) {
-  const absolute = resolvePath(context2.cwd, path);
+  const absolute = pathOf(context2, path);
   const chunks = [];
   let size = 0;
-  if (context2.fs.readStream) {
+  const capabilities = context2.fs.capabilitiesFor ? await interruptible(() => context2.fs.capabilitiesFor(absolute, { signal: context2.signal }), context2.signal) : context2.fs.capabilities;
+  context2.signal.throwIfAborted();
+  if (context2.fs.readStream && capabilities.streamingRead !== false) {
     for await (const chunk of readBytes2(context2.fs.readStream(absolute, { signal: context2.signal }), context2.signal)) {
       size += chunk.byteLength;
       if (size > limits.maxSourceBytes) throw new JqLimitError("maxSourceBytes");
@@ -14368,9 +14422,12 @@ async function* inputSources(context2, options3, budget) {
       usedStdin = true;
       source2 = context2.stdin;
     } else {
-      const absolute = resolvePath(context2.cwd, file);
+      const absolute = pathOf(context2, file);
       const remaining = budget.limits.maxInputBytes - budget.inputBytes;
-      if (context2.fs.readStream) source2 = context2.fs.readStream(absolute, { signal: context2.signal });
+      await budget.tick();
+      const capabilities = context2.fs.capabilitiesFor ? await interruptible(() => context2.fs.capabilitiesFor(absolute, { signal: context2.signal }), context2.signal) : context2.fs.capabilities;
+      context2.signal.throwIfAborted();
+      if (context2.fs.readStream && capabilities.streamingRead !== false) source2 = context2.fs.readStream(absolute, { signal: context2.signal });
       else source2 = toByteSource(await interruptible(() => context2.fs.readFile(absolute, { signal: context2.signal, maxBytes: remaining }), context2.signal));
     }
     budget.inputLocation = { name: file === "-" ? "<stdin>" : file, line: 0, complete: false };
@@ -21010,10 +21067,11 @@ async function planOperands(context2, options3) {
       continue;
     }
     if (!name2) throw new FsError("ENOENT", { path: name2 });
-    if (!context2.fs.readStream || context2.fs.capabilities.streamingRead === false) {
+    const source2 = pathOf(context2, name2);
+    const sourceCapabilities = await context2.fs.capabilitiesFor?.(source2, { signal: context2.signal }) ?? context2.fs.capabilities;
+    if (!context2.fs.readStream || sourceCapabilities.streamingRead === false) {
       throw new FsError("ENOTSUP", { message: "named input requires VFS streaming reads; no readFile fallback" });
     }
-    const source2 = pathOf(context2, name2);
     const sourceStat = await context2.fs.lstat(source2, { signal: context2.signal });
     if (sourceStat.type !== "file") throw new FsError("EINVAL", { path: source2, message: "input must be a regular, non-symlink file" });
     const realSource = await context2.fs.realpath(source2, { signal: context2.signal });
@@ -21024,20 +21082,22 @@ async function planOperands(context2, options3) {
     if (context2.fs.capabilities.readOnly === true) {
       throw new FsError("EROFS", { syscall: context2.command, path: realSource });
     }
-    if (!context2.fs.writeStream || context2.fs.capabilities.streamingWrite === false) {
-      throw new FsError("ENOTSUP", { message: "file output requires VFS streaming writes (use -c for stdout)" });
-    }
     if (!options3.keep && !options3.force && (sourceStat.nlink ?? 1) > 1) {
       throw new FsError("EINVAL", { path: source2, message: "input has multiple links (use -k or -f)" });
     }
     const destination2 = outputPath(realSource, options3);
+    const capabilities = await context2.fs.capabilitiesFor?.(destination2, { signal: context2.signal }) ?? context2.fs.capabilities;
+    if (capabilities.readOnly === true) throw new FsError("EROFS", { syscall: context2.command, path: destination2 });
+    if (!context2.fs.writeStream || capabilities.streamingWrite === false) {
+      throw new FsError("ENOTSUP", { message: "file output requires VFS streaming writes (use -c for stdout)" });
+    }
     const destinationStat = await existing(context2, destination2);
     if (destinationStat) {
       if (destinationStat.type !== "file" || sameIdentity(sourceStat, destinationStat) || realSource === await context2.fs.realpath(destination2, { signal: context2.signal })) {
         throw new FsError("EINVAL", { path: destination2, message: "destination is not a distinct regular file" });
       }
       if (!options3.force) throw new FsError("EEXIST", { path: destination2 });
-      if (context2.fs.capabilities.atomicRename !== true) {
+      if (capabilities.atomicRename !== true) {
         throw new FsError("ENOTSUP", { path: destination2, message: "forced replacement requires VFS atomicRename" });
       }
     }
@@ -21370,7 +21430,8 @@ var Budget11 = class {
   async read(path) {
     this.context.signal.throwIfAborted();
     const remaining = this.limits.maxInputBytes - this.inputBytes;
-    const bytes3 = path === "-" ? await collectBytes2(this.chunks(this.context.stdin), { signal: this.context.signal, maxBytes: remaining }) : this.context.fs.readStream ? await collectBytes2(this.chunks(this.context.fs.readStream(path, { signal: this.context.signal })), { signal: this.context.signal, maxBytes: remaining }) : await host(this.context, () => this.context.fs.readFile(path, { signal: this.context.signal, maxBytes: remaining }));
+    const capabilities = path === "-" ? void 0 : await host(this.context, async () => await this.context.fs.capabilitiesFor?.(path, { signal: this.context.signal }) ?? this.context.fs.capabilities);
+    const bytes3 = path === "-" ? await collectBytes2(this.chunks(this.context.stdin), { signal: this.context.signal, maxBytes: remaining }) : this.context.fs.readStream && capabilities?.streamingRead !== false ? await collectBytes2(this.chunks(this.context.fs.readStream(path, { signal: this.context.signal })), { signal: this.context.signal, maxBytes: remaining }) : await host(this.context, () => this.context.fs.readFile(path, { signal: this.context.signal, maxBytes: remaining }));
     this.inputBytes += bytes3.byteLength;
     if (this.inputBytes > this.limits.maxInputBytes) throw new ToolError("input byte limit exceeded");
     return this.text(bytes3);
@@ -21405,7 +21466,7 @@ async function host(context2, operation2) {
 async function inspect(budget, path) {
   const context2 = budget.context;
   if (path.length > 4096) throw new ToolError("path length limit exceeded");
-  const absolute = resolvePath(context2.cwd, path);
+  const absolute = pathOf(context2, path);
   const parts2 = absolute.split("/").filter(Boolean);
   if (absolute.length > 4096 || parts2.length > 256) throw new ToolError("path length/depth limit exceeded");
   let current = "";
@@ -21794,7 +21855,7 @@ async function run(context2, budget) {
       const names = /* @__PURE__ */ new Set();
       for (const path of [leftStat ? left : void 0, rightStat ? right : void 0]) {
         if (path === void 0) continue;
-        const entries3 = await host(context2, () => context2.fs.readdir(resolvePath(context2.cwd, path), { signal: context2.signal }));
+        const entries3 = await host(context2, () => context2.fs.readdir(pathOf(context2, path), { signal: context2.signal }));
         for (const entry of entries3) {
           budget.step();
           if (!entry.name || entry.name === "." || entry.name === ".." || /[\/\\\0\r\n\t]/u.test(entry.name)) throw new ToolError("unsafe directory entry name");
@@ -21808,7 +21869,7 @@ async function run(context2, budget) {
     const read = async (path, exists) => {
       if (!exists) return "";
       if (path === "-") return stdin ??= await budget.read("-");
-      return budget.read(resolvePath(context2.cwd, path));
+      return budget.read(pathOf(context2, path));
     };
     const oldText = await read(left, !!leftStat);
     const newText = await read(right, !!rightStat);
@@ -23070,7 +23131,7 @@ function metadataCommand(name2, handler) {
   } };
 }
 function permissionString(mode, type2) {
-  let text3 = type2 === "directory" ? "d" : type2 === "symlink" ? "l" : "-";
+  let text3 = type2 === "directory" ? "d" : type2 === "symlink" ? "l" : type2 === "character" ? "c" : "-";
   for (const [read, write2, execute5, special2, lower, upper] of [
     [256, 128, 64, 2048, "s", "S"],
     [32, 16, 8, 1024, "s", "S"],
@@ -23390,7 +23451,7 @@ async function render(context2, path, name2, stat, format2, escapes, limit) {
       }
     } else if (code === "%") text3 = "%";
     else if (code === "A") text3 = permissionString(stat.mode, stat.type);
-    else if (code === "F") text3 = stat.type === "directory" ? "directory" : stat.type === "symlink" ? "symbolic link" : stat.size === 0 ? "regular empty file" : "regular file";
+    else if (code === "F") text3 = stat.type === "directory" ? "directory" : stat.type === "symlink" ? "symbolic link" : stat.type === "character" ? "character special file" : stat.size === 0 ? "regular empty file" : "regular file";
     else if (["x", "y", "z", "w"].includes(code)) {
       const value2 = times[code.toUpperCase()];
       text3 = code === "w" && value2 === void 0 ? "-" : timestamp2(available(value2, code));
@@ -23515,7 +23576,6 @@ function createMktempCommand(configuration = {}) {
     try {
       if (!parsed.dryRun) {
         if (context2.fs.capabilities.readOnly) throw new FsError("EROFS", { syscall: "mktemp" });
-        if (context2.fs.capabilities.permissions !== true) throw new FsError("ENOTSUP", { syscall: "mktemp", message: "private temporary creation requires declared permission support" });
       }
       for (let attempt = 0; attempt < configured.limits.maxAttempts; attempt++) {
         await budget.step();
@@ -23534,6 +23594,9 @@ function createMktempCommand(configuration = {}) {
             if (codeOf(error) !== "ENOENT") throw error;
           }
         } else {
+          const capabilities = await context2.fs.capabilitiesFor?.(path, { signal: context2.signal }) ?? context2.fs.capabilities;
+          if (capabilities.readOnly === true) throw new FsError("EROFS", { syscall: "mktemp" });
+          if (capabilities.permissions !== true) throw new FsError("ENOTSUP", { syscall: "mktemp", message: "private temporary creation requires declared permission support" });
           try {
             const mode = (parsed.directory ? 448 : 384) & ~configured.umask;
             if (parsed.directory) await context2.fs.mkdir(path, { mode, recursive: false, signal: context2.signal });
@@ -23714,7 +23777,9 @@ async function* bounded(source2, maximum, signal, chunkSize2) {
 }
 async function* fileSource(context2, path, limits) {
   context2.signal.throwIfAborted();
-  if (context2.fs.readStream) {
+  const capabilities = await operation(context2, () => context2.fs.capabilitiesFor?.(path, { signal: context2.signal }) ?? context2.fs.capabilities);
+  context2.signal.throwIfAborted();
+  if (context2.fs.readStream && capabilities.streamingRead !== false) {
     yield* readBytes2(context2.fs.readStream(path, { signal: context2.signal, chunkSize: limits.chunkSize }), context2.signal);
   } else {
     const stat = await operation(context2, () => context2.fs.stat(path, { signal: context2.signal }));
@@ -23726,7 +23791,9 @@ async function* fileSource(context2, path, limits) {
 }
 async function publish2(context2, path, source2, mode = 384) {
   const options3 = { signal: context2.signal, flag: "wx", mode };
-  if (context2.fs.writeStream) {
+  const capabilities = await operation(context2, () => context2.fs.capabilitiesFor?.(path, { signal: context2.signal }) ?? context2.fs.capabilities);
+  context2.signal.throwIfAborted();
+  if (context2.fs.writeStream && capabilities.streamingWrite !== false) {
     let finished = false;
     const observed = (async function* () {
       yield* readBytes2(source2, context2.signal);
@@ -24492,7 +24559,7 @@ async function readArchive(context2, source2, options3, budget) {
     archivePath = await operation(context2, () => context2.fs.realpath(vfsPath(context2.cwd, options3.archive), { signal: context2.signal }));
     archiveStat = await operation(context2, () => context2.fs.stat(archivePath, { signal: context2.signal }));
   }
-  if (options3.mode === "x") await checkRoot(context2, resolvePath(options3.cwd));
+  if (options3.mode === "x") await checkRoot(context2, options3.cwd);
   try {
     while (true) {
       const block = await reader.exact(512);
@@ -24553,7 +24620,10 @@ async function readArchive(context2, source2, options3, budget) {
         const operand = options3.operands[index];
         const wanted = operand.name.replace(/^\/+/u, "").replace(/\/+$/u, "");
         if (name2.replace(/\/+$/u, "") === wanted || name2.startsWith(`${wanted}/`)) {
-          if (!selected) root = resolvePath(operand.cwd);
+          if (!selected) {
+            if (options3.mode === "x") await checkRoot(context2, operand.cwd);
+            root = resolvePath(operand.cwd);
+          }
           selected = true;
           matched.add(index);
         }
@@ -24864,10 +24934,11 @@ var Inputs = class {
     let source2;
     if (name2 === "-") source2 = this.context.stdin;
     else {
-      const path = resolvePath(this.context.cwd, name2);
+      const path = pathOf(this.context, name2);
       const stat = await this.context.fs.stat(path, { signal: this.signal });
       if (stat.type === "directory") throw new FsError("EISDIR", { path });
-      if (this.context.fs.readStream) source2 = this.context.fs.readStream(path, { signal: this.signal });
+      const capabilities = await this.context.fs.capabilitiesFor?.(path, { signal: this.signal }) ?? this.context.fs.capabilities;
+      if (this.context.fs.readStream && capabilities.streamingRead !== false) source2 = this.context.fs.readStream(path, { signal: this.signal });
       else {
         const { context: context2, signal, budget } = this;
         source2 = (async function* () {
@@ -25430,11 +25501,14 @@ var Session = class {
           } };
         } else {
           if (!name2) throw new FsError("ENOENT", { path: name2 });
-          const path = resolvePath(session.context.cwd, name2);
+          const path = pathOf(session.context, name2);
           const stat = await session.context.fs.stat(path, { signal });
           signal.throwIfAborted();
           if (stat.type === "directory") throw new FsError("EISDIR", { path });
-          if (session.context.fs.readStream) yield* session.context.fs.readStream(path, { signal });
+          await session.step();
+          const capabilities = await session.context.fs.capabilitiesFor?.(path, { signal }) ?? session.context.fs.capabilities;
+          signal.throwIfAborted();
+          if (session.context.fs.readStream && capabilities.streamingRead !== false) yield* session.context.fs.readStream(path, { signal });
           else yield await session.context.fs.readFile(path, { signal, maxBytes: Math.min(session.limits.maxChunkBytes, session.limits.maxInputBytes - session.inputBytes) });
         }
       })();
@@ -25937,11 +26011,14 @@ var Session2 = class {
           } };
         } else {
           if (!name2) throw new FsError("ENOENT", { path: name2 });
-          const path = resolvePath(session.context.cwd, name2);
+          const path = pathOf(session.context, name2);
           const stat = await session.context.fs.stat(path, { signal });
           signal.throwIfAborted();
           if (stat.type === "directory") throw new FsError("EISDIR", { path });
-          if (session.context.fs.readStream) yield* session.context.fs.readStream(path, { signal });
+          await session.step();
+          const capabilities = await session.context.fs.capabilitiesFor?.(path, { signal }) ?? session.context.fs.capabilities;
+          signal.throwIfAborted();
+          if (session.context.fs.readStream && capabilities.streamingRead !== false) yield* session.context.fs.readStream(path, { signal });
           else yield await session.context.fs.readFile(path, { signal, maxBytes: Math.min(session.limits.maxChunkBytes, session.limits.maxInputBytes - session.inputBytes) });
         }
       })();
@@ -26710,7 +26787,8 @@ var Cursor = class {
       if (input3 === "-") yield* readBytes2(context2.stdin, signal);
       else {
         const path = pathOf(context2, input3);
-        if (context2.fs.readStream && context2.fs.capabilities.streamingRead !== false) {
+        const capabilities = await interruptible2(() => Promise.resolve(context2.fs.capabilitiesFor?.(path, { signal }) ?? context2.fs.capabilities), signal);
+        if (context2.fs.readStream && capabilities.streamingRead !== false) {
           yield* readBytes2(context2.fs.readStream(path, { signal, chunkSize: limits.maxChunkBytes }), signal);
         } else {
           const maxBytes = Math.min(limits.maxInputBytes, limits.maxBufferBytes);
@@ -26977,7 +27055,8 @@ async function run3(context2, limits) {
           yield chunk;
         }
       })();
-      if (context2.fs.writeStream && context2.fs.capabilities.streamingWrite !== false) {
+      const capabilities = await interruptible2(() => Promise.resolve(context2.fs.capabilitiesFor?.(destination2.path, { signal }) ?? context2.fs.capabilities), signal);
+      if (context2.fs.writeStream && capabilities.streamingWrite !== false) {
         await interruptible2(() => context2.fs.writeStream(destination2.path, source2, { signal, flag: destination2.flag }), signal);
       } else {
         const bytes3 = await collectBytes2(source2, { signal, maxBytes: limits.maxBufferBytes });
@@ -27706,7 +27785,7 @@ function createDateCommand(configuration) {
     if (parsed.reference !== void 0) {
       try {
         if (!parsed.reference) throw new FsError("ENOENT", { path: parsed.reference });
-        const stat = await context2.fs.stat(resolvePath(context2.cwd, parsed.reference), { signal: context2.signal });
+        const stat = await context2.fs.stat(pathOf(context2, parsed.reference), { signal: context2.signal });
         context2.signal.throwIfAborted();
         instant = millisecondsInstant(stat.mtimeMs);
       } catch (error) {
@@ -28419,7 +28498,7 @@ var Walker2 = class {
       this.budget.text(operand);
       this.budget.entry();
       if (this.args.json && index) await this.write(`,${this.newline()}`);
-      const entry = await this.inspect(resolvePath(this.budget.context.cwd, operand), operand, operand);
+      const entry = await this.inspect(pathOf(this.budget.context, operand), operand, operand);
       await this.visit(entry, [], "", true, 0);
     }
     if (this.args.report) {
@@ -28849,10 +28928,11 @@ async function inspect2(context2, name2, follow, describe2, budget, stdinUsed) {
     return result3;
   }
   if (!name2 || name2.includes("\0")) throw new FsError(name2 ? "EINVAL" : "ENOENT", { path: name2 });
-  const path = resolvePath(context2.cwd, name2);
+  const path = pathOf(context2, name2);
   const fs = context2.fs;
   const stat = await budget.host(() => follow ? fs.stat(path, { signal: budget.signal }) : fs.lstat(path, { signal: budget.signal }));
   if (stat.type === "directory") return { description: "directory", mime: "inode/directory", encoding: "binary" };
+  if (stat.type === "character") return { description: "character special", mime: "inode/chardevice", encoding: "binary" };
   if (stat.type === "symlink") {
     if (follow) throw new FsError("ENOTSUP", { path, message: "followed stat returned a symbolic link" });
     const target = fs.readlink ? await budget.host(() => fs.readlink(path, { signal: budget.signal })) : void 0;
@@ -28861,7 +28941,8 @@ async function inspect2(context2, name2, follow, describe2, budget, stdinUsed) {
   }
   if (stat.type !== "file") throw new FsError("ENOTSUP", { path, message: "unsupported filesystem entry type" });
   let sample;
-  if (fs.readStream) {
+  const capabilities = fs.capabilitiesFor ? await budget.host(() => fs.capabilitiesFor(path, { signal: budget.signal })) : fs.capabilities;
+  if (fs.readStream && capabilities.streamingRead !== false) {
     const controller = new AbortController();
     const signal = AbortSignal.any([budget.signal, controller.signal]);
     try {
@@ -30226,25 +30307,17 @@ var Inputs2 = class {
     if (name2 === "-") source2 = this.context.stdin;
     else {
       const context2 = this.context, budget = this.budget, path = pathOf(context2, name2);
-      if (context2.fs.readStream) source2 = context2.fs.readStream(path, { signal: context2.signal, chunkSize: 16384 });
-      else {
-        let consumed = false;
-        source2 = { [Symbol.asyncIterator]() {
-          return {
-            async next() {
-              if (consumed) return { done: true, value: void 0 };
-              consumed = true;
-              const value2 = await context2.fs.readFile(path, { signal: context2.signal, maxBytes: budget.limits.maxInputBytes - budget.input });
-              context2.signal.throwIfAborted();
-              return { done: false, value: value2 };
-            },
-            async return() {
-              consumed = true;
-              return { done: true, value: void 0 };
-            }
-          };
-        } };
-      }
+      source2 = (async function* () {
+        const capabilities = await context2.fs.capabilitiesFor?.(path, { signal: context2.signal }) ?? context2.fs.capabilities;
+        context2.signal.throwIfAborted();
+        if (context2.fs.readStream && capabilities.streamingRead !== false) {
+          yield* readBytes2(context2.fs.readStream(path, { signal: context2.signal, chunkSize: 16384 }), context2.signal);
+        } else {
+          const value2 = await context2.fs.readFile(path, { signal: context2.signal, maxBytes: budget.limits.maxInputBytes - budget.input });
+          context2.signal.throwIfAborted();
+          yield value2;
+        }
+      })();
     }
     const cursor = new Cursor2(source2, this.context.signal);
     this.cursors.push(cursor);
@@ -31249,7 +31322,7 @@ var Walker3 = class {
     let stat;
     try {
       stat = await this.budget.fs(() => context2.fs.lstat(path, { signal: context2.signal }));
-      if (!stat || !["file", "directory", "symlink"].includes(stat.type)) throw new PublicDiagnostic("invalid entry type");
+      if (!stat || !["file", "directory", "symlink", "character"].includes(stat.type)) throw new PublicDiagnostic("invalid entry type");
     } catch (error) {
       await this.failure(error, display2);
       return { bytes: 0, complete: false };
@@ -31281,10 +31354,9 @@ var Walker3 = class {
     const { context: context2 } = this.budget;
     this.budget.text(context2.cwd);
     const paths = this.args.operands.map((operand) => {
-      const path = resolvePath(context2.cwd, operand);
-      const resolved = operand.endsWith("/") && path !== "/" ? path + "/" : path;
-      this.budget.text(resolved);
-      return resolved;
+      const path = pathOf(context2, operand === "" ? "." : operand);
+      this.budget.text(path);
+      return path;
     });
     for (let index = 0; index < paths.length; index++) {
       const amount = await this.walk(paths[index], this.args.operands[index], 0);
@@ -33095,7 +33167,10 @@ var Invocation2 = class {
     try {
       await this.work.fs(target, () => this.context.fs.access(target, 2, { signal: this.context.signal }));
     } catch (error) {
-      if (error instanceof FileFailure2 && (error.error.code === "ENOTSUP" || error.error.code === "EOPNOTSUPP") && this.context.fs.capabilities.permissions !== true) return;
+      if (error instanceof FileFailure2 && (error.error.code === "ENOTSUP" || error.error.code === "EOPNOTSUPP")) {
+        const capabilities = await this.work.fs(target, async () => await this.context.fs.capabilitiesFor?.(target, { signal: this.context.signal }) ?? this.context.fs.capabilities);
+        if (capabilities.permissions !== true) return;
+      }
       throw error;
     }
   }
@@ -33382,6 +33457,7 @@ init_platform();
 
 // packages/safe-bash/src/shell/shell.ts
 init_platform();
+import { createDeviceFileSystem } from "@poe-platform/safe-fs/core";
 
 // packages/safe-bash/src/shell/env-warning.ts
 init_platform();
@@ -33976,20 +34052,22 @@ async function unary(operator, value2, context2) {
     return context2.present(value2);
   }
   if (operator === "-o") return context2.option(value2);
-  if (!["-e", "-a", "-f", "-d", "-s", "-L", "-h", "-r", "-w", "-x"].includes(operator)) unsupported3(operator);
+  if (!["-e", "-a", "-f", "-c", "-d", "-s", "-L", "-h", "-r", "-w", "-x"].includes(operator)) unsupported3(operator);
   if (value2 === "") return false;
   if (/^\/dev\/(?:fd(?:\/|$)|stdin$|stdout$|stderr$)/u.test(value2)) unsupported3("descriptor predicate");
   const access = ["-r", "-w", "-x"].includes(operator);
-  if (access && context2.fs.capabilities.permissions !== true) unsupported3("unobservable access permission");
   try {
     if (access) {
-      await context2.fs.access(resolvePath(context2.cwd, value2), operator === "-r" ? 4 : operator === "-w" ? 2 : 1, { signal: context2.signal });
+      const capabilities = await context2.fs.capabilitiesFor?.(pathOf(context2, value2), { signal: context2.signal }) ?? context2.fs.capabilities;
+      if (capabilities.permissions !== true) unsupported3("unobservable access permission");
+      await context2.fs.access(pathOf(context2, value2), operator === "-r" ? 4 : operator === "-w" ? 2 : 1, { signal: context2.signal });
       context2.signal.throwIfAborted();
       return true;
     }
-    const metadata3 = await (operator === "-L" || operator === "-h" ? context2.fs.lstat(resolvePath(context2.cwd, value2), { signal: context2.signal }) : context2.fs.stat(resolvePath(context2.cwd, value2), { signal: context2.signal }));
+    const metadata3 = await (operator === "-L" || operator === "-h" ? context2.fs.lstat(pathOf(context2, value2), { signal: context2.signal }) : context2.fs.stat(pathOf(context2, value2), { signal: context2.signal }));
     context2.signal.throwIfAborted();
     if (operator === "-f") return metadata3.type === "file";
+    if (operator === "-c") return metadata3.type === "character";
     if (operator === "-d") return metadata3.type === "directory";
     if (operator === "-s") return metadata3.size > 0;
     if (operator === "-L" || operator === "-h") return metadata3.type === "symlink";
@@ -38474,19 +38552,20 @@ var CdLookup = class {
       const rawBytes = absolute ? targetBytes : component.startsWith("/") ? componentBytes + 1 + targetBytes : cwdBytes + 1 + (component ? componentBytes + 1 : 0) + targetBytes;
       if (rawBytes > 65536) throw new PublicDiagnostic("cd: path exceeds 65536 UTF-8 bytes");
       await this.charge(2 * rawBytes);
-      const raw = absolute ? target : component.startsWith("/") ? `${component}/${target}` : component ? `${cwd}/${component}/${target}` : `${cwd}/${target}`;
+      const raw = absolute ? target : pathOf({ cwd }, component ? `${component}/${target}` : target);
       const path = resolvePath(cwd, raw);
+      const operand = pathOf({ cwd }, raw);
       await this.scan(path);
       this.signal.throwIfAborted();
       if (++this.probes > 4097) throw new PublicDiagnostic("cd: probe limit exceeded");
       await this.charge(1);
       this.signal.throwIfAborted();
-      const stat = await fs.stat(path, { signal: this.signal });
+      const stat = await fs.stat(operand, { signal: this.signal });
       this.signal.throwIfAborted();
       if (stat.type !== "directory") throw new FsError("ENOTDIR", { path });
       await this.charge(1);
       this.signal.throwIfAborted();
-      await fs.access(path, ACCESS_MODES.X_OK, { signal: this.signal });
+      await fs.access(operand, ACCESS_MODES.X_OK, { signal: this.signal });
       this.signal.throwIfAborted();
       return path;
     };
@@ -38841,7 +38920,7 @@ var InvocationCancellationOwner = class {
   }
 };
 var Runtime = class _Runtime {
-  constructor(fs, commands, middleware, budget, signal = budget.signal, fileWrites = /* @__PURE__ */ new Map(), outputFiles = /* @__PURE__ */ new Map(), commandSignal = signal, cancellation, cancellationState, cancellationOwner, cancellationDepth, cancellationMaxDepth, outcomeFrame = void 0) {
+  constructor(fs, commands, middleware, budget, signal = budget.signal, fileWrites = /* @__PURE__ */ new Map(), outputFiles = /* @__PURE__ */ new Map(), commandSignal = signal, cancellation, cancellationState, cancellationOwner, cancellationDepth, cancellationMaxDepth, outcomeFrame = void 0, inputProfile = fs) {
     this.fs = fs;
     this.commands = commands;
     this.middleware = middleware;
@@ -38856,6 +38935,7 @@ var Runtime = class _Runtime {
     this.cancellationDepth = cancellationDepth;
     this.cancellationMaxDepth = cancellationMaxDepth;
     this.outcomeFrame = outcomeFrame;
+    this.inputProfile = inputProfile;
     this.fs = scopeFileSystem(fs, () => budget.fileSystemOperation(), signal);
     const checkpoint = () => budget.cpuCheckpoint();
     registerYieldCheckpoint(signal, checkpoint);
@@ -38875,6 +38955,7 @@ var Runtime = class _Runtime {
   cancellationDepth;
   cancellationMaxDepth;
   outcomeFrame;
+  inputProfile;
   async ereDiagnostic(io, detail) {
     try {
       await this.diagnostic(io, detail);
@@ -39073,7 +39154,8 @@ var Runtime = class _Runtime {
         owner ?? this.cancellationOwner,
         prepared.owned ? childDepth : this.cancellationDepth,
         this.cancellationMaxDepth,
-        frame
+        frame,
+        this.inputProfile
       );
       let captured;
       const executeChild = () => execute5(runtime, scope);
@@ -39616,7 +39698,8 @@ var Runtime = class _Runtime {
             owner,
             childDepth,
             this.cancellationMaxDepth,
-            frame
+            frame,
+            this.inputProfile
           );
           const input3 = new ShellInput(incoming?.readable ?? io.stdin, this.budget, signal);
           const pipeOutput = outgoing && { [outputFailure]: outgoing.abort, ownedOutput: outgoing.writable.ownedOutput, write: async (chunk) => {
@@ -40115,13 +40198,13 @@ var Runtime = class _Runtime {
             }
           }
         } else {
-          const path = resolvePath(state.cwd, target);
+          const path = pathOf(state, target);
           const options3 = { signal: this.signal };
           if (redirect.operator === "<") {
             await interruptible3(this.fs.access(path, 4, options3), this.signal);
             const stat = await interruptible3(this.fs.stat(path, options3), this.signal);
             if (stat.type === "directory" && !fileShortcut) throw new PublicDiagnostic(`${target}: Is a directory`);
-            const source2 = stat.type === "directory" ? toByteSource("") : await fileInput(this.fs, path, this.budget.limits.maxInputBytes, this.signal);
+            const source2 = stat.type === "directory" ? toByteSource("") : await fileInput(this.fs, path, this.budget.limits.maxInputBytes, this.signal, this.inputProfile);
             const input3 = new ShellInput(source2, this.budget, this.signal);
             inputs2.add(input3);
             descriptors.set(redirect.descriptor, { input: input3, stdinIsDefault: false });
@@ -40129,24 +40212,25 @@ var Runtime = class _Runtime {
             const append = redirect.operator === ">>";
             const capabilities = await this.fs.capabilitiesFor?.(path, options3) ?? this.fs.capabilities;
             const random = capabilities.randomAccessWrite === true;
+            const key = resolvePath(state.cwd, path);
             let file;
-            await this.fileOperation(path, async () => {
-              file = this.outputFiles.get(path) ?? { data: void 0, references: 0 };
+            await this.fileOperation(key, async () => {
+              file = this.outputFiles.get(key) ?? { data: void 0, references: 0 };
               if (!random && file.references) throw new FsError("ENOTSUP", { path, message: "Conflicting sequential output descriptors" });
               file.references++;
-              this.outputFiles.set(path, file);
+              this.outputFiles.set(key, file);
             });
             let closed = false;
             let offset = 0;
             const incremental = async () => {
-              await this.fileOperation(path, async () => {
+              await this.fileOperation(key, async () => {
                 if (append) await this.fs.appendFile(path, new Uint8Array(), options3);
                 else await this.fs.writeFile(path, new Uint8Array(), { ...options3, flag: "w" });
                 if (!append) file.data = new Uint8Array();
               });
               return { write: (chunk) => {
                 const copy2 = new Uint8Array(chunk);
-                return this.fileOperation(path, async () => {
+                return this.fileOperation(key, async () => {
                   if (closed) throw new Error("Output descriptor is closed");
                   const current = file.data;
                   let atEOF = false;
@@ -40178,7 +40262,7 @@ var Runtime = class _Runtime {
               if (closed) return;
               closed = true;
               resumePathCache();
-              if (--file.references === 0 && this.outputFiles.get(path) === file) this.outputFiles.delete(path);
+              if (--file.references === 0 && this.outputFiles.get(key) === file) this.outputFiles.delete(key);
             };
             let target2;
             let outputScope;
@@ -40422,7 +40506,8 @@ var Runtime = class _Runtime {
       this.cancellationOwner,
       this.cancellationDepth,
       this.cancellationMaxDepth,
-      this.outcomeFrame
+      this.outcomeFrame,
+      this.inputProfile
     );
     try {
       return await runtime.dispatchScoped(name2, values, state, { ...io, [invocationScope]: scope }, assignments2, bypassFunctions);
@@ -40818,11 +40903,12 @@ ${functionDisplay(name2, state.functions.get(name2))}`;
     let denied;
     const matches3 = [];
     for (const target of pathTargets(name2, state.variables.PATH, this.budget.limits, this.signal, (limit) => this.budget.fail(limit))) {
-      const resolved = resolvePath(state.cwd, target);
+      const resolved = pathOf(state, target);
       try {
         const options3 = { signal: this.signal };
         if (!await interruptible3(this.budget.pathLookup.isFile(this.fs, resolved, this.signal), this.signal)) continue;
-        if (this.fs.capabilities.permissions !== true) throw new CommandFailure2(`${target}: execution permissions are not supported by this filesystem`, 126);
+        const capabilities = this.fs.capabilitiesFor ? await interruptible3(this.fs.capabilitiesFor(resolved, options3), this.signal) : this.fs.capabilities;
+        if (capabilities.permissions !== true) throw new CommandFailure2(`${target}: execution permissions are not supported by this filesystem`, 126);
         await interruptible3(this.fs.access(resolved, ACCESS_MODES.X_OK, options3), this.signal);
         matches3.push(target);
         if (!all) return matches3;
@@ -41037,7 +41123,8 @@ ${prefix3} line ${offset + line}: \`${source2.split("\n")[line - 1] ?? ""}'
       this.cancellationOwner,
       this.cancellationDepth,
       this.cancellationMaxDepth,
-      this.outcomeFrame
+      this.outcomeFrame,
+      this.inputProfile
     );
     let input3;
     try {
@@ -41214,7 +41301,7 @@ ${prefix3} line ${offset + line}: \`${source2.split("\n")[line - 1] ?? ""}'
   async scriptFile(context2, state, io, target, args, direct, errexit = false, loadedSource, braceexpand = true) {
     if (target === "") throw new CommandFailure2(`${context2.command}: : No such file or directory`, 127);
     if (state.depth >= this.budget.limits.maxSubstitutionDepth) this.budget.fail("maxSubstitutionDepth");
-    const path = resolvePath(state.cwd, target);
+    const path = pathOf(state, target);
     let source2;
     let environmentInterpreter = null;
     let interpreterProfile;
@@ -41224,7 +41311,10 @@ ${prefix3} line ${offset + line}: \`${source2.split("\n")[line - 1] ?? ""}'
         const options3 = { signal: this.signal };
         const stat = await interruptible3(this.fs.stat(path, options3), this.signal);
         if (stat.type !== "file") throw new CommandFailure2(`${target}: ${stat.type === "directory" ? "Is a directory" : "not a regular file"}`, 126);
-        if (direct && this.fs.capabilities.permissions !== true) throw new CommandFailure2(`${target}: execution permissions are not supported by this filesystem`, 126);
+        if (direct) {
+          const capabilities = this.fs.capabilitiesFor ? await interruptible3(this.fs.capabilitiesFor(path, options3), this.signal) : this.fs.capabilities;
+          if (capabilities.permissions !== true) throw new CommandFailure2(`${target}: execution permissions are not supported by this filesystem`, 126);
+        }
         await interruptible3(this.fs.access(path, ACCESS_MODES.R_OK | (direct ? ACCESS_MODES.X_OK : 0), options3), this.signal);
         const maxBytes = this.budget.limits.maxSourceBytes - this.budget.sourceBytes;
         if (stat.size > maxBytes) this.budget.fail("maxSourceBytes");
@@ -41362,7 +41452,7 @@ ${prefix3} line ${offset + line}: \`${source2.split("\n")[line - 1] ?? ""}'
       if (filename && !filename.includes("/") && state.variables.PATH) {
         let found = false;
         for (const candidate of pathTargets(filename, state.variables.PATH, this.budget.limits, this.signal, (limit) => this.budget.fail(limit))) {
-          const path2 = resolvePath(state.cwd, candidate);
+          const path2 = pathOf(state, candidate);
           try {
             if (!await interruptible3(this.budget.pathLookup.isFile(this.fs, path2, this.signal), this.signal)) continue;
             await interruptible3(this.fs.access(path2, ACCESS_MODES.R_OK, options3), this.signal);
@@ -41377,7 +41467,7 @@ ${prefix3} line ${offset + line}: \`${source2.split("\n")[line - 1] ?? ""}'
         if (!found && state.profile === "sh") throw new CommandFailure2(`${context2.command}: ${filename}: file not found`, 1);
       }
       if (!filename) throw new CommandFailure2(": No such file or directory", 1);
-      const path = resolvePath(state.cwd, target);
+      const path = pathOf(state, target);
       const stat = await interruptible3(this.fs.stat(path, options3), this.signal);
       if (stat.type === "directory") throw new CommandFailure2(`${context2.command}: ${target}: is a directory`, 1);
       if (stat.type !== "file") throw new CommandFailure2(`${target}: not a regular file`, 1);
@@ -43257,7 +43347,7 @@ ${prefix3} line ${offset + line}: \`${source2.split("\n")[line - 1] ?? ""}'
           for (const candidate of candidates) {
             let entries3;
             try {
-              const pending = this.fs.readdir(resolvePath(state.cwd, candidate || "."), { signal: this.signal });
+              const pending = this.fs.readdir(pathOf(state, candidate || "."), { signal: this.signal });
               entries3 = arrayStore(state) ? await interruptible3(pending, this.signal) : await pending;
             } catch (error) {
               if (["ENOENT", "ENOTDIR", "EACCES"].includes(errorCode(error) ?? "")) continue;
@@ -43278,7 +43368,7 @@ ${prefix3} line ${offset + line}: \`${source2.split("\n")[line - 1] ?? ""}'
     const found = [];
     for (const candidate of candidates) {
       try {
-        const pending = this.fs.stat(resolvePath(state.cwd, candidate), { signal: this.signal });
+        const pending = this.fs.stat(pathOf(state, candidate), { signal: this.signal });
         const stat = arrayStore(state) ? await interruptible3(pending, this.signal) : await pending;
         if (!value2.endsWith("/") || stat.type === "directory") found.push(candidate + (value2.endsWith("/") ? "/" : ""));
       } catch (error) {
@@ -43290,7 +43380,7 @@ ${prefix3} line ${offset + line}: \`${source2.split("\n")[line - 1] ?? ""}'
 };
 
 // packages/safe-bash/src/shell/input.ts
-async function fileInput(fs, path, maxBytes, signal) {
+async function fileInput(fs, path, maxBytes, signal, inputProfile = fs) {
   signal.throwIfAborted();
   async function bufferedInput() {
     signal.throwIfAborted();
@@ -43300,7 +43390,13 @@ async function fileInput(fs, path, maxBytes, signal) {
     return toByteSource(bytes3);
   }
   const readStream = fs.readStream;
-  if (!readStream || fs.capabilities.streamingRead === false) return bufferedInput();
+  const capabilities = await interruptible3(Promise.resolve(fs.capabilitiesFor?.(path, { signal }) ?? fs.capabilities), signal);
+  if (!readStream || capabilities.streamingRead === false) {
+    if (!inputProfile.readStream || inputProfile.capabilities.streamingRead === false) return bufferedInput();
+    return { async *[Symbol.asyncIterator]() {
+      yield* await bufferedInput();
+    } };
+  }
   let iterator;
   try {
     iterator = readStream.call(fs, path, { signal })[Symbol.asyncIterator]();
@@ -43894,8 +43990,9 @@ var Shell = class {
           profile: "bash"
         };
         const admission = Runtime.rootCancellationAdmission(budget);
+        const filesystem = options3.fs ?? this.#options.fs;
         const runtime = new Runtime(
-          options3.fs ?? this.#options.fs,
+          createDeviceFileSystem(filesystem),
           this.commands,
           [...this.#middleware],
           budget,
@@ -43907,7 +44004,9 @@ var Shell = class {
           cancellationState,
           owner,
           0,
-          admission.maxDepth
+          admission.maxDepth,
+          void 0,
+          filesystem
         );
         exitCode = 0;
         while (true) {
@@ -44109,7 +44208,7 @@ init_platform();
 // packages/safe-js/dist/browser/safe-fs.js
 init_platform();
 
-// packages/safe-js/dist/browser/chunks/chunk-I3HSJDAA.js
+// packages/safe-js/dist/browser/chunks/chunk-QK4IEGRO.js
 init_platform();
 var platform = Object.freeze({
   errno(_code) {
@@ -44767,6 +44866,7 @@ var MemoryFileSystem = class _MemoryFileSystem {
       removeDirectory: true,
       recursiveRemove: true,
       rename: true,
+      atomicRenameNoReplace: true,
       copy: true,
       exclusiveCopy: true,
       readlink: true,
@@ -45191,6 +45291,7 @@ var MemoryFileSystem = class _MemoryFileSystem {
       if (this.terminalDot(source2) || this.terminalDot(destination2)) this.fail("EINVAL", "rename", source2, destination2);
       if (node === this.root || target.node === this.root) this.fail("EBUSY", "rename", source2, destination2);
       if (destination2.endsWith("/") && node.type !== "directory") this.fail("ENOTDIR", "rename", source2, destination2);
+      if (options3.noReplace && target.node) this.fail("EEXIST", "rename", source2, destination2);
       if (target.node === node) return;
       if (node.type === "directory" && target.path.startsWith(`${origin.path}/`)) this.fail("EINVAL", "rename", source2, destination2);
       this.permission(origin.parent, 3, "rename", source2);
@@ -45477,6 +45578,39 @@ function stockDescriptorWrite(filesystem) {
   }
   return true;
 }
+var deviceCapabilities = Object.freeze({
+  readOnly: false,
+  read: true,
+  stat: true,
+  realpath: true,
+  access: true,
+  readdir: false,
+  write: true,
+  append: true,
+  exclusiveCreate: true,
+  streamingRead: true,
+  retainedRead: true,
+  streamingWrite: true,
+  streamingAppend: true,
+  copy: true,
+  exclusiveCopy: true,
+  remove: false,
+  removeDirectory: false,
+  recursiveRemove: false,
+  rename: false,
+  mkdir: false,
+  recursiveMkdir: false,
+  symlinks: false,
+  hardlinks: false,
+  readlink: false,
+  permissions: false,
+  timestamps: false,
+  truncate: false,
+  randomAccessWrite: false,
+  atomicRename: false,
+  atomicRenameNoReplace: false,
+  descriptorWriteStream: true
+});
 var syntheticStat = Object.freeze({
   type: "directory",
   size: 0,
@@ -45849,6 +45983,7 @@ var WebDavFileSystem = class {
     remove: true,
     recursiveRemove: true,
     rename: true,
+    atomicRenameNoReplace: false,
     copy: true,
     exclusiveCopy: true,
     readlink: false,
@@ -46787,6 +46922,10 @@ var WebDavFileSystem = class {
     }
   }
   async rename(source2, destination2, options3 = {}) {
+    if (options3.noReplace) {
+      options3.signal?.throwIfAborted();
+      fail32("ENOTSUP", "rename", source2, "atomic no-replace rename is unsupported");
+    }
     await this.transfer("MOVE", source2, destination2, options3);
   }
   async copyFile(source2, destination2, options3 = {}) {
@@ -47351,7 +47490,8 @@ function createSafeJsCommands(options3 = {}, dialect = {
       let filename = parsed.file;
       if (source2 === void 0) {
         if (!fromStdin) filename = pathOf(context2, parsed.file);
-        const bytes3 = fromStdin ? context2.stdin : context2.fs.readStream && context2.fs.capabilities.streamingRead !== false ? context2.fs.readStream(filename, { signal, chunkSize: 65536 }) : toByteSource(await withSignal(signal, () => context2.fs.readFile(filename, { signal, maxBytes: limits.maxSourceBytes })));
+        const capabilities = fromStdin ? void 0 : await withSignal(signal, async () => await context2.fs.capabilitiesFor?.(filename, { signal }) ?? context2.fs.capabilities);
+        const bytes3 = fromStdin ? context2.stdin : context2.fs.readStream && capabilities?.streamingRead !== false ? context2.fs.readStream(filename, { signal, chunkSize: 65536 }) : toByteSource(await withSignal(signal, () => context2.fs.readFile(filename, { signal, maxBytes: limits.maxSourceBytes })));
         const reader = new GuestInput(bytes3, limits.maxSourceBytes, signal, fail4, "maxSourceBytes");
         try {
           source2 = await reader.readText();