@poe-platform/safe-bash 0.1.799 → 0.1.801

package/dist/safe-bash/commands/pdfinfo/index.js

@@ -1,5 +1,6 @@
+import { createPdftocairoCommand as createRawPdftocairoCommand } from "../../../safe-bash-command-pdftoppm/index.js";
 import { builtInDirectContextExecutors, syncCommandEvaluators } from "../internal.js";
-import { createPdfinfoCommand as createRawPdfinfoCommand, createPdfinfoCommands as createRawPdfinfoCommands, createPdffontsCommand as createRawPdffontsCommand, createPdfdetachCommand as createRawPdfdetachCommand, createPdftocairoCommand as createRawPdftocairoCommand, inspectPdfBytes, runPdffontsCliSync, runPdfdetachCliSync, } from "../../../safe-bash-command-pdfinfo/index.js";
+import { createPdfinfoCommand as createRawPdfinfoCommand, createPdfinfoCommands as createRawPdfinfoCommands, createPdffontsCommand as createRawPdffontsCommand, createPdfdetachCommand as createRawPdfdetachCommand, inspectPdfBytes, runPdffontsCliSync, runPdfdetachCliSync, } from "../../../safe-bash-command-pdfinfo/index.js";
 export * from "../../../safe-bash-command-pdfinfo/index.js";
 export function createPdfinfoCommand(options = {}) {
     syncCommandEvaluators.evalSyncPdfinfo = evalSyncPdfinfo;

package/dist/safe-bash/commands/pr/index.browser.js

@@ -3,8 +3,8 @@ import {
   createPrCommands,
   evalSyncPr,
   prCommands
-} from "../../chunks/chunk-F3RV2F72.js";
-import "../../chunks/chunk-YG5WAHK7.js";
+} from "../../chunks/chunk-CHYGPFVM.js";
+import "../../chunks/chunk-B7TAL7S5.js";
 export {
   createPrCommand,
   createPrCommands,

package/dist/safe-bash/commands/predicates.js

@@ -123,10 +123,8 @@ export function tryFastPredicate(name, rawArgs, offset = 0, fileUnaryEval) {
             const t0 = rawArgs[cursor];
             if (t0 === "(" || t0 === ")")
                 return undefined;
-            if (cursor + 1 < end && binary.has(rawArgs[cursor + 1])) {
+            if (cursor + 2 < end && binary.has(rawArgs[cursor + 1])) {
                 const op = rawArgs[cursor + 1];
-                if (cursor + 2 >= end)
-                    return undefined;
                 const right = rawArgs[cursor + 2];
                 cursor += 3;
                 if (op === "=" || op === "==")
@@ -338,7 +336,8 @@ export function predicateCommands(identity = {}) {
             const leftLength = token === "-l" && numeric.has(args[offset + 1] ?? "");
             const left = leftLength ? args[offset++] : token;
             const operator = args[offset];
-            if (operator !== undefined && binary.has(operator)) {
+            // With only two tokens, an operator-looking operand belongs to the unary test.
+            if (offset + 1 < args.length && operator !== undefined && binary.has(operator)) {
                 offset++;
                 const rightLength = numeric.has(operator) && args[offset] === "-l";
                 if (rightLength)

package/dist/safe-bash/commands/python/host-capabilities.js

@@ -22,6 +22,7 @@ export function createPythonHostBridge(capabilities, options) {
     const pending = new Set();
     const streams = new Map();
     const jobs = new Map();
+    const activeCalls = new Set();
     const cleanupFailures = [];
     const jobWork = new Set();
     let nextJob = 1;
@@ -93,16 +94,17 @@ export function createPythonHostBridge(capabilities, options) {
         const stream = streams.get(handle);
         if (!stream)
             throw new Error('Unknown Python host stream');
-        streams.delete(handle);
-        if (cancel)
-            stream.controller.abort(new Error('Python host stream released'));
-        try {
-            await stream.iterator.return?.();
-        }
-        catch (error) {
-            cleanupFailures.push(error);
-            throw error;
+        if (!stream.closing) {
+            stream.closing = Promise.resolve().then(async () => {
+                if (cancel)
+                    stream.controller.abort(new Error('Python host stream released'));
+                await stream.iterator.return?.();
+                // Retained iterators consume admission until cleanup succeeds, including
+                // when a host ignores cancellation or its cleanup fails.
+                streams.delete(handle);
+            }).catch(error => { cleanupFailures.push(error); throw error; });
         }
+        await stream.closing;
     };
     const pull = async (handle) => {
         const stream = streams.get(handle);
@@ -140,6 +142,7 @@ export function createPythonHostBridge(capabilities, options) {
         const payload = data(incoming);
         if (!payload || Array.isArray(payload) || typeof payload !== 'object' || payload.version !== 1)
             throw new TypeError('Unsupported Python host protocol');
+        let reservation;
         const operation = Promise.resolve().then(async () => {
             assertLive();
             if (payload.operation === 'poll' || payload.operation === 'cancel') {
@@ -151,23 +154,29 @@ export function createPythonHostBridge(capabilities, options) {
                     throw new Error('Unknown Python host job');
                 if (payload.operation === 'cancel') {
                     jobs.delete(handle);
+                    if (job.settled)
+                        activeCalls.delete(job.reservation);
                     job.controller.abort(new Error('Python guest cancelled host operation'));
                     return null;
                 }
                 if (job.result === undefined && !job.failed)
                     return { done: false };
                 jobs.delete(handle);
+                if (job.settled)
+                    activeCalls.delete(job.reservation);
                 return job.failed ? { done: true, error: 'Python host operation failed', errorCode: job.failed } : { done: true, value: job.result };
             }
-            if (Math.max(jobWork.size, jobs.size) >= maxConcurrentCalls)
+            if (activeCalls.size >= maxConcurrentCalls)
                 throw new Error('Python host call concurrency limit exceeded');
+            reservation = {};
+            activeCalls.add(reservation);
             if (payload.operation === 'begin' || payload.operation === 'begin-next') {
                 let work;
                 let child;
                 let reservedStream;
                 if (payload.operation === 'begin-next') {
                     const stream = typeof payload.handle === 'number' ? streams.get(payload.handle) : undefined;
-                    if (!stream || stream.busy)
+                    if (!stream || stream.busy || stream.closing)
                         throw new Error('Unknown or busy Python host stream');
                     reservedStream = stream;
                     stream.busy = true;
@@ -182,8 +191,10 @@ export function createPythonHostBridge(capabilities, options) {
                     work = childSignal => capability.call(payload.value ?? null, { signal: childSignal });
                 }
                 const handle = nextJob++;
-                const job = { controller: child };
+                const job = { controller: child, reservation, settled: false };
                 jobs.set(handle, job);
+                // Transfer admission to the job until both host work and guest ownership end.
+                reservation = undefined;
                 const task = Promise.resolve().then(() => {
                     const childSignal = AbortSignal.any([signal, child.signal]);
                     childSignal.throwIfAborted();
@@ -193,6 +204,9 @@ export function createPythonHostBridge(capabilities, options) {
                     child.signal.throwIfAborted();
                     job.result = data(value);
                 }).catch(error => { job.failed = pythonHostFailureCode(error); }).finally(() => {
+                    job.settled = true;
+                    if (!jobs.has(handle))
+                        activeCalls.delete(job.reservation);
                     if (reservedStream)
                         reservedStream.busy = false;
                     jobWork.delete(task);
@@ -207,8 +221,8 @@ export function createPythonHostBridge(capabilities, options) {
                 const stream = streams.get(handle);
                 if (!stream)
                     throw new Error('Unknown Python host stream');
-                if (stream.busy)
-                    throw new Error('Python host stream already pulling');
+                if (stream.busy || stream.closing)
+                    throw new Error('Python host stream already pulling or closing');
                 if (payload.operation === 'release') {
                     await release(handle);
                     return null;
@@ -248,6 +262,8 @@ export function createPythonHostBridge(capabilities, options) {
         }
         finally {
             pending.delete(operation);
+            if (reservation)
+                activeCalls.delete(reservation);
         }
     };
     const close = () => {
@@ -260,6 +276,7 @@ export function createPythonHostBridge(capabilities, options) {
                 job.controller.abort(controller.signal.reason);
             await Promise.allSettled([...pending, ...jobWork]);
             jobs.clear();
+            activeCalls.clear();
             const results = await Promise.allSettled([...streams.keys()].map(handle => release(handle)));
             registry.clear();
             for (const result of results)

package/dist/safe-bash/commands/python/index.browser.js

@@ -16,20 +16,20 @@ import {
   pythonCommands,
   pythonDocumentPackages,
   pythonHostFailureCode
-} from "../../chunks/chunk-6IBTC4YL.js";
-import "../../chunks/chunk-KCVSVD65.js";
-import "../../chunks/chunk-KMH2DF3I.js";
-import "../../chunks/chunk-IUTD5FH5.js";
-import "../../chunks/chunk-VYZTG3GV.js";
-import "../../chunks/chunk-LQHGH25W.js";
-import "../../chunks/chunk-PYVEAFJM.js";
+} from "../../chunks/chunk-VQDD3G76.js";
+import "../../chunks/chunk-I5HZ4FGE.js";
+import "../../chunks/chunk-ICFDYV64.js";
+import "../../chunks/chunk-VTH3MLDU.js";
+import "../../chunks/chunk-NZQXYWA3.js";
+import "../../chunks/chunk-74GHTNJA.js";
+import "../../chunks/chunk-7R5BDCG7.js";
 import {
   PythonFailure,
   inspectPythonCapabilities
-} from "../../chunks/chunk-63FXVDGF.js";
-import "../../chunks/chunk-KV7PKOHV.js";
-import "../../chunks/chunk-ENR3HB2B.js";
-import "../../chunks/chunk-YG5WAHK7.js";
+} from "../../chunks/chunk-LVOBFF4D.js";
+import "../../chunks/chunk-IWDICZVK.js";
+import "../../chunks/chunk-E7OYNDGL.js";
+import "../../chunks/chunk-B7TAL7S5.js";
 export {
   PythonFailure,
   PythonPackageConflictError,

package/dist/safe-bash/commands/python/llm-capability.d.ts

@@ -8,6 +8,7 @@ type PythonLlmContext = Pick<CommandContext, 'fs' | 'cwd' | 'inputBudget'> & Par
 export interface PythonLlmCapabilityOptions {
     readonly maxStreamChunkBytes?: number;
     readonly maxBufferedResponseBytes?: number;
+    readonly maxBufferedInputBytes?: number;
     readonly maxBufferedEvents?: number;
     readonly maxMetadataBytes?: number;
     readonly templateLoaders?: ReadonlyMap<string, LlmTemplateLoader>;

package/dist/safe-bash/commands/python/llm-capability.js

@@ -1,4 +1,4 @@
-import { selectLlmModelByQuery, getLlmModelAliases, createLlmConfiguration, createLlmTemplateStore, evaluateLlmTemplate, findExtractedRange, llmTemplateUsesInput, validateLlmTemplateParameters } from "../../../safe-bash-command-llm/index.js";
+import { loadLlmStoredSchema, selectLlmModelByQuery, getLlmModelAliases, createLlmConfiguration, createLlmTemplateStore, evaluateLlmTemplate, findExtractedRange, llmTemplateUsesInput, validateLlmTemplateParameters } from "../../../safe-bash-command-llm/index.js";
 import { sniffMimeType } from '../llm/mime.js';
 import { pathOf } from '../internal.js';
 function record(value) {
@@ -24,20 +24,20 @@ function configurationContext(context, payload, signal) {
     return { fs: context.fs, cwd, env, signal, ...(context.capabilities ? { capabilities: context.capabilities } : {}), ...(context.fetch ? { fetch: context.fetch } : {}) };
 }
 /** Count the wire representation before retaining/serializing host metadata. */
-function jsonBytes(value, limit) {
+function jsonBytes(value, limit, subject = 'response') {
     if (limit === Infinity)
         return 0;
     let bytes = 0;
     const ancestors = new Set();
     const add = (size) => {
         if (size > limit - bytes)
-            throw new RangeError('Python LLM serialized response limit exceeded');
+            throw new RangeError(`Python LLM serialized ${subject} limit exceeded`);
         bytes += size;
     };
     const string = (text) => {
         add(2);
         if (text.length > limit - bytes)
-            throw new RangeError('Python LLM serialized response limit exceeded');
+            throw new RangeError(`Python LLM serialized ${subject} limit exceeded`);
         for (let i = 0; i < text.length; i++) {
             const point = text.codePointAt(i);
             if (point > 65535) {
@@ -70,7 +70,7 @@ function jsonBytes(value, limit) {
         let entries = 0;
         if (Array.isArray(item)) {
             if (item.length > limit - bytes)
-                throw new RangeError('Python LLM serialized response limit exceeded');
+                throw new RangeError(`Python LLM serialized ${subject} limit exceeded`);
             for (let i = 0; i < item.length; i++) {
                 const descriptor = Object.getOwnPropertyDescriptor(item, String(i));
                 if (!descriptor || !('value' in descriptor))
@@ -123,18 +123,20 @@ export function createPythonLlmCapability(context, service, options = {}) {
     if (!Number.isSafeInteger(chunkBytes) || chunkBytes < 1)
         throw new RangeError('Invalid Python LLM stream chunk limit');
     const bufferedLimit = options.maxBufferedResponseBytes ?? Infinity;
+    const bufferedInputLimit = options.maxBufferedInputBytes ?? Infinity;
     const eventLimit = options.maxBufferedEvents ?? bufferedLimit;
     const metadataLimit = options.maxMetadataBytes ?? bufferedLimit;
     const maxRemoteBytes = options.maxRemoteTemplateBytes ?? (context.inputBudget?.maxBytes === Infinity ? undefined : context.inputBudget?.maxBytes) ?? 1_048_576;
     if (!Number.isSafeInteger(maxRemoteBytes) || maxRemoteBytes < 1)
         throw new RangeError('Invalid Python LLM remote template limit');
-    const templateLoaderOptions = { maxRemoteBytes, ...(options.templateLoaders ? { loaders: options.templateLoaders } : {}) };
-    for (const limit of [bufferedLimit, eventLimit, metadataLimit]) {
+    const templateLoaderOptions = { maxRemoteBytes: Math.min(maxRemoteBytes, bufferedInputLimit), ...(options.templateLoaders ? { loaders: options.templateLoaders } : {}) };
+    for (const limit of [bufferedInputLimit, bufferedLimit, eventLimit, metadataLimit]) {
         if (limit !== Infinity && (!Number.isSafeInteger(limit) || limit < 1))
             throw new RangeError('Invalid Python LLM host limit');
     }
     const prepare = async (value, signal) => {
         let payload = record(value);
+        jsonBytes(payload, bufferedInputLimit, 'input');
         const timeout = payload.timeout;
         if (timeout !== undefined && timeout !== null) {
             if (typeof timeout !== 'number' || !Number.isFinite(timeout) || timeout <= 0 || timeout * 1000 > 2147483647)
@@ -188,6 +190,7 @@ export function createPythonLlmCapability(context, service, options = {}) {
         const identity = selected === undefined ? undefined : await configuration.resolveAlias(selected);
         const { model } = service.resolve(identity);
         payload = { ...payload, model: model.id, options: { ...await configuration.modelOptions(model.id), ...record(payload.options ?? {}) } };
+        jsonBytes(payload, bufferedInputLimit, 'input');
         signal.throwIfAborted();
         if (payload.extract !== undefined && typeof payload.extract !== 'boolean' || payload.extract_last !== undefined && typeof payload.extract_last !== 'boolean')
             throw new TypeError('Invalid LLM extract option');
@@ -343,6 +346,23 @@ export function createPythonLlmCapability(context, service, options = {}) {
             signal.throwIfAborted();
             const operation = record(value);
             const payload = record(operation.payload ?? {});
+            jsonBytes(payload, bufferedInputLimit, 'input');
+            if (operation.operation === 'load_schema') {
+                const id = payload.schema_id;
+                if (typeof id !== 'string' || !id || id.includes('\0'))
+                    throw new TypeError('Stored schema ID must be a nonempty string');
+                const database = payload.database;
+                if (database !== undefined && (typeof database !== 'string' || !database || database.includes('\0')))
+                    throw new TypeError('Schema database must be a nonempty canonical path');
+                let admitted = 0;
+                const result = await loadLlmStoredSchema(configurationContext(context, payload, signal), id, {
+                    ...(database === undefined ? {} : { database: database }),
+                    maxBytes: Math.min(bufferedInputLimit, bufferedLimit, context.inputBudget?.maxBytes ?? Infinity),
+                    admitBytes(size) { admitted += size; context.inputBudget?.check(admitted); },
+                }) ?? null;
+                jsonBytes(result, bufferedLimit);
+                return result;
+            }
             if (operation.operation === 'select_model') {
                 const queries = payload.queries;
                 if (!Array.isArray(queries) || !queries.length || queries.some(query => typeof query !== 'string'))

package/dist/safe-bash/commands/python/llm-module.js

@@ -392,6 +392,17 @@ class Client:
         payload = {**_configuration_context(), "queries": list(queries)}
         return await self._run(lambda: self._bridge.call("select_model", payload), self._timeout)
 
+    async def load_schema(self, schema_id: str, *, database: str | None = None) -> dict | None:
+        if not isinstance(schema_id, str) or not schema_id or "\\0" in schema_id:
+            raise TypeError("Stored schema ID must be a nonempty string")
+        if database is not None and (not isinstance(database, str) or not database or "\\0" in database):
+            raise TypeError("Schema database must be a nonempty canonical path")
+        payload = {**_configuration_context(), "schema_id": schema_id}
+        if database is not None:
+            payload["database"] = database
+        value = await self._run(lambda: self._bridge.call("load_schema", payload), self._timeout)
+        return copy.deepcopy(value)
+
     async def models(self):
         values = await self._run(lambda: self._bridge.call("models", _configuration_context()), self._timeout)
         return tuple(Model(id=value["id"], aliases=tuple(value.get("aliases", ())),

package/dist/safe-bash/commands/python/manifest.d.ts

@@ -17,6 +17,8 @@ export declare class PythonPackageConflictError extends Error {
 }
 export declare function createPythonPackageManifestStore(options?: {
     readonly maxBytes?: number;
+    readonly maxEntries?: number;
+    readonly maxScopeLength?: number;
 }): PythonPackageManifestStore & {
     dispose(): void;
 };

package/dist/safe-bash/commands/python/manifest.js

@@ -7,19 +7,26 @@ export class PythonPackageConflictError extends Error {
     }
 }
 export function createPythonPackageManifestStore(options = {}) {
-    const maxBytes = options.maxBytes ?? 1048576;
-    if (!Number.isSafeInteger(maxBytes) || maxBytes < 1)
-        throw new RangeError('Python manifest maxBytes must be a positive integer');
+    const maxBytes = options.maxBytes ?? Infinity;
+    const maxEntries = options.maxEntries ?? Infinity;
+    const maxScopeLength = options.maxScopeLength ?? Infinity;
+    for (const [name, value] of Object.entries({ maxBytes, maxEntries, maxScopeLength })) {
+        if (value !== Infinity && (!Number.isSafeInteger(value) || value < 1)) {
+            throw new RangeError(`Python manifest ${name} must be a positive safe integer or Infinity`);
+        }
+    }
     const manifests = new Map();
     let retainedBytes = 0;
-    let revision = 0;
+    let revision = 0n;
     let disposed = false;
     const check = (scope, signal) => {
         signal.throwIfAborted();
         if (disposed)
             throw new Error('Python manifest store is disposed');
-        if (typeof scope !== 'string' || !scope || scope.length > 1024)
+        if (typeof scope !== 'string' || !scope)
             throw new TypeError('Invalid Python manifest scope');
+        if (scope.length > maxScopeLength)
+            throw new RangeError('Python manifest scope budget exhausted');
     };
     return {
         async get(scope, { signal }) {
@@ -35,7 +42,7 @@ export function createPythonPackageManifestStore(options = {}) {
             if (!(bytes instanceof Uint8Array))
                 throw new TypeError('Python manifest must contain bytes');
             const nextBytes = retainedBytes - (current?.bytes.length ?? 0) + bytes.length;
-            if (nextBytes > maxBytes || (!current && manifests.size >= 1024) || revision >= Number.MAX_SAFE_INTEGER) {
+            if (nextBytes > maxBytes || (!current && manifests.size >= maxEntries)) {
                 throw new RangeError('Python manifest store budget exhausted');
             }
             manifests.set(scope, { revision: String(++revision), bytes: Uint8Array.from(bytes) });

package/dist/safe-bash/commands/python/provisioning.js

@@ -29,7 +29,7 @@ function checkSession(session) {
 export function createPythonPackageEnvironment(options = {}) {
     if (options.cache && options.cacheDirectory)
         throw new TypeError('Choose package cache or cacheDirectory, not both');
-    if (options.manifestStore && (typeof options.scope !== 'string' || !options.scope.trim() || options.scope.length > 1024))
+    if (options.manifestStore && (typeof options.scope !== 'string' || !options.scope.trim()))
         throw new TypeError('Shared Python manifests require an explicit nonempty scope');
     if (options.scope !== undefined && !options.manifestStore)
         throw new TypeError('Python scope requires a manifestStore');

package/dist/safe-bash/commands/python/shell-capability.d.ts

@@ -5,6 +5,7 @@ export declare function pythonShellDispatchActive(scope: object | undefined): bo
 export declare function createPythonShellCapability(context: CommandContext, options?: {
     readonly maxInputBytes?: number;
     readonly maxOutputBytes?: number;
+    readonly maxBufferedOutputBytes?: number;
     readonly maxConcurrentCalls?: number;
     readonly maxStreamChunkBytes?: number;
 }): PythonHostCapability;

package/dist/safe-bash/commands/python/shell-capability.js

@@ -8,8 +8,9 @@ export function createPythonShellCapability(context, options = {}) {
         throw new TypeError('Python shell capability requires a parent shell invocation');
     const maxInputBytes = options.maxInputBytes ?? Infinity;
     const maxOutputBytes = options.maxOutputBytes ?? Infinity;
+    const maxBufferedOutputBytes = options.maxBufferedOutputBytes ?? Infinity;
     const maxConcurrentCalls = options.maxConcurrentCalls ?? Infinity;
-    for (const limit of [maxInputBytes, maxOutputBytes, maxConcurrentCalls])
+    for (const limit of [maxInputBytes, maxOutputBytes, maxBufferedOutputBytes, maxConcurrentCalls])
         if (limit !== Infinity && (!Number.isSafeInteger(limit) || limit < 1))
             throw new RangeError('Invalid Python shell limit');
     const chunkBytes = options.maxStreamChunkBytes ?? 16384;
@@ -28,7 +29,7 @@ export function createPythonShellCapability(context, options = {}) {
         const requestedOutput = request.maxOutputBytes;
         if (requestedOutput !== undefined && (typeof requestedOutput !== 'number' || requestedOutput !== Infinity && (!Number.isSafeInteger(requestedOutput) || requestedOutput < 0)))
             throw new RangeError('Invalid Python shell output limit');
-        const outputLimit = Math.min(maxOutputBytes, typeof requestedOutput === 'number' ? requestedOutput : maxOutputBytes);
+        const outputLimit = Math.min(maxOutputBytes, publish ? Infinity : maxBufferedOutputBytes, typeof requestedOutput === 'number' ? requestedOutput : Infinity);
         const timeoutMs = request.timeoutMs;
         if (timeoutMs !== undefined && (typeof timeoutMs !== 'number' || !Number.isSafeInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > 2147483647))
             throw new RangeError('Invalid Python shell timeout');

package/dist/safe-bash/commands/python/worker.browser.js

@@ -8,11 +8,11 @@ import {
   pythonRuntimeRelocation,
   pythonStatProjection,
   pythonTreeCleanup
-} from "../../chunks/chunk-63FXVDGF.js";
-import "../../chunks/chunk-KV7PKOHV.js";
+} from "../../chunks/chunk-LVOBFF4D.js";
+import "../../chunks/chunk-IWDICZVK.js";
 import {
   init_platform
-} from "../../chunks/chunk-YG5WAHK7.js";
+} from "../../chunks/chunk-B7TAL7S5.js";
 
 // packages/safe-bash/src/commands/python/worker.ts
 init_platform();

package/dist/safe-bash/commands/regex-execution/matching.js

@@ -1,6 +1,5 @@
 import { decodeBytes, encodeBytes } from "../../byte-encoding.js";
 import { PublicDiagnostic } from "../../public-diagnostic.js";
-import { isAscii } from "node:buffer";
 import { matchRangeLimits } from "./protocol.js";
 class SearchError extends PublicDiagnostic {
 }
@@ -102,7 +101,7 @@ class SearchMatcher {
                 throw new SearchError("matches per line limit exceeded");
             return Array.from({ length }, (_value, offset) => ({ start: offset, end: offset }));
         }
-        const { text, offsets, invalid } = isAscii(bytes) ? { text: decodeBytes(encodeBytes(bytes), "ascii"), offsets: undefined, invalid: [] } : decode(bytes);
+        const { text, offsets, invalid } = bytes.every(byte => byte < 128) ? { text: decodeBytes(encodeBytes(bytes), "ascii"), offsets: undefined, invalid: [] } : decode(bytes);
         const matches = [];
         let previousEnd = -1;
         let fragmentStart = 0;

package/dist/safe-bash/commands/regex-execution/public.browser.js

@@ -1,11 +1,6 @@
 import {
   RegexExecutionError
-} from "../../chunks/chunk-KHMGTPD6.js";
-import {
-  RegexExecutor,
-  RegexSession,
-  createBoundedRegexProvider
-} from "../../chunks/chunk-6HZYFL3H.js";
+} from "../../chunks/chunk-46Z5E5EV.js";
 import {
   EreLedger,
   EreProfileLimitError,
@@ -14,8 +9,13 @@ import {
   EreUsageUnknownError,
   compileEre,
   matchEre
-} from "../../chunks/chunk-XB3B7KMM.js";
-import "../../chunks/chunk-YG5WAHK7.js";
+} from "../../chunks/chunk-6O77NL2S.js";
+import {
+  RegexExecutor,
+  RegexSession,
+  createBoundedRegexProvider
+} from "../../chunks/chunk-NR3EM4LS.js";
+import "../../chunks/chunk-B7TAL7S5.js";
 export {
   EreLedger,
   EreProfileLimitError,

package/dist/safe-bash/commands/safejs/runtime.js

@@ -210,13 +210,22 @@ export function createSafeJsCommands(options, dialect) {
                                 }
                             },
                         });
-                        const result = record(await withSignal(signal, () => runtime.run(prepared?.source ?? source, {
-                            ...(parsed.nodeOptions?.length ? { nodeOptions: parsed.nodeOptions } : {}),
-                            budget, filename, modules, signal, ...(prepared ? { bindings: prepared.bindings,
-                                ...(prepared.sourceLocation ? { sourceLocation: prepared.sourceLocation } : {}),
-                                ...(prepared.importSpecifiers ? { importSpecifiers: prepared.importSpecifiers } : {}) } : {}),
-                            sink: { log: (...args) => output.console(args, false), error: (...args) => output.console(args, true) },
-                        })), "SafeJS run result");
+                        let rawResult;
+                        try {
+                            rawResult = await withSignal(signal, () => runtime.run(prepared?.source ?? source, {
+                                ...(parsed.nodeOptions?.length ? { nodeOptions: parsed.nodeOptions } : {}),
+                                budget, filename, modules, signal, ...(prepared ? { bindings: prepared.bindings,
+                                    ...(prepared.sourceLocation ? { sourceLocation: prepared.sourceLocation } : {}),
+                                    ...(prepared.importSpecifiers ? { importSpecifiers: prepared.importSpecifiers } : {}) } : {}),
+                                sink: { log: (...args) => output.console(args, false), error: (...args) => output.console(args, true) },
+                            }));
+                        }
+                        catch (error) {
+                            if (error instanceof SafeJsCommandLimitError || statusField(error, "code") === "budgetExceeded" || signal.aborted)
+                                throw error;
+                            throw new GuestDiagnostic(errorInfo(error));
+                        }
+                        const result = record(rawResult, "SafeJS run result");
                         signal.throwIfAborted();
                         if (result.ok !== true && result.ok !== false)
                             throw new TypeError("Invalid SafeJS run result.ok");

package/dist/safe-bash/commands/search/index.d.ts

@@ -3,5 +3,5 @@ import type { SearchOptions } from "./options.js";
 export type { SearchOptions } from "./options.js";
 export declare function createSearchCommands(options?: SearchOptions): readonly CommandDefinition[];
 export declare function searchCommands(options?: SearchOptions): VirtualShellPlugin;
-export declare function evalSyncRg(stdinBytes: Uint8Array | undefined, args: readonly string[], readFile?: (path: string) => Uint8Array | undefined, allowNullBytes?: boolean): string | undefined;
+export { evalSyncRg } from "../../../safe-bash-command-rg/index.js";
 //# sourceMappingURL=index.d.ts.map