@poe-platform/safe-bash 0.1.802 → 0.1.804

package/dist/safe-bash/internal/op/types.d.ts

@@ -31,6 +31,7 @@ export interface OpBindingTarget {
     readonly revision: string;
 }
 export interface OpBindingPrepareContext extends OpBackendContext {
+    /** Deadline on the backend clock; omitted or Infinity means no timeout. */
     readonly expiresAt?: number;
 }
 export interface OpPreparedBinding {

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

@@ -1,12 +1,12 @@
 import {
   jobsExtension
-} from "./chunks/chunk-BJA5XNP6.js";
-import "./chunks/chunk-J42RIHHJ.js";
-import "./chunks/chunk-7R5BDCG7.js";
-import "./chunks/chunk-74GHTNJA.js";
+} from "./chunks/chunk-Y7FW6GLT.js";
+import "./chunks/chunk-4KTMKD5W.js";
+import "./chunks/chunk-XQWCQSRN.js";
+import "./chunks/chunk-OHML2BEU.js";
 import {
   init_platform
-} from "./chunks/chunk-B7TAL7S5.js";
+} from "./chunks/chunk-PTAEWLSE.js";
 
 // packages/safe-bash/src/jobs.ts
 init_platform();

package/dist/safe-bash/lazy-optional.d.ts

@@ -19,12 +19,12 @@ export declare const sofficeCommands: sofficeModule["sofficeCommands"];
 export type { SofficeCommandOptions } from "./commands/soffice/index.js";
 export declare const createSofficeCommands: sofficeModule["createSofficeCommands"];
 export type { SofficeCommandsOptions } from "./commands/soffice/index.js";
-type pandocModule = typeof import("./commands/pandoc/implementation.js");
+type pandocModule = typeof import("../safe-bash-command-pandoc/index.js");
 export declare const pandocCommands: pandocModule["pandocCommands"];
 export declare const createPandocCommands: pandocModule["createPandocCommands"];
 export declare const createPandocCommand: pandocModule["createPandocCommand"];
-export type { PandocCommandsOptions } from "./commands/pandoc/implementation.js";
-export type { PandocLimits } from "./commands/pandoc/implementation.js";
+export type { PandocCommandsOptions } from "../safe-bash-command-pandoc/index.js";
+export type { PandocLimits } from "../safe-bash-command-pandoc/index.js";
 type ssconvertModule = typeof import("./commands/ssconvert/index.js");
 export declare const createSsconvertCommand: ssconvertModule["createSsconvertCommand"];
 export declare const ssconvertCommands: ssconvertModule["ssconvertCommands"];

package/dist/safe-bash/lazy-optional.js

@@ -94,7 +94,7 @@ export const createSofficeCommands = (...args) => {
     });
     return definitions;
 };
-const loadpandoc = /* @__PURE__ */ createLazyCommandLoader(() => import("./commands/pandoc/implementation.js"));
+const loadpandoc = /* @__PURE__ */ createLazyCommandLoader(() => import("../safe-bash-command-pandoc/index.js"));
 const pandocMetadata = [
     {
         name: "pandoc",

package/dist/safe-bash/opt-in/commands/cmp/index.js

@@ -2,7 +2,7 @@ import { commandRuntimeIdentity, FsError, getCommandArguments, isFsError } from
 import { yieldTurn } from "@poe-platform/safe-bash/contracts/yield";
 import { assertCommandRequirements } from "@poe-platform/safe-bash/contracts/command-requirements";
 import { PublicDiagnostic, publicDiagnosticMessage } from "@poe-platform/safe-bash/contracts/diagnostics";
-import { ByteInputBudget } from "@poe-platform/safe-bash/optional-host";
+import { InputByteBudget } from "@poe-platform/safe-bash/contracts";
 import { registerDefaultExecutor, output, pathOf, UsageError } from "@poe-platform/safe-bash/optional-host";
 import { inputRequirements } from "@poe-platform/safe-bash/optional-host";
 import { compareCopyIdentity, compareObservedEntries } from "@poe-platform/safe-bash/contracts/filesystem-identity";
@@ -503,12 +503,11 @@ class Cursor {
                 throw result.reason;
     }
 }
-async function compare(context, parsed, blockBytes, limits, legacy, preferredBlock) {
+async function compare(context, parsed, blockBytes, limits, legacy, preferredBlock, budget) {
     const { names, skips, silent, verbose, printBytes } = parsed;
     const limit = parsed.limit >= maxCount ? Infinity : parsed.limit > BigInt(Number.MAX_SAFE_INTEGER) ? Number.MAX_SAFE_INTEGER : Number(parsed.limit);
     const controller = new AbortController();
     const signal = AbortSignal.any([context.signal, controller.signal]);
-    const budget = new ByteInputBudget(Infinity);
     let chunks = 0;
     const chargeChunk = async () => {
         if (++chunks % 64 === 0)
@@ -667,6 +666,7 @@ function buildCmpCommand(legacy, options = {}) {
     const definition = { name: "cmp", runtimeIdentity: commandRuntimeIdentity, filesystemRequirements: inputRequirements, async execute(context) {
             context.signal.throwIfAborted();
             let silent = false;
+            const budget = new InputByteBudget(Infinity, context.inputBudget);
             try {
                 const parsed = parse(context, legacy);
                 if (parsed.information) {
@@ -674,10 +674,11 @@ function buildCmpCommand(legacy, options = {}) {
                     return { exitCode: 0 };
                 }
                 silent = parsed.silent;
-                return { exitCode: await compare(context, parsed, blockBytes, limits, legacy, options.comparisonBlockBytes === undefined) };
+                return { exitCode: await compare(context, parsed, blockBytes, limits, legacy, options.comparisonBlockBytes === undefined, budget) };
             }
             catch (error) {
                 context.signal.throwIfAborted();
+                budget.assertOpen();
                 if (error instanceof InvocationClosed)
                     throw error;
                 if (!silent || !(error instanceof InputError) || !error.suppressInSilent) {
@@ -779,9 +780,9 @@ export function evalSyncCmp(inBytes, opArgs, readFileSync) {
     }
 }
 /** Opt-in GNU comparison-block behavior; producer fragments do not define blocks. */
-export const createCmpCommand = buildCmpCommand.bind(undefined, false);
+export const createCmpCommand = /* @__PURE__ */ buildCmpCommand.bind(undefined, false);
 /** Existing default-shell behavior, sharing the same retained-input engine. */
-export const cmpCommand = buildCmpCommand.bind(undefined, true);
+export const cmpCommand = /* @__PURE__ */ buildCmpCommand.bind(undefined, true);
 export function createCmpCommands(options = {}) { return [createCmpCommand(options)]; }
 export function cmpCommands(options = {}) {
     const commands = createCmpCommands(options);

package/dist/safe-bash/opt-in/commands/dd/index.js

@@ -145,7 +145,7 @@ export function createDdCommand(options = {}) {
             }
             const operation = plan.output === undefined ? createOutputOperation(context, context.stdout) : undefined;
             if (operation)
-                context = { ...context, signal: operation.signal, stdout: operation.output };
+                context = { ...context, ...(context.stdinInput ? { stdinInput: context.stdinInput } : {}), ...(context.stdoutFile ? { stdoutFile: context.stdoutFile } : {}), signal: operation.signal, stdout: operation.output };
             const handles = [];
             let cleanup;
             let closeFailure;

package/dist/safe-bash/opt-in/commands/dd/io.js

@@ -176,6 +176,31 @@ export async function openDdFile(context, request) {
         throw new DdError(`${request.synchronization === "all" ? "fsync" : "fdatasync"}: Operation not supported by the filesystem stream adapter`);
     if (request.direction === "output" && request.flags.has("append") && request.truncate)
         throw new DdError("append with truncation: Operation not supported by the filesystem stream adapter");
+    if (path === undefined && request.direction === "input" && context.stdinInput) {
+        const input = context.stdinInput;
+        const start = input.position;
+        let closed = false;
+        return {
+            ...(input.stat ? { size: BigInt(Math.max(0, input.stat.size - start)), type: input.stat.type } : {}),
+            async read(size, options) {
+                signal.throwIfAborted();
+                if (closed)
+                    throw new FsError("EBADF");
+                const result = await input.read(size, options.signal ?? signal);
+                return result.done ? new Uint8Array() : result.value;
+            },
+            ...(input.seek ? { async seek(offset, options) {
+                    signal.throwIfAborted();
+                    if (closed)
+                        throw new FsError("EBADF");
+                    const position = BigInt(start) + offset;
+                    if (position < 0n || position > BigInt(Number.MAX_SAFE_INTEGER))
+                        throw new DdError("input offset limit exceeded");
+                    await input.seek(Number(position), options.signal ?? signal);
+                } } : {}),
+            async close() { closed = true; },
+        };
+    }
     if (request.direction === "input") {
         const stat = path === undefined ? undefined : await context.fs.stat(path, { signal });
         if (path !== undefined)
@@ -243,14 +268,35 @@ export async function openDdFile(context, request) {
             async close() { closed = true; await closeIterator(); },
         };
     }
-    if (request.seek !== 0n || path !== undefined && (!request.truncate && !request.flags.has("append") || request.creation === "never")) {
-        throw new DdError("positioned or existing-only output: Operation not supported by the filesystem stream adapter");
-    }
-    if (path === undefined)
+    if (path === undefined) {
+        let position = 0n;
         return {
-            async write(chunk) { await writeBytes(context.stdout, chunk, signal); return chunk.length; },
+            async write(chunk) {
+                await writeBytes(context.stdout, chunk, signal);
+                position += BigInt(chunk.length);
+                return chunk.length;
+            },
+            async seek(offset) {
+                signal.throwIfAborted();
+                if (!context.stdoutFile)
+                    throw new FsError("ESPIPE");
+                if (offset < position || offset > BigInt(Number.MAX_SAFE_INTEGER))
+                    throw new DdError("output offset limit exceeded");
+                const capacity = BigInt(Math.min(65536, request.maxBufferBytes));
+                const zeros = new Uint8Array(Number(offset - position < capacity ? offset - position : capacity));
+                while (position < offset) {
+                    const count = Number(offset - position < BigInt(zeros.length) ? offset - position : BigInt(zeros.length));
+                    await writeBytes(context.stdout, zeros.subarray(0, count), signal);
+                    position += BigInt(count);
+                    await yieldTurn(signal);
+                }
+            },
             async close() { },
         };
+    }
+    if (request.seek !== 0n || !request.truncate && !request.flags.has("append") || request.creation === "never") {
+        throw new DdError("positioned or existing-only output: Operation not supported by the filesystem stream adapter");
+    }
     const capabilities = await context.fs.capabilitiesFor?.(path, { signal }) ?? context.fs.capabilities;
     const flag = request.creation === "exclusive" ? request.flags.has("append") ? "ax" : "wx" : request.flags.has("append") ? "a" : "w";
     if (!context.fs.writeStream || capabilities.streamingWrite === false)

package/dist/safe-bash/opt-in/commands/truncate/index.js

@@ -816,8 +816,8 @@ function createDefinition(retained, options = {}) {
     return registerDefaultExecutor(definition, options);
 }
 // Portable callers retain the path-based filesystem contract; shell defaults require retained identity.
-export const createTruncateCommand = createDefinition.bind(undefined, false);
-export const truncateCommand = createDefinition.bind(undefined, true);
+export const createTruncateCommand = /* @__PURE__ */ createDefinition.bind(undefined, false);
+export const truncateCommand = /* @__PURE__ */ createDefinition.bind(undefined, true);
 export { evalSyncTruncate } from "./sync.js";
 export function createTruncateCommands(options = {}) { return [createTruncateCommand(options)]; }
 export function truncateCommands(options = {}) {

package/dist/safe-bash/opt-in/commands/yq/native-work.js

@@ -18,6 +18,8 @@ export function limitsFor(options = {}) {
         throw new TypeError("invalid yq limits");
     const limits = { ...mikeLimits };
     for (const [name, value] of Object.entries(options)) {
+        if (Object.hasOwn(limits, name) && value === undefined)
+            continue;
         if (!Object.hasOwn(limits, name) || value !== Infinity && (!Number.isSafeInteger(value) || value < 1)) {
             throw new TypeError(`invalid yq limit: ${name}`);
         }
@@ -84,6 +86,7 @@ export class NativeWork {
         if (bytes > this.limits.maxInputBytes - this.#input)
             throw new MikeError("yq limit exceeded: maxInputBytes");
         this.#input += bytes;
+        this.context.inputBudget?.check(this.#input);
     }
     node(count = 1) {
         this.assertOpen();

package/dist/safe-bash/opt-in/optional/commands/shuf/input.js

@@ -107,7 +107,7 @@ export class FileInput {
         return { next: () => this.next(), return: async () => { await this.close(); return { done: true, value: undefined }; } };
     }
 }
-export function ownedBytes(source, signal) {
+export function ownedBytes(source, signal, budget) {
     const iterator = source[Symbol.asyncIterator]();
     const controller = new AbortController();
     const readingSignal = AbortSignal.any([signal, controller.signal]);
@@ -146,6 +146,7 @@ export function ownedBytes(source, signal) {
         let chunks = 0;
         try {
             for await (const chunk of readBytes(tracked, readingSignal)) {
+                budget?.charge(chunk.byteLength);
                 yield chunk;
                 if (++chunks % 1024 === 0)
                     await yieldTurn(readingSignal);

package/dist/safe-bash/opt-in/optional/commands/shuf/shuf.js

@@ -1,4 +1,4 @@
-import { builtInDirectContextExecutors, commandRuntimeIdentity, createBufferedOutput, getCommandArguments, isFsError, writeBytes, } from "@poe-platform/safe-bash/contracts";
+import { builtInDirectContextExecutors, commandRuntimeIdentity, createBufferedOutput, getCommandArguments, InputByteBudget, isFsError, writeBytes, } from "@poe-platform/safe-bash/contracts";
 import { openFileOutput } from "./filesystem-output.js";
 import { inheritYieldCheckpoint, yieldTurn } from "@poe-platform/safe-bash/contracts/yield";
 import { countMax, Diagnostic, fileQuote, parse, quote, unicodeLocale } from "./args.js";
@@ -25,6 +25,7 @@ export function createShufCommand(options = {}) {
         runtimeIdentity: commandRuntimeIdentity,
         description: "Write a random permutation of input records",
         async execute(context) {
+            const budget = new InputByteBudget(Infinity, context.inputBudget);
             let random;
             let output;
             let source;
@@ -96,7 +97,7 @@ export function createShufCommand(options = {}) {
                                 inputSize = stat.size;
                             input = fileInput;
                         }
-                        inputSource = ownedBytes(input, inputSignal);
+                        inputSource = ownedBytes(input, inputSignal, budget);
                         inputSignal.throwIfAborted();
                         if (closed)
                             throw new Error("shuf input is closed");
@@ -226,6 +227,7 @@ export function createShufCommand(options = {}) {
                 if (output)
                     await output.abort(error);
                 context.signal.throwIfAborted();
+                budget.assertOpen();
                 inputSignal.throwIfAborted();
                 if (isFsError(error) && error.code === "EPIPE" && diagnostic === "write error")
                     return { exitCode: 141 };

package/dist/safe-bash/opt-in/optional.d.ts

@@ -1,4 +1,4 @@
-export { Shell, agentCommands } from "@poe-platform/safe-bash";
+export { Shell, agentCommands } from "@poe-platform/safe-bash/core";
 export { createYesCommand, createYesCommands, yesCommands } from "./commands/yes/index.js";
 export type { YesCommandOptions, YesCommandsOptions, YesLimits } from "./commands/yes/index.js";
 export { createCmpCommand, createCmpCommands, cmpCommands } from "./commands/cmp/index.js";

package/dist/safe-bash/opt-in/optional.js

@@ -1,4 +1,4 @@
-export { Shell, agentCommands } from "@poe-platform/safe-bash";
+export { Shell, agentCommands } from "@poe-platform/safe-bash/core";
 export { createYesCommand, createYesCommands, yesCommands } from "./commands/yes/index.js";
 export { createCmpCommand, createCmpCommands, cmpCommands } from "./commands/cmp/index.js";
 export { createDdCommand, createDdCommands, ddCommands } from "./commands/dd/index.js";

package/dist/safe-bash/opt-in/shell/extensions/read/index.js

@@ -1,350 +1,8 @@
 import { commandRuntimeIdentity } from "@poe-platform/safe-bash/contracts/command";
-import { FsError } from "@poe-platform/safe-bash/contracts/errors";
-import { concatShellValues, shellValueBytes, shellValueFromBytes, shellValueText } from "@poe-platform/safe-bash/contracts/value";
-const usage = "read: usage: read [-Eers] [-a array] [-d delim] [-i text] [-n nchars] [-N nchars] [-p prompt] [-t timeout] [-u fd] [name ...]\n";
-function identifier(name) {
-    if (!name.length)
-        return false;
-    for (let index = 0; index < name.length; index++) {
-        const character = name[index];
-        if (character !== "_" && !(character >= "a" && character <= "z") && !(character >= "A" && character <= "Z") && !(index > 0 && character >= "0" && character <= "9"))
-            return false;
-    }
-    return true;
-}
-function decimal(value) {
-    let left = 0;
-    let right = value.length;
-    while (left < right && " \t\n\r\v\f".includes(value[left]))
-        left++;
-    while (right > left && " \t\n\r\v\f".includes(value[right - 1]))
-        right--;
-    const digits = value.slice(left, right);
-    let start = 0;
-    if (digits[0] === "+" || digits[0] === "-")
-        start++;
-    if (digits.length === start)
-        return undefined;
-    for (let index = start; index < digits.length; index++)
-        if (digits[index] < "0" || digits[index] > "9")
-            return undefined;
-    const number = Number(digits);
-    return Number.isInteger(number) && number >= 0 && number <= 2147483647 ? number : undefined;
-}
-function timeout(value) {
-    let offset = value.startsWith("+") || value.startsWith("-") ? 1 : 0;
-    let seconds = 0n;
-    while (offset < value.length && value[offset] !== ".") {
-        const character = value[offset++];
-        if (character < "0" || character > "9")
-            return undefined;
-        seconds = seconds * 10n + BigInt(character);
-        if (seconds > 9223372036854775807n)
-            return undefined;
-    }
-    if (value[offset] === ".")
-        offset++;
-    let fraction = 0;
-    let digits = 0;
-    while (offset < value.length && digits < 6) {
-        const character = value[offset++];
-        if (character < "0" || character > "9")
-            return undefined;
-        fraction = fraction * 10 + Number(character);
-        digits++;
-    }
-    fraction *= 10 ** (6 - digits);
-    if (digits === 6 && value[offset] !== undefined && value[offset] >= "5" && value[offset] <= "9")
-        fraction++;
-    if (value.startsWith("-") && (seconds > 0n || fraction > 0))
-        return undefined;
-    return Number(seconds & 4294967295n) * 1000 + fraction / 1000;
-}
-async function parse(context, validate) {
-    const options = { raw: false, exact: false, descriptor: 0, names: [] };
-    const args = context.argumentValues;
-    let offset = 0;
-    while (offset < args.length) {
-        const argument = args[offset];
-        const bytes = shellValueBytes(argument);
-        const text = shellValueText(argument);
-        if (text === "--") {
-            offset++;
-            break;
-        }
-        if (bytes[0] !== 45 || bytes.length === 1)
-            break;
-        offset++;
-        for (let index = 1; index < bytes.length; index++) {
-            const flag = String.fromCharCode(bytes[index]);
-            if (flag === "r") {
-                options.raw = true;
-                continue;
-            }
-            if (flag === "e" || flag === "E" || flag === "s") {
-                options.terminal = flag;
-                continue;
-            }
-            if (!"adnNptui".includes(flag)) {
-                await context.diagnostic(concatShellValues(["read: -", bytes[index] < 128 ? flag : shellValueFromBytes(bytes.subarray(index, index + 1)), ": invalid option"]));
-                await context.stderr.write(new TextEncoder().encode(usage));
-                return 2;
-            }
-            let value;
-            if (index + 1 < bytes.length)
-                value = typeof argument === "string" ? argument.slice(index + 1) : shellValueFromBytes(bytes.subarray(index + 1));
-            else if (offset < args.length)
-                value = args[offset++];
-            else {
-                await context.diagnostic(`read: -${flag}: option requires an argument`);
-                await context.stderr.write(new TextEncoder().encode(usage));
-                return 2;
-            }
-            const valueText = shellValueText(value);
-            if (flag === "a")
-                options.array = value;
-            else if (flag === "d")
-                options.delimiter = (index + 1 < bytes.length ? bytes[index + 1] : shellValueBytes(value)[0]) ?? 0;
-            else if (flag === "p" || flag === "i")
-                options.terminal = flag;
-            else if (flag === "t") {
-                const milliseconds = timeout(valueText);
-                if (milliseconds === undefined) {
-                    await context.diagnostic(concatShellValues(["read: ", value, ": invalid timeout specification"]));
-                    return 1;
-                }
-                options.timeout = milliseconds;
-            }
-            else {
-                const number = decimal(valueText);
-                if (number === undefined) {
-                    const detail = flag === "u" ? "file descriptor specification" : `${valueText.startsWith("0x") || valueText.startsWith("0X") ? "hex " : ""}number`;
-                    await context.diagnostic(concatShellValues(["read: ", value, `: invalid ${detail}`]));
-                    return 1;
-                }
-                if (flag === "u") {
-                    options.descriptor = number;
-                    await validate(number);
-                }
-                else {
-                    options.count = number;
-                    options.exact ||= flag === "N";
-                }
-            }
-            break;
-        }
-    }
-    options.names = args.slice(offset);
-    return options;
-}
-async function execute(nonTerminalInput, context) {
-    const diagnosedDescriptorFailure = Symbol("diagnosed read descriptor failure");
-    const inputs = [];
-    let input;
-    let observer;
-    let record;
-    let writer;
-    const operation = {};
-    let completion;
-    let closed = false;
-    const check = () => { context.signal.throwIfAborted(); if (closed)
-        throw new Error("Read invocation is closed"); };
-    const close = () => {
-        closed = true;
-        return completion ??= (async () => {
-            await Promise.allSettled([operation.work]);
-            let failure;
-            for (const release of [() => writer?.close(), () => record?.release(), ...inputs.map(lease => () => lease.release()), () => observer?.release()]) {
-                try {
-                    await release();
-                }
-                catch (reason) {
-                    failure ??= { reason };
-                }
-            }
-            if (failure)
-                throw failure.reason;
-        })();
-    };
-    context.registerCleanup(close);
-    const validate = async (descriptor) => {
-        check();
-        try {
-            context.input.validateOpen(descriptor);
-        }
-        catch (error) {
-            context.signal.throwIfAborted();
-            if (error instanceof FsError && error.code === "EBADF") {
-                await context.diagnostic(`read: ${descriptor}: invalid file descriptor: Bad file descriptor`);
-                throw diagnosedDescriptorFailure;
-            }
-            throw error;
-        }
-    };
-    const select = (descriptor) => {
-        check();
-        try {
-            input = context.input.borrow(descriptor);
-            inputs.push(input);
-        }
-        catch (error) {
-            context.signal.throwIfAborted();
-            if (!(error instanceof FsError && error.code === "EBADF"))
-                throw error;
-        }
-    };
-    const observe = (descriptor) => {
-        check();
-        try {
-            observer = context.input.observe(descriptor);
-        }
-        catch (error) {
-            context.signal.throwIfAborted();
-            if (!(error instanceof FsError && error.code === "EBADF"))
-                throw error;
-        }
-    };
-    const work = Promise.resolve().then(async () => {
-        check();
-        const options = await parse(context, validate);
-        check();
-        if (typeof options === "number")
-            return options;
-        if (options.timeout === 0) {
-            observe(options.descriptor);
-            check();
-            if (!observer)
-                return 1;
-            const { readiness } = await observer.probeRead();
-            check();
-            if (readiness === "ready")
-                return 0;
-            if (readiness === "blocked")
-                return 1;
-            if (readiness !== "unknown")
-                throw new TypeError("Invalid input readiness");
-            await context.diagnostic(observer.readable ? "read: input readiness is unknown for this cursor" : "read: descriptor readiness unavailable through this extension API");
-            return 1;
-        }
-        if (options.terminal !== undefined && !nonTerminalInput) {
-            await context.diagnostic(`read: -${options.terminal}: terminal input capabilities unavailable through this extension API`);
-            return 1;
-        }
-        const invalidName = async (name) => { await context.diagnostic(concatShellValues(["read: `", name, "': not a valid identifier"])); return 1; };
-        if (options.names[0] !== undefined && !identifier(shellValueText(options.names[0])))
-            return invalidName(options.names[0]);
-        if (options.array !== undefined && typeof context.bindings.openIndexed !== "function") {
-            await context.diagnostic("read: indexed writer unavailable through this extension API");
-            return 1;
-        }
-        const ifs = options.exact ? "" : context.bindings.get("IFS") ?? " \t\n";
-        select(options.descriptor);
-        check();
-        const inherited = options.timeout === undefined && options.count !== 0 ? context.bindings.get("TMOUT") : undefined;
-        const milliseconds = options.timeout ?? (inherited === undefined ? undefined : timeout(shellValueText(inherited)));
-        let timedOut = false;
-        if (!input && options.count !== 0) {
-            if (milliseconds !== undefined && milliseconds > 0) {
-                observe(options.descriptor);
-                check();
-                if (observer) {
-                    const probe = await observer.probeRead();
-                    check();
-                    const readyUnreadable = observer.readable === false && probe.readiness === "ready";
-                    if (probe.timeout !== "ignore" && !(readyUnreadable && probe.timeout === "unknown")) {
-                        if (probe.readiness === "unknown" || probe.timeout !== "honor") {
-                            await context.diagnostic("read: descriptor timeout observation unavailable through this extension API");
-                            return 1;
-                        }
-                        if (probe.readiness === "blocked") {
-                            const outcome = await observer.waitRead({ timeoutMs: milliseconds, signal: context.signal });
-                            check();
-                            if (outcome === "unknown") {
-                                await context.diagnostic("read: descriptor timeout observation unavailable through this extension API");
-                                return 1;
-                            }
-                            if (outcome !== "ready" && outcome !== "timeout")
-                                throw new TypeError("Invalid descriptor wait result");
-                            timedOut = outcome === "timeout";
-                        }
-                        else if (probe.readiness !== "ready")
-                            throw new TypeError("Invalid descriptor readiness");
-                    }
-                }
-            }
-            if (!timedOut) {
-                await context.diagnostic(`read: ${options.descriptor}: read error: Bad file descriptor`);
-                return 1;
-            }
-        }
-        record = await input?.read(options.raw, {
-            ...(options.count === undefined ? {} : { count: options.count }),
-            ...(options.delimiter === undefined ? {} : { delimiter: options.delimiter }),
-            exact: options.exact,
-            ...(options.count !== 0 && milliseconds !== undefined && milliseconds > 0 ? { timeoutMs: milliseconds } : {}),
-        });
-        check();
-        const status = timedOut || record?.reason === "timeout" ? 142 : record?.terminated ? 0 : 1;
-        if (options.array !== undefined) {
-            const name = shellValueText(options.array);
-            if (!identifier(name))
-                return invalidName(options.array);
-            if (context.bindings.describe(name).readonly) {
-                await context.diagnostic(`${name}: readonly variable`);
-                return 1;
-            }
-            writer = await context.bindings.openIndexed(name, { clear: true });
-            check();
-            const fields = await record?.fields(ifs) ?? [];
-            for (let index = 0; index < fields.length; index++) {
-                check();
-                await writer.set(index, fields[index].value);
-            }
-        }
-        else {
-            const names = options.names.length ? options.names : ["REPLY"];
-            const fields = options.names.length ? await record?.fields(ifs, names.length) ?? [] : undefined;
-            for (let index = 0; index < names.length; index++) {
-                check();
-                const original = names[index];
-                const name = shellValueText(original);
-                if (!identifier(name))
-                    return invalidName(original);
-                if (context.bindings.describe(name).readonly) {
-                    await context.diagnostic(`${name}: readonly variable`);
-                    return options.names.length === 0 || index < names.length - 1 ? 2 : 1;
-                }
-                await context.bindings.assign(name, fields ? fields[index]?.value ?? "" : record?.shellValue ?? "");
-            }
-        }
-        return status;
-    });
-    operation.work = work;
-    let result = 1;
-    let failure;
-    try {
-        result = await work;
-    }
-    catch (reason) {
-        if (reason === diagnosedDescriptorFailure)
-            result = 1;
-        else
-            failure = { reason };
-    }
-    try {
-        await close();
-    }
-    catch (reason) {
-        failure ??= { reason };
-    }
-    context.signal.throwIfAborted();
-    if (failure)
-        throw failure.reason;
-    return result;
-}
+import { executeRead } from "@poe-platform/safe-bash/optional-host";
 export function readExtension(options = {}) {
     const nonTerminalInput = options.nonTerminalInput === true;
     return { name: "extended-read", runtimeIdentity: commandRuntimeIdentity, create: () => ({
-            builtins: [{ name: "read", replace: true, execute: execute.bind(undefined, nonTerminalInput) }],
+            builtins: [{ name: "read", replace: true, execute: executeRead.bind(undefined, nonTerminalInput) }],
         }) };
 }