@poe-platform/safe-bash 0.1.745 → 0.1.747

package/README.md

@@ -160,7 +160,7 @@ and other unsupported options remain unavailable.
 
 `printf` returns status 1 for invalid formats and options, retaining any output written before a format error. Its Bash format dialect accepts zero flags on string conversions and rejects numbered conversions such as `%1$s`; the grouping flag is accepted without locale-specific separators.
 
-`uniq INPUT OUTPUT` refuses aliases of the input, including symbolic and hard links, before opening the output. An existing output also requires the filesystem to establish that the files are distinct. `cut` accepts space/tab separators and padding in range lists, rejects empty comma items, and retains `--output-delimiter` between adjacent byte or character ranges. `chmod -r` removes read permissions; `--reference=FILE` copies a file's mode.
+`uniq -s` and `uniq -w` count Unicode code points in valid UTF-8 records; invalid UTF-8 records retain byte comparisons. `uniq INPUT OUTPUT` refuses aliases of the input, including symbolic and hard links, before opening the output. An existing output also requires the filesystem to establish that the files are distinct. `cut` accepts space/tab separators and padding in range lists, rejects empty comma items, and retains `--output-delimiter` between adjacent byte or character ranges. `chmod -r` removes read permissions; `--reference=FILE` copies a file's mode.
 
 `cp -l` / `--link` creates hard links to source files; `cp -s` / `--symbolic-link` creates symbolic links using the source operand as the literal target. Relative symbolic targets require destinations in the current directory; use absolute source paths when copying into other directories. Link modes require filesystem link capabilities and support recursive copying, no-clobber and backups. `cp -x` / `--one-file-system` creates directories at known filesystem boundaries without copying their contents; unknown filesystem identities remain traversable.
 
@@ -626,6 +626,10 @@ nested command dispatch, and `regex` worker limits. Per-family options are
 `text`, `structured`, `search`, `diffPatch`, `metadata`, `archive`, `tableText`,
 `streamInspection`, `streamFormat`, `split`, `timeEnv`, `tree`, `file`, `column`,
 `htmlToMarkdown`, `du`, `expr`, `which`, `timeout`, and `applyPatch`.
+`timeout.limits` bounds argument count, argument bytes, and timeout's own output
+through `maxArguments`, `maxArgumentBytes`, and `maxOutputBytes`.
+`timeEnv.maxTimerMilliseconds` and `timeout.maxTimerMilliseconds` accept `Infinity`;
+host timer calls remain capped at 2147483647 ms and progress with frozen clocks.
 Use the [typed options and linked family interfaces](src/plugins/index.ts) for
 their individual limits and hooks, including clocks and schedulers. Family budgets
 are separate from shell counters; `limits.commandLimits.archive` supplies

package/dist/image-ast/browser/sharp.d.ts

@@ -1,4 +1,4 @@
-import { Duplex } from "#image-ast-streams";
+import { Duplex } from "./streams/web.js";
 import { type ColorInput, type CompositeLayer, type ImageAstNode, type ImageFormat, type ImageMetadata, type ImageStats, type OutputInfo, type ResizeOptions, type SharpInputOptions } from "./ast.js";
 export declare class SharpInstance extends Duplex {
     private inputBytes;

package/dist/image-ast/index.js

@@ -28156,50 +28156,148 @@ function erodeImage(img, width = 1) {
   };
 }
 
-// src/streams/node.ts
-import { Buffer } from "node:buffer";
-import { EventEmitter } from "node:events";
-import { Duplex } from "node:stream";
-var outputBytes = Buffer.from;
-var isBuffer = Buffer.isBuffer;
-
-// ../safe-fs/dist/platform/node.js
-import { AsyncLocalStorage } from "node:async_hooks";
-import { randomUUID } from "node:crypto";
-import * as util from "node:util";
-import { constants } from "node:os";
-var systemErrnos = (() => {
-  const fallback = new Map(Object.entries(constants.errno).map(([name, errno]) => [name, -Math.abs(errno)]));
-  if (typeof util.getSystemErrorMap !== "function")
-    return fallback;
-  try {
-    return new Map([...util.getSystemErrorMap()].map(([errno, [name]]) => [name, errno]));
-  } catch {
-    return fallback;
+// src/streams/web.ts
+var outputBytes = Uint8Array.from.bind(Uint8Array);
+var isBuffer = (_input) => false;
+var EventEmitter = class {
+  listeners = /* @__PURE__ */ new Map();
+  on(event, listener) {
+    let listeners = this.listeners.get(event);
+    if (!listeners) this.listeners.set(event, listeners = /* @__PURE__ */ new Set());
+    listeners.add(listener);
+    return this;
   }
-})();
-var negotiating = new AsyncLocalStorage();
+  once(event, listener) {
+    const once = (...args) => {
+      this.removeListener(event, once);
+      listener(...args);
+    };
+    return this.on(event, once);
+  }
+  removeListener(event, listener) {
+    this.listeners.get(event)?.delete(listener);
+    return this;
+  }
+  emit(event, ...args) {
+    const listeners = [...this.listeners.get(event) ?? []];
+    for (const listener of listeners) listener(...args);
+    return listeners.length > 0;
+  }
+};
+var Duplex = class extends EventEmitter {
+  readable;
+  writable;
+  writableFinished = false;
+  controller;
+  closed = false;
+  constructor() {
+    super();
+    this.readable = new ReadableStream({
+      start: (controller) => {
+        this.controller = controller;
+      },
+      pull: () => {
+        this._read();
+      },
+      cancel: (reason) => {
+        this.destroy(reason instanceof Error ? reason : void 0);
+      }
+    }, { highWaterMark: 0 });
+    this.writable = new WritableStream({
+      write: (chunk) => new Promise((resolve, reject) => {
+        this._write(chunk, "utf8", (error) => {
+          if (error) {
+            this.destroy(error);
+            reject(error);
+          } else resolve();
+        });
+      }),
+      close: () => {
+        this.writableFinished = true;
+        this.emit("finish");
+      },
+      abort: (reason) => {
+        this.destroy(reason instanceof Error ? reason : void 0);
+      }
+    });
+  }
+  _write(_chunk, _encoding, callback) {
+    callback(new Error("Writable operation is not implemented"));
+  }
+  _read() {
+    throw new Error("Readable operation is not implemented");
+  }
+  push(chunk) {
+    if (this.closed) return false;
+    if (chunk === null) {
+      this.closed = true;
+      this.controller.close();
+    } else this.controller.enqueue(new Uint8Array(chunk));
+    return (this.controller.desiredSize ?? 0) > 0;
+  }
+  destroy(error) {
+    if (!this.closed) {
+      this.closed = true;
+      this.controller.error(error ?? new Error("Stream cancelled"));
+      this.emit("error", error ?? new Error("Stream cancelled"));
+    }
+    return this;
+  }
+  async *[Symbol.asyncIterator]() {
+    const reader = this.readable.getReader();
+    try {
+      while (true) {
+        const result = await reader.read();
+        if (result.done) return;
+        yield result.value;
+      }
+    } finally {
+      await reader.cancel();
+      reader.releaseLock();
+    }
+  }
+};
+
+// ../safe-fs/dist/platform/browser.js
 var platform = Object.freeze({
-  nativeFileSystem: Object.freeze({ open: true, permissions: true, timestamps: true, conditionalChmod: true, trustedOwnedStaging: true, atomicRename: true }),
+  nativeFileSystem: Object.freeze({ open: false, permissions: false, timestamps: false, conditionalChmod: false, trustedOwnedStaging: false, atomicRename: false }),
   maxCollectionBytes: Infinity,
-  errno(code) {
-    const errno = systemErrnos.get(code === "EOPNOTSUPP" ? "ENOTSUP" : code);
-    if (errno === void 0)
-      throw new TypeError(`Unsupported platform errno code: ${code}`);
-    return errno;
+  errno(_code) {
+    return void 0;
   },
-  callbackAuthorities: true,
-  randomUUID
+  callbackAuthorities: false,
+  randomUUID() {
+    const crypto = globalThis.crypto;
+    if (typeof crypto?.randomUUID === "function")
+      return crypto.randomUUID();
+    if (typeof crypto?.getRandomValues !== "function") {
+      throw new FsError("ENOTSUP", { message: "secure crypto is required for overlay staging" });
+    }
+    const bytes = crypto.getRandomValues(new Uint8Array(16));
+    bytes[6] = bytes[6] & 15 | 64;
+    bytes[8] = bytes[8] & 63 | 128;
+    const hex = Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+  }
 });
+var operationKey = /* @__PURE__ */ Symbol("filesystem-comparison");
+var contexts = /* @__PURE__ */ new WeakSet();
 var comparisonContext = Object.freeze({
-  active(_options) {
-    return negotiating.getStore() === true;
+  active(options) {
+    const context = options[operationKey];
+    return context !== void 0 && contexts.has(context);
   },
-  run(options, action) {
-    return negotiating.run(true, () => action(options));
+  async run(options, action) {
+    const context = Object.freeze({});
+    contexts.add(context);
+    const nested = { ...options, [operationKey]: context };
+    try {
+      return await action(nested);
+    } finally {
+      contexts.delete(context);
+    }
   }
 });
-var transportBudgets = new AsyncLocalStorage();
 
 // ../safe-fs/dist/contracts/errors.js
 var descriptions = {

package/dist/image-ast/sharp.d.ts

@@ -1,4 +1,4 @@
-import { Duplex } from "#image-ast-streams";
+import { Duplex } from "./streams/web.js";
 import { type ColorInput, type CompositeLayer, type ImageAstNode, type ImageFormat, type ImageMetadata, type ImageStats, type OutputInfo, type ResizeOptions, type SharpInputOptions } from "./ast.js";
 export declare class SharpInstance extends Duplex {
     private inputBytes;

package/dist/safe-bash/chunks/{chunk-2F7Q532M.js → chunk-4GK4FAT6.js}

@@ -1438,8 +1438,8 @@ function settings2(options) {
     if (value !== Infinity && (!Number.isSafeInteger(value) || value < 1)) throw new RangeError(`Invalid time-env limit: ${name}`);
   }
   const maxTimerMilliseconds = options.maxTimerMilliseconds ?? 2147483647;
-  if (!Number.isInteger(maxTimerMilliseconds) || maxTimerMilliseconds < 1 || maxTimerMilliseconds > 2147483647) {
-    throw new RangeError("maxTimerMilliseconds must be between1 and2147483647");
+  if (maxTimerMilliseconds !== Infinity && (!Number.isInteger(maxTimerMilliseconds) || maxTimerMilliseconds < 1 || maxTimerMilliseconds > 2147483647)) {
+    throw new RangeError("maxTimerMilliseconds must be between 1 and 2147483647 or Infinity");
   }
   const scheduler = options.scheduler ?? {
     now: () => performance.now(),
@@ -2079,4 +2079,4 @@ export {
   createPrCommands,
   prCommands
 };
-//# sourceMappingURL=chunk-2F7Q532M.js.map
+//# sourceMappingURL=chunk-4GK4FAT6.js.map