@poe-platform/safe-bash 0.1.798 → 0.1.800

package/dist/safe-bash-command-rg/index.js

@@ -1,6 +1,6 @@
 import {
   createRgCommand
-} from "../safe-bash/command-chunks/chunk-CU5RLO62.js";
+} from "../safe-bash/command-chunks/chunk-GLOZX57Y.js";
 import {
   init_buffer
 } from "../safe-bash/command-chunks/chunk-HX3SHTCE.js";
@@ -9,6 +9,226 @@ import {
 init_buffer();
 import { RegexExecutor } from "../safe-bash-regex-engine/execution/portable.js";
 import { createBoundedRegexProvider } from "../safe-bash-regex-engine/execution/bounded-provider.js";
+
+// packages/safe-bash-command-rg/src/sync.ts
+init_buffer();
+var syncRgDecoder = new TextDecoder("utf-8", { fatal: false });
+function evalSyncRg(stdinBytes, args, readFile, allowNullBytes = false) {
+  let fixed = false;
+  let ignoreCase = false;
+  let smartCase = false;
+  let invert = false;
+  let countOnly = false;
+  let onlyMatching = false;
+  let wordRegexp = false;
+  let lineRegexp = false;
+  let lineNumber;
+  let withFilename;
+  let filesWithMatches = false;
+  let filesWithoutMatch = false;
+  let quiet = false;
+  let nullTerminated = false;
+  let maxCount = Infinity;
+  const patterns = [];
+  let positionalPatternConsumed = false;
+  const paths = [];
+  let endOpts = false;
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (!endOpts && a === "--") {
+      endOpts = true;
+      continue;
+    }
+    if (!endOpts && (a === "-e" || a === "--regexp")) {
+      if (i + 1 >= args.length) return void 0;
+      patterns.push(args[++i]);
+      positionalPatternConsumed = true;
+      continue;
+    }
+    if (!endOpts && a.startsWith("--regexp=")) {
+      patterns.push(a.slice(9));
+      positionalPatternConsumed = true;
+      continue;
+    }
+    if (!endOpts && (a === "-r" || a === "--replace")) {
+      return void 0;
+    }
+    if (!endOpts && a.startsWith("--replace=")) {
+      return void 0;
+    }
+    if (!endOpts && (a === "-m" || a === "--max-count")) {
+      if (i + 1 >= args.length || !/^\d+$/u.test(args[i + 1])) return void 0;
+      maxCount = Number(args[++i]);
+      continue;
+    }
+    if (!endOpts && a.startsWith("--max-count=")) {
+      const v = a.slice(12);
+      if (!/^\d+$/u.test(v)) return void 0;
+      maxCount = Number(v);
+      continue;
+    }
+    if (!endOpts && a.startsWith("--") && a.length > 2) {
+      if (a === "--fixed-strings") fixed = true;
+      else if (a === "--ignore-case") {
+        ignoreCase = true;
+        smartCase = false;
+      } else if (a === "--case-sensitive") {
+        ignoreCase = false;
+        smartCase = false;
+      } else if (a === "--smart-case") {
+        smartCase = true;
+        ignoreCase = false;
+      } else if (a === "--invert-match") invert = true;
+      else if (a === "--count") countOnly = true;
+      else if (a === "--only-matching") onlyMatching = true;
+      else if (a === "--word-regexp") wordRegexp = true;
+      else if (a === "--line-regexp") lineRegexp = true;
+      else if (a === "--line-number") lineNumber = true;
+      else if (a === "--no-line-number") lineNumber = false;
+      else if (a === "--with-filename") withFilename = true;
+      else if (a === "--no-filename") withFilename = false;
+      else if (a === "--files-with-matches") filesWithMatches = true;
+      else if (a === "--files-without-match") filesWithoutMatch = true;
+      else if (a === "--quiet") quiet = true;
+      else if (a === "--null") nullTerminated = true;
+      else return void 0;
+      continue;
+    }
+    if (!endOpts && a.startsWith("-") && a.length > 1) {
+      for (let j = 1; j < a.length; j++) {
+        const ch = a[j];
+        if (ch === "F") fixed = true;
+        else if (ch === "i") {
+          ignoreCase = true;
+          smartCase = false;
+        } else if (ch === "s") {
+          ignoreCase = false;
+          smartCase = false;
+        } else if (ch === "S") {
+          smartCase = true;
+          ignoreCase = false;
+        } else if (ch === "v") invert = true;
+        else if (ch === "c") countOnly = true;
+        else if (ch === "o") onlyMatching = true;
+        else if (ch === "w") wordRegexp = true;
+        else if (ch === "x") lineRegexp = true;
+        else if (ch === "n") lineNumber = true;
+        else if (ch === "N") lineNumber = false;
+        else if (ch === "H") withFilename = true;
+        else if (ch === "I") withFilename = false;
+        else if (ch === "l") filesWithMatches = true;
+        else if (ch === "q") quiet = true;
+        else if (ch === "0") nullTerminated = true;
+        else if (ch === "e") {
+          const rest = a.slice(j + 1);
+          if (rest) patterns.push(rest);
+          else {
+            if (i + 1 >= args.length) return void 0;
+            patterns.push(args[++i]);
+          }
+          positionalPatternConsumed = true;
+          break;
+        } else if (ch === "m") {
+          const rest = a.slice(j + 1);
+          const v = rest || args[++i];
+          if (!v || !/^\d+$/u.test(v)) return void 0;
+          maxCount = Number(v);
+          break;
+        } else if (ch === "r") {
+          return void 0;
+        } else return void 0;
+      }
+      continue;
+    }
+    if (!positionalPatternConsumed) {
+      patterns.push(a);
+      positionalPatternConsumed = true;
+    } else {
+      paths.push(a);
+    }
+  }
+  if (patterns.length === 0) return void 0;
+  if (nullTerminated && (!allowNullBytes || !filesWithMatches && !filesWithoutMatch)) return void 0;
+  if (onlyMatching && (invert || countOnly || filesWithMatches || filesWithoutMatch)) return void 0;
+  const effectiveIgnoreCase = ignoreCase || smartCase && !patterns.some((p) => /[A-Z]/u.test(p));
+  const escapeRegex = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const rawSources = [];
+  for (const pat of patterns) {
+    if (fixed) {
+      rawSources.push(escapeRegex(pat));
+    } else {
+      if (!/^[a-zA-Z0-9_ :;,=.+*?^$\-[\]()|/{}\\]+$/u.test(pat) || /\([^)]*[+*][^)]*\)[+*?]/u.test(pat)) return void 0;
+      rawSources.push(pat);
+    }
+  }
+  const combinedSource = rawSources.length === 1 ? rawSources[0] : rawSources.map((s) => `(?:${s})`).join("|");
+  const wrappedSource = lineRegexp ? `^(?:${combinedSource})$` : wordRegexp ? `(?<![a-zA-Z0-9_])(?:${combinedSource})(?![a-zA-Z0-9_])` : combinedSource;
+  let reTest;
+  let reGlobal;
+  try {
+    reTest = new RegExp(wrappedSource, effectiveIgnoreCase ? "i" : "");
+    reGlobal = new RegExp(wrappedSource, effectiveIgnoreCase ? "gi" : "g");
+  } catch {
+    return void 0;
+  }
+  const targets = paths.length > 0 ? paths : ["-"];
+  const showFile = withFilename ?? targets.length > 1;
+  const showLine = lineNumber ?? false;
+  const outLines = [];
+  let anyMatched = false;
+  for (const t of targets) {
+    const b = t === "-" ? stdinBytes : readFile ? readFile(t) : void 0;
+    if (!b || b.byteLength > 65536 || b.includes(0)) return void 0;
+    const text = syncRgDecoder.decode(b);
+    const rawLines = text.length === 0 ? [] : text.endsWith("\n") ? text.slice(0, -1).split("\n") : text.split("\n");
+    let count = 0;
+    for (let idx = 0; idx < rawLines.length; idx++) {
+      const line = rawLines[idx];
+      const ok = reTest.test(line);
+      if (invert ? !ok : ok) {
+        count++;
+        if (filesWithoutMatch) {
+          break;
+        }
+        anyMatched = true;
+        if (filesWithMatches) {
+          outLines.push(t);
+          break;
+        }
+        if (!countOnly) {
+          let prefix = "";
+          if (showFile) prefix += `${t}:`;
+          if (showLine) prefix += `${idx + 1}:`;
+          if (onlyMatching) {
+            reGlobal.lastIndex = 0;
+            let m;
+            while ((m = reGlobal.exec(line)) !== null) {
+              outLines.push(prefix + m[0]);
+              if (m[0].length === 0) reGlobal.lastIndex++;
+            }
+          } else {
+            outLines.push(prefix + line);
+          }
+        }
+        if (count >= maxCount) break;
+      }
+    }
+    if (filesWithoutMatch) {
+      if (count === 0) {
+        anyMatched = true;
+        outLines.push(t);
+      }
+    } else if (countOnly && count > 0) {
+      outLines.push(showFile ? `${t}:${count}` : String(count));
+    }
+  }
+  if (!anyMatched) return void 0;
+  if (quiet) return "";
+  const sep = nullTerminated ? "\0" : "\n";
+  return outLines.length === 0 ? "" : `${outLines.join(sep)}${sep}`;
+}
+
+// packages/safe-bash-command-rg/src/index.ts
 function createRgCommand2(options = {}) {
   const provider = options.regexExecutor === void 0 ? createBoundedRegexProvider() : options.regexExecutor;
   return createRgCommand(new RegexExecutor(provider, options.regex), options);
@@ -28,6 +248,7 @@ function rgCommands(options = {}) {
 export {
   createRgCommand2 as createRgCommand,
   createRgCommands,
+  evalSyncRg,
   createRgCommand2 as rgCommand,
   rgCommands
 };

package/dist/safe-bash-command-rg/rg-command.js

@@ -2,7 +2,7 @@ import {
   clearRgFastRunnerPool,
   createRgCommand,
   preverifyMemoryRgTree
-} from "../safe-bash/command-chunks/chunk-CU5RLO62.js";
+} from "../safe-bash/command-chunks/chunk-GLOZX57Y.js";
 import "../safe-bash/command-chunks/chunk-HX3SHTCE.js";
 export {
   clearRgFastRunnerPool,

package/dist/safe-bash-command-rg/sync.d.ts

@@ -0,0 +1 @@
+export declare function evalSyncRg(stdinBytes: Uint8Array | undefined, args: readonly string[], readFile?: (path: string) => Uint8Array | undefined, allowNullBytes?: boolean): string | undefined;

package/dist/safe-bash-command-sed/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Poe Platform
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/safe-bash-command-sed/index.d.ts

@@ -0,0 +1,7 @@
+import type { CommandDefinition, VirtualShellPlugin } from "../safe-bash-contracts/index.js";
+import type { TextProgramOptions } from "../safe-bash-io-engine/commands/text-programs/shared.js";
+export type { TextProgramOptions as SedCommandsOptions, TextProgramOptions } from "../safe-bash-io-engine/commands/text-programs/shared.js";
+export { sedCommand as createSedCommand, sedCommand } from "./sed.js";
+export type SedLimits = Omit<TextProgramOptions, "replace" | "regexExecutor" | "regex">;
+export declare function createSedCommands(options?: TextProgramOptions): readonly CommandDefinition[];
+export declare function sedCommands(options?: TextProgramOptions): VirtualShellPlugin;

package/dist/safe-bash-command-sed/index.js

@@ -0,0 +1,28 @@
+import {
+  sedCommand
+} from "../safe-bash/command-chunks/chunk-TEVJJPTC.js";
+import "../safe-bash/command-chunks/chunk-CQ5YGOGB.js";
+import {
+  init_buffer
+} from "../safe-bash/command-chunks/chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-sed/src/index.ts
+init_buffer();
+function createSedCommands(options = {}) {
+  return [sedCommand(options)];
+}
+function sedCommands(options = {}) {
+  const commands = createSedCommands(options);
+  return { name: "sed-commands", setup(host) {
+    if (!options.replace) for (const command of commands) {
+      if (host.commands.has(command.name)) throw new Error(`Command already registered: ${command.name}`);
+    }
+    for (const command of commands) host.commands.register(command, { replace: options.replace ?? false });
+  } };
+}
+export {
+  sedCommand as createSedCommand,
+  createSedCommands,
+  sedCommand,
+  sedCommands
+};

package/dist/safe-bash-command-sed/inplace.d.ts

@@ -0,0 +1,16 @@
+import { type ByteSource, type CommandContext, type FileStagingEntry, type FileStat, type FileSystem } from "../safe-bash-contracts/index.js";
+import { Budget } from "../safe-bash-io-engine/commands/text-programs/shared.js";
+interface Target {
+    readonly path: string;
+    readonly parent: FileStat;
+    readonly original: FileStat;
+    readonly backup: FileStat | null;
+    readonly backupAncestors: readonly FileStagingEntry[];
+    readonly fs: FileSystem;
+}
+export declare function prepareInPlace(context: CommandContext, files: readonly string[], suffix: string): Promise<Target[]>;
+export declare function editInPlace<Result>(context: CommandContext, target: Target, suffix: string, budget: Budget, run: (input: ByteSource) => Promise<{
+    readonly data: Uint8Array;
+    readonly result: Result;
+}>): Promise<Result>;
+export {};

package/dist/safe-bash-command-sed/inplace.js

@@ -0,0 +1,9 @@
+import {
+  editInPlace,
+  prepareInPlace
+} from "../safe-bash/command-chunks/chunk-CQ5YGOGB.js";
+import "../safe-bash/command-chunks/chunk-HX3SHTCE.js";
+export {
+  editInPlace,
+  prepareInPlace
+};

package/dist/safe-bash-command-sed/sed.d.ts

@@ -0,0 +1,3 @@
+import { type CommandDefinition } from "../safe-bash-contracts/index.js";
+import { type TextProgramOptions } from "../safe-bash-io-engine/commands/text-programs/shared.js";
+export declare function sedCommand(options?: TextProgramOptions): CommandDefinition;

package/dist/safe-bash-command-sed/sed.js

@@ -0,0 +1,8 @@
+import {
+  sedCommand
+} from "../safe-bash/command-chunks/chunk-TEVJJPTC.js";
+import "../safe-bash/command-chunks/chunk-CQ5YGOGB.js";
+import "../safe-bash/command-chunks/chunk-HX3SHTCE.js";
+export {
+  sedCommand
+};

package/dist/safe-bash-command-shuf/input.js

@@ -1,5 +1,5 @@
 import { FsError, readBytes } from "../safe-bash-contracts/index.js";
-import { hasYieldCheckpoint, monotonicNow, runYieldCheckpoint, yieldTurn } from "../safe-bash-contracts/yield.js";
+import { yieldTurn } from "../safe-bash-contracts/yield.js";
 import { Diagnostic } from "./args.js";
 export function virtualPath(cwd, name) {
     if (name === "")
@@ -173,8 +173,6 @@ export async function* records(source, delimiter, limit, signal) {
     let pending = new Uint8Array(Math.min(256, limit));
     let used = 0;
     let scanned = 0;
-    let lastYield = monotonicNow();
-    let yieldChecks = 0;
     for await (const rawChunk of source) {
         const chunk = Uint8Array.prototype.slice.call(rawChunk);
         let start = 0;
@@ -205,14 +203,7 @@ export async function* records(source, delimiter, limit, signal) {
                 }
             }
             if (++scanned % 8192 === 0) {
-                if (++yieldChecks % 16 === 0 || hasYieldCheckpoint(signal) || monotonicNow() - lastYield >= 25) {
-                    await yieldTurn(signal);
-                    lastYield = monotonicNow();
-                }
-                else {
-                    runYieldCheckpoint(signal);
-                    signal.throwIfAborted();
-                }
+                await yieldTurn(signal);
             }
         }
     }
@@ -230,8 +221,6 @@ export async function readAllRecords(source, delimiter, maxBytes, maxRecords, si
     let used = 0;
     let scanned = 0;
     let totalBytes = 0;
-    let lastYield = monotonicNow();
-    let yieldChecks = 0;
     for await (const rawChunk of source) {
         const chunk = Uint8Array.prototype.slice.call(rawChunk);
         let start = 0;
@@ -271,14 +260,7 @@ export async function readAllRecords(source, delimiter, maxBytes, maxRecords, si
                 }
             }
             if (++scanned % 8192 === 0) {
-                const now = monotonicNow();
-                if (++yieldChecks % 16 === 0 || hasYieldCheckpoint(signal) || now - lastYield >= 16) {
-                    await yieldTurn(signal);
-                    lastYield = monotonicNow();
-                }
-                else {
-                    runYieldCheckpoint(signal);
-                }
+                await yieldTurn(signal);
             }
         }
     }

package/dist/safe-bash-command-shuf/shuf.js

@@ -1,6 +1,6 @@
 import { builtInDirectContextExecutors, commandRuntimeIdentity, createBufferedOutput, getCommandArguments, isFsError, writeBytes, } from "../safe-bash-contracts/index.js";
 import { openFileOutput } from "./filesystem-output.js";
-import { hasYieldCheckpoint, inheritYieldCheckpoint, monotonicNow, runYieldCheckpoint, yieldTurn } from "../safe-bash-contracts/yield.js";
+import { inheritYieldCheckpoint, yieldTurn } from "../safe-bash-contracts/yield.js";
 import { countMax, Diagnostic, fileQuote, parse, quote, unicodeLocale } from "./args.js";
 import { FileInput, ownedBytes, readAllRecords, records, virtualPath } from "./input.js";
 import { settings } from "./options.js";
@@ -25,8 +25,6 @@ export function createShufCommand(options = {}) {
         runtimeIdentity: commandRuntimeIdentity,
         description: "Write a random permutation of input records",
         async execute(context) {
-            let lastYield = monotonicNow();
-            let yieldChecks = 0;
             let random;
             let output;
             let source;
@@ -152,14 +150,7 @@ export function createShufCommand(options = {}) {
                             }
                             seen++;
                             if (seen % 1024n === 0n) {
-                                if (++yieldChecks % 16 === 0 || hasYieldCheckpoint(context.signal) || monotonicNow() - lastYield >= 25) {
-                                    await yieldTurn(context.signal);
-                                    lastYield = monotonicNow();
-                                }
-                                else {
-                                    runYieldCheckpoint(context.signal);
-                                    context.signal.throwIfAborted();
-                                }
+                                await yieldTurn(context.signal);
                             }
                         }
                     }
@@ -185,14 +176,7 @@ export function createShufCommand(options = {}) {
                         swaps.set(chosen, swaps.get(index) ?? index);
                         swaps.delete(index);
                         if (index % 1024n === 1023n) {
-                            if (++yieldChecks % 16 === 0 || hasYieldCheckpoint(context.signal) || monotonicNow() - lastYield >= 25) {
-                                await yieldTurn(context.signal);
-                                lastYield = monotonicNow();
-                            }
-                            else {
-                                runYieldCheckpoint(context.signal);
-                                context.signal.throwIfAborted();
-                            }
+                            await yieldTurn(context.signal);
                         }
                     }
                 }
@@ -227,14 +211,7 @@ export function createShufCommand(options = {}) {
                     if (parsed.repeat && parsed.random !== undefined)
                         await sink.flush();
                     if (index % 256n === 255n) {
-                        if (++yieldChecks % 16 === 0 || hasYieldCheckpoint(context.signal) || monotonicNow() - lastYield >= 25) {
-                            await yieldTurn(context.signal);
-                            lastYield = monotonicNow();
-                        }
-                        else {
-                            runYieldCheckpoint(context.signal);
-                            context.signal.throwIfAborted();
-                        }
+                        await yieldTurn(context.signal);
                     }
                 }
                 await sink.flush();