@poe-platform/safe-bash 0.1.745 → 0.1.747

package/dist/safe-bash/chunks/{chunk-WCNFCN2G.js → chunk-BS6QFRNX.js}

@@ -12,7 +12,7 @@ import {
 import {
   Interpreter,
   parse
-} from "./chunk-IZZ7KX4E.js";
+} from "./chunk-JCXAGOEK.js";
 import {
   Budget,
   Decimal,
@@ -2879,4 +2879,4 @@ export {
   createYqCommands,
   yqCommands
 };
-//# sourceMappingURL=chunk-WCNFCN2G.js.map
+//# sourceMappingURL=chunk-BS6QFRNX.js.map

package/dist/safe-bash/chunks/{chunk-IZZ7KX4E.js → chunk-JCXAGOEK.js}

@@ -3849,8 +3849,38 @@ var Interpreter = class _Interpreter {
       }
       return;
     }
-    if (name === "indices") {
-      for await (const value of this.run(args[0], input)) yield await indices(input, value, budget);
+    if (name === "indices" || name === "index" || name === "rindex") {
+      for await (const value of this.run(args[0], input)) {
+        const found = await indices(input, value, budget);
+        if (name === "indices") yield found;
+        else yield indexValue(found, name === "index" ? 0 : -1);
+      }
+      return;
+    }
+    if (name === "floor" || name === "ceil" || name === "round" || name === "abs") {
+      if (!isNumber(input)) throw new JqError(`${describe(input, budget)} cannot be ${name}ed`);
+      budget.step();
+      const n = numberValue(input);
+      yield name === "floor" ? Math.floor(n) : name === "ceil" ? Math.ceil(n) : name === "round" ? Math.round(n) : Math.abs(n);
+      return;
+    }
+    if (name === "implode") {
+      if (!Array.isArray(input)) throw new JqError("implode input must be an array");
+      let out = "";
+      for (let i = 0; i < input.length; i++) {
+        {
+          const _p = budget.tickSync();
+          if (_p) await _p;
+        }
+        const el = input[i];
+        const cp = isNumber(el) ? numberValue(el) : NaN;
+        if (!Number.isInteger(cp) || cp < 0 || cp > 1114111) {
+          throw new JqError("implode elements must be Unicode codepoints");
+        }
+        out += String.fromCodePoint(cp);
+      }
+      budget.value(out);
+      yield out;
       return;
     }
     if (["startswith", "endswith", "ltrimstr", "rtrimstr"].includes(name)) {
@@ -4459,7 +4489,14 @@ var precedence = Object.freeze({
 var functions = Object.freeze({
   walk: [1],
   explode: [0],
+  implode: [0],
   utf8bytelength: [0],
+  floor: [0],
+  ceil: [0],
+  round: [0],
+  abs: [0],
+  index: [1],
+  rindex: [1],
   while: [2],
   until: [2],
   fromdateiso8601: [0],
@@ -5107,4 +5144,4 @@ export {
   moduleProgram,
   parse
 };
-//# sourceMappingURL=chunk-IZZ7KX4E.js.map
+//# sourceMappingURL=chunk-JCXAGOEK.js.map

package/dist/safe-bash/chunks/{chunk-I3DOFJSJ.js → chunk-MUWJPSGN.js}

@@ -1438,8 +1438,8 @@ function settings2(options) {
     if (value !== Infinity && (!Number.isSafeInteger(value) || value < 1)) throw new RangeError(`Invalid time-env limit: ${name}`);
   }
   const maxTimerMilliseconds = options.maxTimerMilliseconds ?? 2147483647;
-  if (!Number.isInteger(maxTimerMilliseconds) || maxTimerMilliseconds < 1 || maxTimerMilliseconds > 2147483647) {
-    throw new RangeError("maxTimerMilliseconds must be between1 and2147483647");
+  if (maxTimerMilliseconds !== Infinity && (!Number.isInteger(maxTimerMilliseconds) || maxTimerMilliseconds < 1 || maxTimerMilliseconds > 2147483647)) {
+    throw new RangeError("maxTimerMilliseconds must be between 1 and 2147483647 or Infinity");
   }
   const scheduler = options.scheduler ?? {
     now: () => performance.now(),

package/dist/safe-bash/chunks/{chunk-7RP6WOWK.js → chunk-OF2PDE3W.js}

@@ -11,7 +11,7 @@ import {
   tryProcessFlatJsonChunkSync,
   tryProcessFlatSelectProjectChunkSync,
   tryWriteCompactSync
-} from "./chunk-IZZ7KX4E.js";
+} from "./chunk-JCXAGOEK.js";
 import {
   Budget,
   JqError,
@@ -2530,4 +2530,4 @@ export {
   createXmlCommands,
   xmlCommands
 };
-//# sourceMappingURL=chunk-7RP6WOWK.js.map
+//# sourceMappingURL=chunk-OF2PDE3W.js.map

package/dist/safe-bash/chunks/{src-FTMTU65U.js → src-T672TQJC.js}

@@ -81,7 +81,7 @@ import {
   updateWorkbook,
   validSheetSize,
   visitFormula
-} from "./chunk-EAUCLWEZ.js";
+} from "./chunk-55AGFLG5.js";
 import "./chunk-CVAVQZSF.js";
 import "./chunk-RCM5PZBN.js";
 import "./chunk-LSRHLNCR.js";
@@ -171,4 +171,4 @@ export {
   validSheetSize,
   visitFormula
 };
-//# sourceMappingURL=src-FTMTU65U.js.map
+//# sourceMappingURL=src-T672TQJC.js.map

package/dist/safe-bash/command-chunks/{chunk-DRCPJVZF.js → chunk-44N2IRVP.js}

@@ -31,7 +31,7 @@ import {
   init_buffer
 } from "./chunk-OWQEVNXV.js";
 
-// packages/safe-bash-command-pandoc/dist/chunks/chunk-AUKRN2ZN.js
+// packages/safe-bash-command-pandoc/dist/chunks/chunk-IGDCQRP5.js
 init_buffer();
 import * as gfm_syntax_star from "../../safe-bash-markdown-engine/gfm-syntax.js";
 import * as commonmark_blocks_star from "../../safe-bash-markdown-engine/commonmark-blocks.js";
@@ -919,7 +919,7 @@ async function renderPdf(document, context = {}) {
   return bytes;
 }
 
-// packages/safe-bash-command-pandoc/dist/chunks/chunk-AUKRN2ZN.js
+// packages/safe-bash-command-pandoc/dist/chunks/chunk-IGDCQRP5.js
 import { hasYieldCheckpoint, runYieldCheckpoint, yieldTurn } from "../../safe-bash-contracts/yield.js";
 import { dirname } from "@poe-platform/safe-fs/core";
 import { createOutputOperation, getCommandArguments, readBytes, FsError } from "../../safe-bash-contracts/index.js";
@@ -22874,10 +22874,22 @@ function createPandocCommand(options = {}, hasCommand) {
         if (matchedExt) return matchedExt;
         if (!["python3", "python", "node", "sh", "bash"].some((candidate) => hasCommand(candidate))) return void 0;
         try {
-          const head2 = await context.fs.readFile(pathOf(context, filterPath), { signal: readSignal, maxBytes: 256 });
-          const shebangCmd = parseShebangCommand(head2);
+          const bound = Math.min(limits.resourceBytes ?? defaultLimits.resourceBytes, maxBytes);
+          const head2 = await (stdout ?? invocation).acquire(() => context.fs.readFile(
+            pathOf(context, filterPath),
+            Number.isFinite(bound) ? { signal: readSignal, maxBytes: bound } : { signal: readSignal }
+          ), () => {
+          });
+          total += head2.byteLength;
+          context.inputBudget?.check(total);
+          const shebangCmd = parseShebangCommand(head2.subarray(0, 256));
           if (shebangCmd && hasCommand(shebangCmd)) return shebangCmd;
-        } catch {
+        } catch (error) {
+          readSignal.throwIfAborted();
+          if (error instanceof Error && error.name === "AbortError") {
+            await (stdout ?? invocation).abort(error);
+            throw error;
+          }
           return void 0;
         }
         return void 0;

package/dist/safe-bash/command-chunks/{chunk-LYKC7WJB.js → chunk-6742OVAC.js}

@@ -1511,9 +1511,43 @@ var Interpreter = class _Interpreter {
       }
       return;
     }
-    if (name === "indices") {
-      for await (const value of this.run(args[0], input))
-        yield await indices(input, value, budget);
+    if (name === "indices" || name === "index" || name === "rindex") {
+      for await (const value of this.run(args[0], input)) {
+        const found = await indices(input, value, budget);
+        if (name === "indices")
+          yield found;
+        else
+          yield indexValue(found, name === "index" ? 0 : -1);
+      }
+      return;
+    }
+    if (name === "floor" || name === "ceil" || name === "round" || name === "abs") {
+      if (!isNumber(input))
+        throw new JqError(`${describe(input, budget)} cannot be ${name}ed`);
+      budget.step();
+      const n = numberValue(input);
+      yield name === "floor" ? Math.floor(n) : name === "ceil" ? Math.ceil(n) : name === "round" ? Math.round(n) : Math.abs(n);
+      return;
+    }
+    if (name === "implode") {
+      if (!Array.isArray(input))
+        throw new JqError("implode input must be an array");
+      let out = "";
+      for (let i = 0; i < input.length; i++) {
+        {
+          const _p = budget.tickSync();
+          if (_p)
+            await _p;
+        }
+        const el = input[i];
+        const cp = isNumber(el) ? numberValue(el) : NaN;
+        if (!Number.isInteger(cp) || cp < 0 || cp > 1114111) {
+          throw new JqError("implode elements must be Unicode codepoints");
+        }
+        out += String.fromCodePoint(cp);
+      }
+      budget.value(out);
+      yield out;
       return;
     }
     if (["startswith", "endswith", "ltrimstr", "rtrimstr"].includes(name)) {

package/dist/safe-bash/command-chunks/{chunk-BMBXSLVX.js → chunk-6QU5OLPJ.js}

@@ -1,9 +1,9 @@
 import {
   parse
-} from "./chunk-YHANNN7I.js";
+} from "./chunk-S3BO2NJT.js";
 import {
   Interpreter
-} from "./chunk-LYKC7WJB.js";
+} from "./chunk-6742OVAC.js";
 import {
   Budget,
   JqLimitError,

package/dist/safe-bash/command-chunks/{chunk-YHANNN7I.js → chunk-S3BO2NJT.js}

@@ -44,7 +44,14 @@ var precedence = Object.freeze({
 var functions = Object.freeze({
   walk: [1],
   explode: [0],
+  implode: [0],
   utf8bytelength: [0],
+  floor: [0],
+  ceil: [0],
+  round: [0],
+  abs: [0],
+  index: [1],
+  rindex: [1],
   while: [2],
   until: [2],
   fromdateiso8601: [0],

package/dist/safe-bash/commands/basic.d.ts

@@ -3,5 +3,7 @@ export declare const defaultEchoExecutors: WeakSet<CommandHandler>;
 export declare function basicCommands(): CommandDefinition[];
 export declare function formatPrintf(context: CommandContext): Promise<CommandResult>;
 export declare function tryFastPrintf(args: readonly string[]): string | undefined;
+export type FastPrintfSpecKind = "s" | "s_prec" | "c" | "d" | "u";
+export declare function extractFastPrintfSpecifiers(format: string): readonly FastPrintfSpecKind[] | undefined;
 export declare const printfCommand: CommandDefinition;
 //# sourceMappingURL=basic.d.ts.map

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

@@ -8,6 +8,7 @@ import { printfHex } from "./printf-hex.js";
 import { parsePrintfFloat } from "./printf-float.js";
 import { printfDecimal } from "./printf-decimal.js";
 import { parsePrintfDirective } from "./printf-format.js";
+const utf8Encoder = new TextEncoder();
 export const defaultEchoExecutors = new WeakSet();
 export function basicCommands() {
     return [
@@ -94,7 +95,7 @@ export function basicCommands() {
                 await output(context, result + (parsed.flags.has("z") ? "\0" : "\n"));
             }
             return { exitCode: 0 };
-        }),
+        }, 1, 1),
         define("dirname", async (context) => {
             const parsed = options(context.args, "z", { zero: "z" });
             requireOperands(parsed.operands);
@@ -106,7 +107,7 @@ export function basicCommands() {
                 await output(context, parent.slice(0, end) + (parsed.flags.has("z") ? "\0" : "\n"));
             }
             return { exitCode: 0 };
-        }),
+        }, 1, 1),
         printfCommand,
     ].map(command => {
         if (command.name === "echo")
@@ -355,6 +356,75 @@ export function tryFastPrintf(args) {
                     offset += 2;
                     continue;
                 }
+                if (next === 97) {
+                    result += "\x07";
+                    offset += 2;
+                    continue;
+                }
+                if (next === 98) {
+                    result += "\b";
+                    offset += 2;
+                    continue;
+                }
+                if (next === 102) {
+                    result += "\f";
+                    offset += 2;
+                    continue;
+                }
+                if (next === 118) {
+                    result += "\v";
+                    offset += 2;
+                    continue;
+                }
+                if (next === 101 || next === 69) {
+                    result += "\x1b";
+                    offset += 2;
+                    continue;
+                }
+                if (next === 34) {
+                    result += "\"";
+                    offset += 2;
+                    continue;
+                }
+                if (next === 39) {
+                    result += "'";
+                    offset += 2;
+                    continue;
+                }
+                if (next >= 48 && next <= 55) {
+                    let cur = offset + 1;
+                    const end = Math.min(format.length, cur + 3);
+                    let val = 0;
+                    while (cur < end && format.charCodeAt(cur) >= 48 && format.charCodeAt(cur) <= 55) {
+                        val = val * 8 + (format.charCodeAt(cur++) - 48);
+                    }
+                    const byte = val & 255;
+                    if (byte === 0 || byte >= 128)
+                        return undefined;
+                    result += String.fromCharCode(byte);
+                    offset = cur;
+                    continue;
+                }
+                if (next === 120) {
+                    let cur = offset + 2;
+                    const end = Math.min(format.length, cur + 2);
+                    let val = 0;
+                    let digits = 0;
+                    while (cur < end) {
+                        const d = format.charCodeAt(cur);
+                        const n = d >= 48 && d <= 57 ? d - 48 : d >= 65 && d <= 70 ? d - 55 : d >= 97 && d <= 102 ? d - 87 : -1;
+                        if (n < 0)
+                            break;
+                        val = val * 16 + n;
+                        digits++;
+                        cur++;
+                    }
+                    if (digits === 0 || val === 0 || val >= 128)
+                        return undefined;
+                    result += String.fromCharCode(val);
+                    offset = cur;
+                    continue;
+                }
                 return undefined;
             }
             if (ch !== 37) {
@@ -422,15 +492,31 @@ export function tryFastPrintf(args) {
                 const rawVal = args[argument++] ?? "";
                 if (rawVal.includes("\0"))
                     return undefined;
-                // String slicing and padding match byte semantics only for ASCII.
+                let val = rawVal;
+                let valByteLen = rawVal.length;
                 if (precision >= 0 || width > 0) {
-                    for (let i = 0; i < rawVal.length; i++)
-                        if (rawVal.charCodeAt(i) >= 128)
-                            return undefined;
+                    let isAscii = true;
+                    for (let i = 0; i < rawVal.length; i++) {
+                        if (rawVal.charCodeAt(i) >= 128) {
+                            isAscii = false;
+                            break;
+                        }
+                    }
+                    if (isAscii) {
+                        if (precision >= 0 && precision < rawVal.length) {
+                            val = rawVal.slice(0, precision);
+                            valByteLen = val.length;
+                        }
+                    }
+                    else if (precision < 0) {
+                        valByteLen = utf8Encoder.encode(rawVal).byteLength;
+                    }
+                    else {
+                        return undefined;
+                    }
                 }
-                const val = precision >= 0 ? rawVal.slice(0, precision) : rawVal;
-                if (width > val.length) {
-                    const pad = " ".repeat(width - val.length);
+                if (width > valByteLen) {
+                    const pad = " ".repeat(width - valByteLen);
                     result += leftAlign ? val + pad : pad + val;
                 }
                 else {
@@ -439,6 +525,24 @@ export function tryFastPrintf(args) {
                 offset = cur + 1;
                 continue;
             }
+            if (conv === 99 && !zeroPad) {
+                const rawVal = args[argument++] ?? "";
+                if (rawVal.length === 0)
+                    return undefined;
+                const c0 = rawVal.charCodeAt(0);
+                if (c0 === 0 || c0 >= 128)
+                    return undefined;
+                const ch0 = rawVal[0];
+                if (width > 1) {
+                    const pad = " ".repeat(width - 1);
+                    result += leftAlign ? ch0 + pad : pad + ch0;
+                }
+                else {
+                    result += ch0;
+                }
+                offset = cur + 1;
+                continue;
+            }
             if (conv === 100 || conv === 105) {
                 const rawVal = args[argument++] ?? "0";
                 const val = rawVal.length === 0 ? "0" : rawVal;
@@ -536,5 +640,128 @@ export function tryFastPrintf(args) {
     } while (argument < args.length);
     return result;
 }
+export function extractFastPrintfSpecifiers(format) {
+    if (format.length > 256)
+        return undefined;
+    const specs = [];
+    for (let offset = 0; offset < format.length;) {
+        const ch = format.charCodeAt(offset);
+        if (ch === 92) {
+            const next = format.charCodeAt(offset + 1);
+            if (next === 110 || next === 116 || next === 114 || next === 92 ||
+                next === 97 || next === 98 || next === 102 || next === 118 ||
+                next === 101 || next === 69 || next === 34 || next === 39) {
+                offset += 2;
+                continue;
+            }
+            if (next >= 48 && next <= 55) {
+                let cur = offset + 1;
+                const end = Math.min(format.length, cur + 3);
+                let val = 0;
+                while (cur < end && format.charCodeAt(cur) >= 48 && format.charCodeAt(cur) <= 55) {
+                    val = val * 8 + (format.charCodeAt(cur++) - 48);
+                }
+                if ((val & 255) === 0 || (val & 255) >= 128)
+                    return undefined;
+                offset = cur;
+                continue;
+            }
+            if (next === 120) {
+                let cur = offset + 2;
+                const end = Math.min(format.length, cur + 2);
+                let val = 0;
+                let digits = 0;
+                while (cur < end) {
+                    const d = format.charCodeAt(cur);
+                    const n = d >= 48 && d <= 57 ? d - 48 : d >= 65 && d <= 70 ? d - 55 : d >= 97 && d <= 102 ? d - 87 : -1;
+                    if (n < 0)
+                        break;
+                    val = val * 16 + n;
+                    digits++;
+                    cur++;
+                }
+                if (digits === 0 || val === 0 || val >= 128)
+                    return undefined;
+                offset = cur;
+                continue;
+            }
+            return undefined;
+        }
+        if (ch !== 37) {
+            offset++;
+            continue;
+        }
+        const spec = format.charCodeAt(offset + 1);
+        if (spec === 37) {
+            offset += 2;
+            continue;
+        }
+        let cur = offset + 1;
+        let leftAlign = false;
+        let zeroPad = false;
+        while (cur < format.length) {
+            const fc = format.charCodeAt(cur);
+            if (fc === 45) {
+                leftAlign = true;
+                cur++;
+            }
+            else if (fc === 48) {
+                zeroPad = true;
+                cur++;
+            }
+            else
+                break;
+        }
+        if (leftAlign)
+            zeroPad = false;
+        let width = 0;
+        while (cur < format.length) {
+            const dc = format.charCodeAt(cur);
+            if (dc < 48 || dc > 57)
+                break;
+            width = width * 10 + (dc - 48);
+            if (width > 128)
+                return undefined;
+            cur++;
+        }
+        let precision = -1;
+        if (format.charCodeAt(cur) === 46) {
+            cur++;
+            precision = 0;
+            while (cur < format.length) {
+                const dc = format.charCodeAt(cur);
+                if (dc < 48 || dc > 57)
+                    break;
+                precision = precision * 10 + (dc - 48);
+                if (precision > 128)
+                    return undefined;
+                cur++;
+            }
+        }
+        const conv = format.charCodeAt(cur);
+        if (conv === 115 && !zeroPad) {
+            specs.push(precision < 0 ? "s" : "s_prec");
+            offset = cur + 1;
+            continue;
+        }
+        if (conv === 99 && !zeroPad) {
+            specs.push("c");
+            offset = cur + 1;
+            continue;
+        }
+        if (conv === 100 || conv === 105) {
+            specs.push("d");
+            offset = cur + 1;
+            continue;
+        }
+        if (conv === 120 || conv === 88 || conv === 111 || conv === 117) {
+            specs.push("u");
+            offset = cur + 1;
+            continue;
+        }
+        return undefined;
+    }
+    return specs;
+}
 export const printfCommand = define("printf", formatPrintf, 1, 1);
 //# sourceMappingURL=basic.js.map

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

@@ -2,7 +2,7 @@ import {
   createPrCommand,
   createPrCommands,
   prCommands
-} from "../../chunks/chunk-I3DOFJSJ.js";
+} from "../../chunks/chunk-MUWJPSGN.js";
 import "../../chunks/chunk-BI6JV62X.js";
 import "../../chunks/chunk-2G2T5MEM.js";
 import "../../chunks/chunk-JYGWVGEJ.js";

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

@@ -713,7 +713,7 @@ async function executeHeadTailSlow(name, maxTailFollowHandles, context) {
 }
 function headTail(name, maxTailFollowHandles = Infinity) {
     return define(name, context => {
-        if (name === "head" || name === "tail") {
+        if (name === "head") {
             const a = context.args;
             let fastCount = -1;
             if (a.length === 0) {
@@ -746,62 +746,15 @@ function headTail(name, maxTailFollowHandles = Infinity) {
                 fastCount = n;
             }
             if (fastCount >= 0) {
-                if (name === "head") {
-                    assertCommandRequirements(context, inspectedInputRequirements, STDIN_REQUIREMENT_MODES);
-                    try {
-                        const p = prefixSyncOrAsync(context, input(context, "-"), fastCount, false, false, 10);
-                        if (p === undefined)
-                            return RESOLVED_EXIT_ZERO;
-                        return finishHeadTailPromise(context, p);
-                    }
-                    catch (error) {
-                        return diagnostic(context, error).then(RETURN_EXIT_ONE);
-                    }
+                assertCommandRequirements(context, inspectedInputRequirements, STDIN_REQUIREMENT_MODES);
+                try {
+                    const p = prefixSyncOrAsync(context, input(context, "-"), fastCount, false, false, 10);
+                    if (p === undefined)
+                        return RESOLVED_EXIT_ZERO;
+                    return finishHeadTailPromise(context, p);
                 }
-                else {
-                    const req = assertInputRequirements(context, SINGLE_STDIN_OPERAND);
-                    if (!req) {
-                        assertCommandRequirements(context, inspectedInputRequirements, STDIN_REQUIREMENT_MODES);
-                        const iter = input(context, "-")[Symbol.asyncIterator]();
-                        if (typeof iter.tryNextSync === "function") {
-                            try {
-                                const res1 = iter.tryNextSync();
-                                if (res1 !== undefined) {
-                                    if (res1.done)
-                                        return RESOLVED_EXIT_ZERO;
-                                    const chunk = res1.value;
-                                    const res2 = iter.tryNextSync();
-                                    if (res2 !== undefined && res2.done && chunk.length <= bufferLimit) {
-                                        if (fastCount === 0 || chunk.length === 0)
-                                            return RESOLVED_EXIT_ZERO;
-                                        let pos = chunk[chunk.length - 1] === 10 ? chunk.length - 2 : chunk.length - 1;
-                                        let startIdx = 0;
-                                        for (let rem = fastCount; rem > 0; rem--) {
-                                            if (pos < 0) {
-                                                startIdx = 0;
-                                                break;
-                                            }
-                                            const nl = chunk.lastIndexOf(10, pos);
-                                            if (nl === -1) {
-                                                startIdx = 0;
-                                                break;
-                                            }
-                                            startIdx = nl + 1;
-                                            pos = nl - 1;
-                                        }
-                                        const slice = startIdx === 0 ? chunk : chunk.subarray(startIdx);
-                                        const p = output(context, slice);
-                                        if (isSyncResolved(p))
-                                            return RESOLVED_EXIT_ZERO;
-                                        return finishHeadTailPromise(context, p);
-                                    }
-                                }
-                            }
-                            catch (error) {
-                                return diagnostic(context, error).then(RETURN_EXIT_ONE);
-                            }
-                        }
-                    }
+                catch (error) {
+                    return diagnostic(context, error).then(RETURN_EXIT_ONE);
                 }
             }
         }

package/dist/safe-bash/commands/table-text/index.js

@@ -1,10 +1,14 @@
+import { builtInDirectContextExecutors } from "../internal.js";
 import { createPasteCommand } from "./paste.js";
 import { createCommCommand } from "./comm.js";
 import { createJoinCommand } from "./join.js";
 import { settings } from "./internal.js";
 export function createTableTextCommands(options = {}) {
     settings(options);
-    return [createPasteCommand(options), createCommCommand(options), createJoinCommand(options)];
+    const defs = [createPasteCommand(options), createCommCommand(options), createJoinCommand(options)];
+    for (let i = 0; i < defs.length; i++)
+        builtInDirectContextExecutors.add(defs[i].execute);
+    return defs;
 }
 export function tableTextCommands(options = {}) {
     const commands = createTableTextCommands(options);