@poe-platform/safe-bash 0.1.629 → 0.1.631

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

@@ -0,0 +1,351 @@
+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;
+                    if (flag === "N")
+                        options.exact = true;
+                }
+            }
+            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;
+}
+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) }],
+        }) };
+}

package/dist/safe-bash/opt-in/shell/extensions/trap/index.d.ts

@@ -0,0 +1,9 @@
+import type { ShellExtension } from "@poe-platform/safe-bash/optional-host";
+export interface TrapSignalHost {
+    subscribe(deliver: (signal: string | number) => boolean, scope: object): () => void | Promise<void>;
+}
+export interface TrapExtensionOptions {
+    readonly signalNames?: Readonly<Record<string, number>>;
+    readonly signalHost?: TrapSignalHost;
+}
+export declare function trapExtension(configuration?: TrapExtensionOptions): ShellExtension;

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

@@ -0,0 +1,210 @@
+import { constants, platform } from "node:os";
+import { shellValueByteLength, shellValueBytes, shellValueText } from "@poe-platform/safe-bash/contracts/value";
+import { commandRuntimeIdentity } from "@poe-platform/safe-bash/contracts/command";
+function quote(source) {
+    const bytes = shellValueBytes(source);
+    const parts = [Buffer.from("'")];
+    let start = 0;
+    for (let index = 0; index < bytes.length; index++)
+        if (bytes[index] === 39) {
+            parts.push(bytes.subarray(start, index), Buffer.from("'\\''"));
+            start = index + 1;
+        }
+    parts.push(bytes.subarray(start), Buffer.from("'"));
+    return Buffer.concat(parts);
+}
+export function trapExtension(configuration = {}) {
+    const catalog = { ...(configuration.signalNames ?? { ...constants.signals, ...(platform() === "darwin" ? { SIGEMT: 7 } : {}) }) };
+    const names = new Map([[0, "EXIT"]]);
+    const aliases = new Map([["EXIT", 0], ["SIGEXIT", 0]]);
+    for (const [name, number] of Object.entries(catalog)) {
+        if (!name.startsWith("SIG") || !Number.isSafeInteger(number) || number <= 0 || number > 1024)
+            throw new TypeError("Invalid trap signal catalog");
+        if (!names.has(number))
+            names.set(number, name);
+        aliases.set(name, number);
+        aliases.set(name.slice(3), number);
+    }
+    const pseudoBase = Math.max(...names.keys()) + 1;
+    for (const [index, name] of ["DEBUG", "ERR", "RETURN"].entries()) {
+        names.set(pseudoBase + index, name);
+        aliases.set(name, pseudoBase + index);
+        aliases.set("SIG" + name, pseudoBase + index);
+    }
+    const resolve = (value) => {
+        const text = String(value).toUpperCase();
+        const named = aliases.get(text);
+        if (named !== undefined)
+            return named;
+        const digits = text[0] === "+" ? text.slice(1) : text;
+        if (!digits || [...digits].some(character => character < "0" || character > "9"))
+            return undefined;
+        const number = Number(digits);
+        return names.has(number) ? number : undefined;
+    };
+    function instance(actions = new Map(), errorTrace = false, functionTrace = false, inheritedIgnored = new Set(), extendedDebug = false) {
+        const options = [{ name: "errtrace", flag: "E", enabled: errorTrace }, { name: "functrace", flag: "T", enabled: functionTrace }];
+        const running = new Set();
+        const pending = new Set();
+        const functions = [];
+        const sources = [];
+        const run = async (number, context) => {
+            context.signal.throwIfAborted();
+            const action = actions.get(number);
+            if (!action?.active || !shellValueByteLength(action.source) || running.has(number))
+                return;
+            running.add(number);
+            try {
+                return await context.evaluate(action.source, { name: number === 0 ? "exit trap" : "trap" });
+            }
+            finally {
+                running.delete(number);
+            }
+        };
+        return {
+            options,
+            shoptOptions: [{ name: "extdebug", get enabled() { return extendedDebug; }, set enabled(value) { extendedDebug = value; for (const option of options)
+                        option.enabled = value; } }],
+            start(context) {
+                if (!configuration.signalHost)
+                    return;
+                let open = true;
+                const subscription = {};
+                context.registerCleanup(async () => { open = false; pending.clear(); await subscription.close?.(); });
+                subscription.close = configuration.signalHost.subscribe(signal => {
+                    if (!open || context.signal.aborted)
+                        return false;
+                    const number = resolve(signal);
+                    if (number === undefined || number === 0 || number >= pseudoBase || names.get(number) === "SIGKILL" || names.get(number) === "SIGSTOP")
+                        return false;
+                    const action = actions.get(number);
+                    if (!action?.active)
+                        return false;
+                    if (shellValueByteLength(action.source)) {
+                        pending.add(number);
+                        context.interruptWait?.((128 + number) % 256);
+                    }
+                    return true;
+                }, context.scope);
+            },
+            builtins: [{
+                    name: "trap", special: true,
+                    async execute(context) {
+                        context.signal.throwIfAborted();
+                        const args = [...context.args];
+                        let print = false, list = false;
+                        while (args[0]?.startsWith("-") && args[0] !== "-") {
+                            const option = args.shift();
+                            if (option === "--")
+                                break;
+                            for (const flag of option.slice(1)) {
+                                if (flag === "p")
+                                    print = true;
+                                else if (flag === "l")
+                                    list = true;
+                                else {
+                                    await context.stderr.write(new TextEncoder().encode(`trap: -${flag}: invalid option\ntrap: usage: trap [-lp] [arg signal_spec ...]\n`));
+                                    return 2;
+                                }
+                            }
+                        }
+                        if (list) {
+                            const signals = [...names].filter(([number]) => number > 0 && number < pseudoBase).sort(([left], [right]) => left - right);
+                            let output = "";
+                            for (const [index, [number, name]] of signals.entries())
+                                output += `${String(number).padStart(2, " ")}) ${name}${index % 4 === 3 ? "\n" : "\t"}`;
+                            if (!output.endsWith("\n"))
+                                output += "\n";
+                            await context.stdout.write(new TextEncoder().encode(output));
+                            return 0;
+                        }
+                        if (!args.length)
+                            print = true;
+                        let action;
+                        const first = args[0];
+                        const numericReset = !!first && [...first].every(character => character >= "0" && character <= "9");
+                        if (!print && args.length > 1 && !numericReset) {
+                            action = context.argumentValues[context.args.length - args.length];
+                            args.shift();
+                        }
+                        if (!print && args.length === 1 && args[0] === "-") {
+                            await context.stderr.write(new TextEncoder().encode("trap: usage: trap [-lp] [arg signal_spec ...]\n"));
+                            return 2;
+                        }
+                        if (action !== undefined && shellValueText(action) !== "-")
+                            context.accountSource(action);
+                        const targets = args.length ? args : [...actions.keys()].sort((left, right) => left - right).map(String);
+                        let status = 0;
+                        for (const target of targets) {
+                            const number = resolve(target);
+                            if (number === undefined) {
+                                await context.diagnostic(`trap: ${target}: invalid signal specification`);
+                                status = 1;
+                                continue;
+                            }
+                            if (print) {
+                                const current = actions.get(number);
+                                if (current)
+                                    await context.stdout.write(Buffer.concat([Buffer.from("trap -- "), quote(current.source), Buffer.from(` ${names.get(number)}\n`)]));
+                            }
+                            else if (inheritedIgnored.has(number))
+                                continue;
+                            else if (action === undefined || shellValueText(action) === "-")
+                                actions.delete(number);
+                            else
+                                actions.set(number, { source: action, active: true });
+                        }
+                        return status;
+                    },
+                }],
+            fork(scope) {
+                const inherited = new Map();
+                for (const [number, action] of actions) {
+                    if (scope === "process") {
+                        if (number > 0 && number < pseudoBase && !shellValueByteLength(action.source))
+                            inherited.set(number, action);
+                    }
+                    else
+                        inherited.set(number, { source: action.source, active: !shellValueByteLength(action.source) || names.get(number) === "ERR" && options[0].enabled || ["DEBUG", "RETURN"].includes(names.get(number)) && options[1].enabled });
+                }
+                return instance(inherited, scope !== "process" && options[0].enabled, scope !== "process" && options[1].enabled, scope === "process" ? new Set(inherited.keys()) : inheritedIgnored, scope !== "process" && extendedDebug);
+            },
+            async event(event, context) {
+                if (event === "function-enter") {
+                    functions.push(new Map(actions));
+                    return;
+                }
+                if (event === "function-leave") {
+                    functions.pop();
+                    return;
+                }
+                if (event === "source-enter") {
+                    sources.push(actions.get(aliases.get("DEBUG")));
+                    return;
+                }
+                if (event === "source-leave") {
+                    const previous = sources.pop();
+                    if (previous && !actions.has(aliases.get("DEBUG")))
+                        actions.set(aliases.get("DEBUG"), previous);
+                    return;
+                }
+                for (const number of pending) {
+                    if (running.has(number))
+                        continue;
+                    pending.delete(number);
+                    await run(number, context);
+                }
+                const name = event === "exit" ? "EXIT" : event === "error" ? "ERR" : event === "command" ? "DEBUG" : "RETURN";
+                if (name === "DEBUG" && context.sourceDepth > 0 && sources.at(-1) === actions.get(aliases.get(name)) && !options[1].enabled)
+                    return;
+                const inherited = functions.at(-1)?.get(aliases.get(name)) === actions.get(aliases.get(name));
+                if (context.functionDepth > 0 && inherited && (name === "ERR" && !options[0].enabled || (name === "DEBUG" || name === "RETURN") && !options[1].enabled))
+                    return;
+                const status = await run(aliases.get(name), context);
+                if (name === "DEBUG" && extendedDebug && status)
+                    return status === 2 && (context.functionDepth > 0 || context.sourceDepth > 0) ? { action: "return", status } : { action: "skip" };
+            },
+        };
+    }
+    return { name: "trap", runtimeIdentity: commandRuntimeIdentity, create: () => instance() };
+}

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

@@ -0,0 +1,5 @@
+export { codeOf, output, pathOf } from "./commands/internal.js";
+export { compareCopyIdentity, compareObservedEntries } from "./commands/copy-identity.js";
+export type { PreparedShellChild, ShellBindingReference, ShellBindingResult, ShellChildPreparation, ShellExecutionCheckpoint, ShellExtension, ShellExtensionBuiltin, ShellExtensionContext, ShellExtensionEvent, ShellExtensionInstance, ShellExtensionOption, ShellExtensionScope, ShellIndexedWriter, ShellInputBorrow, ShellInputObserver, ShellListTerminatorContext, ShellListTerminatorHook, ShellSpecialParameterHook, } from "./shell/extensions.js";
+export type { RawRecord, ReadLine } from "./shell/input.js";
+//# sourceMappingURL=optional-host.d.ts.map

package/dist/safe-bash/optional-host.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"optional-host.d.ts","sourceRoot":"","sources":["../src/optional-host.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAChE,OAAO,EAAE,mBAAmB,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAC;AAC1F,YAAY,EACV,kBAAkB,EAClB,qBAAqB,EACrB,kBAAkB,EAClB,qBAAqB,EACrB,wBAAwB,EACxB,cAAc,EACd,qBAAqB,EACrB,qBAAqB,EACrB,mBAAmB,EACnB,sBAAsB,EACtB,oBAAoB,EACpB,mBAAmB,EACnB,kBAAkB,EAClB,gBAAgB,EAChB,kBAAkB,EAClB,0BAA0B,EAC1B,uBAAuB,EACvB,yBAAyB,GAC1B,MAAM,uBAAuB,CAAC;AAC/B,YAAY,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC"}

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

@@ -0,0 +1,3 @@
+export { codeOf, output, pathOf } from "./commands/internal.js";
+export { compareCopyIdentity, compareObservedEntries } from "./commands/copy-identity.js";
+//# sourceMappingURL=optional-host.js.map

package/dist/safe-bash/optional-host.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"optional-host.js","sourceRoot":"","sources":["../src/optional-host.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAChE,OAAO,EAAE,mBAAmB,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAC"}

package/dist/safe-bash/shell/arrays/bindings.d.ts

@@ -1,18 +1,18 @@
 import { Admission, ArrayOwner } from "./ledger.js";
 import type { Tickets } from "./ledger.js";
-import { type ShellValue } from "../../contracts/value.js";
+import type { ShellValue } from "../../contracts/value.js";
 export declare const controlNames: ReadonlySet<string>;
 export declare class OwnedText {
-    readonly value: string;
+    readonly shellValue: ShellValue;
     readonly bytes: number;
     readonly admission: Admission;
-    readonly rawValue?: ShellValue | undefined;
     references: number;
-    constructor(value: string, bytes: number, admission: Admission, rawValue?: ShellValue | undefined);
+    constructor(shellValue: ShellValue, bytes: number, admission: Admission);
+    get value(): string;
     retain(): this;
     release(): void;
 }
-export declare function textToken(owner: ArrayOwner, value: string, signal: AbortSignal): Promise<OwnedText>;
+export declare function textToken(owner: ArrayOwner, value: ShellValue, signal: AbortSignal): Promise<OwnedText>;
 export declare function valueToken(owner: ArrayOwner, value: ShellValue, signal: AbortSignal): Promise<OwnedText>;
 export interface Element {
     readonly text: OwnedText;
@@ -39,6 +39,7 @@ export declare class IndexedBinding {
     keyIndex(value: ShellValue, owner: ArrayOwner, signal: AbortSignal, create?: boolean): Promise<number | undefined>;
     remove(index: number): void;
     get(index: number): string | undefined;
+    getValue(index: number): ShellValue | undefined;
     retain(): this;
     release(): Promise<void> | undefined;
     insert(index: number, text: OwnedText): void;
@@ -71,6 +72,13 @@ interface NamedBinding {
     readonly name: OwnedText;
     readonly admission: Admission;
 }
+export interface PreparedBinding {
+    readonly binding: IndexedBinding;
+    readonly tickets: Tickets;
+    validate(): void;
+    publish(): Promise<void> | undefined;
+    close(): Promise<void>;
+}
 export declare class BindingStore {
     owner: ArrayOwner;
     readonly bindings: Map<string, NamedBinding>;
@@ -79,6 +87,7 @@ export declare class BindingStore {
     private constructor();
     static create(parent: ArrayOwner): BindingStore;
     get(name: string): IndexedBinding | undefined;
+    prepare(name: string, signal: AbortSignal, copy?: boolean): Promise<PreparedBinding>;
     watch(name: string, operation: ArrayOwner, signal: AbortSignal, owner?: ArrayOwner): Promise<BindingWatch>;
     retire(name: string, watch: Watch): void;
     tickets(name?: string): Admission;
@@ -91,6 +100,7 @@ export declare class BindingStore {
         readonly name: OwnedText;
         readonly admission: Admission;
     }, restoring?: boolean, owner?: ArrayOwner): Promise<void> | undefined;
+    revise(name: string, binding: IndexedBinding, tickets: Tickets): void;
     remove(name: string, tickets: Tickets): Promise<void> | undefined;
 }
 export {};