@poe-platform/safe-bash 0.1.806 → 0.1.807

package/dist/safe-bash/command-chunks/{chunk-HFUL6E5I.js → chunk-A7CE4EIU.js}

@@ -1,15 +1,20 @@
+import {
+  createLlmSpool
+} from "./chunk-V3RGA5PS.js";
+import {
+  createLlmService,
+  validateModelOptions
+} from "./chunk-ZH5K2H4E.js";
 import {
   attachmentBytesId,
   base64Stream,
-  getLlmAttachmentUrlId,
+  getLlmAttachmentUrlId
+} from "./chunk-HJDE7ZNV.js";
+import {
   jsonValue,
   sourceBytes,
   waitForSource
-} from "./chunk-BNG4ZMZ3.js";
-import {
-  createLlmService,
-  validateModelOptions
-} from "./chunk-ZH5K2H4E.js";
+} from "./chunk-PXL4NBYP.js";
 import {
   resolveUrlAttachment,
   validateAttachmentUrl
@@ -118,7 +123,7 @@ async function* embeddingText(source, signal) {
 }
 
 // packages/safe-bash-command-llm/src/embed-command.ts
-import { FsError as FsError6 } from "../../safe-bash-contracts/index.js";
+import { FsError as FsError5 } from "../../safe-bash-contracts/index.js";
 import { pathOf as pathOf2 } from "../../safe-bash-contracts/path.js";
 
 // packages/safe-bash-command-llm/src/configuration.ts
@@ -417,128 +422,6 @@ async function fileSource({ fs, path, signal, maxBytes = Infinity, expectedStat
   };
 }
 
-// packages/safe-bash-command-llm/src/retained-spool.ts
-import { FsError as FsError5 } from "../../safe-bash-contracts/index.js";
-var serial = 0;
-function verifyRetainedFile(actual, expected) {
-  const sameOwner = expected.identityScope !== void 0 && expected.identityScope === actual.identityScope;
-  const sameIdentity = expected.opaqueIdentity !== void 0 ? expected.opaqueIdentity === actual.opaqueIdentity : expected.dev !== void 0 && expected.ino !== void 0 && expected.dev === actual.dev && expected.ino === actual.ino;
-  if (!sameOwner || !sameIdentity || actual.type !== "file" || actual.size !== expected.size || actual.revision !== expected.revision || actual.opaqueVersion !== expected.opaqueVersion || actual.mtimeMs !== expected.mtimeMs || actual.ctimeMs !== expected.ctimeMs) throw new FsError5("EBUSY", { message: "LLM spool changed" });
-}
-async function createLlmSpool(fs, directory, signal, purpose = "output") {
-  const parent = await fs.stat(directory, { signal });
-  if (parent.type !== "directory") throw new FsError5("ENOTDIR", { path: directory });
-  const caps = await fs.capabilitiesFor?.(directory, { signal }) ?? fs.capabilities;
-  if (!caps.retainedStagingCleanup || !caps.retainedStagingWrite || !caps.retainedRead || !fs.createStagedFile || !fs.openReadFile) throw new FsError5("ENOTSUP", { message: "LLM staging requires caller filesystem retained staging and reads" });
-  let staging;
-  for (let attempt = 0; attempt < 16; attempt++) {
-    try {
-      staging = await fs.createStagedFile(`${directory === "/" ? "" : directory}/.llm-${purpose}-${++serial}`, purpose, { type: "file", data: new Uint8Array(0) }, { parent, mode: 384, retainCleanup: true, signal });
-      break;
-    } catch (error) {
-      signal.throwIfAborted();
-      if (!(error instanceof FsError5) || error.code !== "EEXIST") throw error;
-    }
-  }
-  if (!staging) throw new FsError5("EEXIST", { message: "LLM output staging names exhausted" });
-  const owner = staging;
-  const cleanup = owner.cleanup;
-  const writer = owner.writer;
-  if (!cleanup || !writer) {
-    try {
-      await cleanup?.remove();
-    } finally {
-      await cleanup?.close();
-    }
-    throw new FsError5("EIO", { message: "Caller filesystem omitted its retained staging handles" });
-  }
-  let reader;
-  let sealed;
-  let sealing;
-  let active = false;
-  let writing = false;
-  let written = 0;
-  let closing;
-  return {
-    async write(bytes) {
-      signal.throwIfAborted();
-      if (sealing || closing) throw new FsError5("EBADF", { message: "LLM spool is closed" });
-      if (writing) throw new FsError5("EBUSY", { message: "LLM spool write is active" });
-      writing = true;
-      try {
-        for (let offset = 0; offset < bytes.byteLength; offset += 16384) {
-          const chunk = bytes.subarray(offset, offset + 16384);
-          await writer.write(chunk, { signal });
-          written += chunk.byteLength;
-        }
-      } finally {
-        writing = false;
-      }
-    },
-    async *replay(select) {
-      signal.throwIfAborted();
-      if (closing) throw new FsError5("EBADF", { message: "LLM spool is closed" });
-      if (active || writing) throw new FsError5("EBUSY", { message: "LLM spool is in use" });
-      active = true;
-      try {
-        sealing ??= (async () => {
-          sealed = await writer.finish({ signal });
-          if (sealed.size !== written) throw new FsError5("EIO", { message: "LLM spool size mismatch" });
-          signal.throwIfAborted();
-          if (closing) throw new FsError5("EBADF", { message: "LLM spool is closed" });
-          const opened = await fs.openReadFile(owner.file.path, { signal });
-          if (closing || signal.aborted) {
-            await opened.close();
-            signal.throwIfAborted();
-            throw new FsError5("EBADF", { message: "LLM spool is closed" });
-          }
-          reader = opened;
-        })();
-        await sealing;
-        signal.throwIfAborted();
-        if (closing || !reader) throw new FsError5("EBADF", { message: "LLM spool is closed" });
-        verifyRetainedFile(await reader.stat({ signal }), sealed);
-        const read = async (position2, maxBytes) => {
-          signal.throwIfAborted();
-          if (closing || !reader) throw new FsError5("EBADF", { message: "LLM spool is closed" });
-          if (!Number.isSafeInteger(position2) || position2 < 0 || position2 >= written || !Number.isSafeInteger(maxBytes) || maxBytes <= 0 || maxBytes > 16384) throw new FsError5("EINVAL", { message: "Invalid LLM spool range" });
-          const count = Math.min(maxBytes, written - position2);
-          verifyRetainedFile(await reader.stat({ signal }), sealed);
-          const bytes = await reader.read(position2, count, { signal });
-          if (!bytes.byteLength || bytes.byteLength > count) throw new FsError5("EIO", { message: "Invalid LLM spool read" });
-          verifyRetainedFile(await reader.stat({ signal }), sealed);
-          return bytes;
-        };
-        const range = await select?.({ size: written, read });
-        if (range && (!Number.isSafeInteger(range.start) || !Number.isSafeInteger(range.end) || range.start < 0 || range.end < range.start || range.end > written)) throw new FsError5("EINVAL", { message: "Invalid LLM spool selection" });
-        let position = range?.start ?? 0;
-        const end = range?.end ?? written;
-        while (position < end) {
-          const bytes = await read(position, Math.min(16384, end - position));
-          position += bytes.byteLength;
-          yield bytes;
-        }
-      } finally {
-        active = false;
-      }
-    },
-    close() {
-      closing ??= (async () => {
-        try {
-          await reader?.close();
-        } finally {
-          try {
-            await cleanup.remove();
-          } finally {
-            await cleanup.close();
-          }
-        }
-      })();
-      return closing;
-    }
-  };
-}
-
 // packages/safe-bash-command-llm/src/embed-output.ts
 import { yieldTurn as yieldTurn2 } from "../../safe-bash-contracts/yield.js";
 function floatText(value) {
@@ -648,7 +531,7 @@ async function embeddingCommand(context, service, tokens, write, diagnostic, ste
     try {
       await context.fs.stat(pathOf2(context, values.input), { signal: context.signal });
     } catch (error) {
-      if (error instanceof FsError6 && error.code === "ENOENT") return fail(`Invalid value for '-i' / '--input': Path '${values.input}' does not exist.`, 2, true);
+      if (error instanceof FsError5 && error.code === "ENOENT") return fail(`Invalid value for '-i' / '--input': Path '${values.input}' does not exist.`, 2, true);
       throw error;
     }
   }
@@ -893,7 +776,7 @@ async function* serializeLlmTokenUsage(usage2, signal) {
 }
 
 // packages/safe-bash-command-llm/src/input-budget.ts
-import { FsError as FsError7, shellValueByteLength } from "../../safe-bash-contracts/index.js";
+import { FsError as FsError6, shellValueByteLength } from "../../safe-bash-contracts/index.js";
 function createLlmInputBudget(limits = {}, parent) {
   for (const [name, value] of Object.entries({ maxInputBytes: limits.maxInputBytes, maxBufferedInputBytes: limits.maxBufferedInputBytes })) {
     if (value !== void 0 && value !== Infinity && (!Number.isSafeInteger(value) || value < 0)) throw new RangeError(`Invalid LLM input limit: ${name}`);
@@ -903,8 +786,8 @@ function createLlmInputBudget(limits = {}, parent) {
   let total = 0, buffered = 0;
   const check = (size, materialized = false) => {
     if (!Number.isSafeInteger(size) || size < 0) throw new RangeError("Invalid LLM input size");
-    if (materialized && size > bufferedLimit - buffered) throw new FsError7("EFBIG", { message: "llm buffered input byte limit exceeded" });
-    if (size > totalLimit - total) throw new FsError7("EFBIG", { message: "llm input byte limit exceeded" });
+    if (materialized && size > bufferedLimit - buffered) throw new FsError6("EFBIG", { message: "llm buffered input byte limit exceeded" });
+    if (size > totalLimit - total) throw new FsError6("EFBIG", { message: "llm input byte limit exceeded" });
     parent?.check(total + size);
   };
   return {
@@ -930,13 +813,13 @@ function createLlmInputBudget(limits = {}, parent) {
 }
 
 // packages/safe-bash-command-llm/src/command.ts
-import { pipeBytes, createOutputOperation, getCommandArguments, shellValueByteLength as shellValueByteLength2, FsError as FsError10 } from "../../safe-bash-contracts/index.js";
+import { pipeBytes, createOutputOperation, getCommandArguments, shellValueByteLength as shellValueByteLength2, FsError as FsError9 } from "../../safe-bash-contracts/index.js";
 import { inheritYieldCheckpoint as inheritYieldCheckpoint2, yieldTurn as yieldTurn5 } from "../../safe-bash-contracts/yield.js";
 import { writeDiagnostic } from "../../safe-bash-contracts/escaping.js";
 import { pathOf as pathOf5 } from "../../safe-bash-contracts/path.js";
 
 // packages/safe-bash-command-llm/src/templates.ts
-import { FsError as FsError8 } from "../../safe-bash-contracts/index.js";
+import { FsError as FsError7 } from "../../safe-bash-contracts/index.js";
 import { pathOf as pathOf3 } from "../../safe-bash-contracts/path.js";
 function unicodeOrder(left, right) {
   let a = 0, b = 0;
@@ -1101,7 +984,7 @@ For more information check: https://developer.mozilla.org/en-US/docs/Web/HTTP/St
             if (next.done) break;
             total += next.value.byteLength;
             if (total > loaders.maxRemoteBytes) throw new RangeError("Template URL exceeds byte limit");
-            if (total > materializedLimit) throw new FsError8("EFBIG", { message: "llm buffered input byte limit exceeded" });
+            if (total > materializedLimit) throw new FsError7("EFBIG", { message: "llm buffered input byte limit exceeded" });
             loaders.admitBytes?.(next.value.byteLength);
             chunks.push(decoder.decode(next.value, { stream: true }));
           }
@@ -1142,7 +1025,7 @@ For more information check: https://developer.mozilla.org/en-US/docs/Web/HTTP/St
       try {
         await context.fs.stat(path, { signal: context.signal });
       } catch (error) {
-        if (!(error instanceof FsError8) || error.code !== "ENOENT") throw error;
+        if (!(error instanceof FsError7) || error.code !== "ENOENT") throw error;
         const colon = name.indexOf(":");
         if (colon > 0) {
           const prefix = name.slice(0, colon);
@@ -1161,7 +1044,7 @@ For more information check: https://developer.mozilla.org/en-US/docs/Web/HTTP/St
               let loadedBytes = 0;
               if (loaders?.admitBytes || materializedLimit !== Infinity) for await (const bytes2 of jsonValue(loaded, context.signal)) {
                 loadedBytes += bytes2.byteLength;
-                if (loadedBytes > materializedLimit) throw new FsError8("EFBIG", { message: "llm buffered input byte limit exceeded" });
+                if (loadedBytes > materializedLimit) throw new FsError7("EFBIG", { message: "llm buffered input byte limit exceeded" });
                 loaders?.admitBytes?.(bytes2.byteLength);
               }
               const value = template(loaded, loaded.name);
@@ -1176,12 +1059,12 @@ For more information check: https://developer.mozilla.org/en-US/docs/Web/HTTP/St
         path = filename(name);
       }
       const size = (await context.fs.stat(path, { signal: context.signal })).size;
-      if (size > (loaders?.maxBytes ?? Infinity)) throw new FsError8("EFBIG", { message: "llm buffered input byte limit exceeded" });
+      if (size > (loaders?.maxBytes ?? Infinity)) throw new FsError7("EFBIG", { message: "llm buffered input byte limit exceeded" });
       const bytes = await context.fs.readFile(path, { signal: context.signal, ...loaders?.maxBytes === void 0 || loaders.maxBytes === Infinity ? {} : { maxBytes: loaders.maxBytes } });
       loaders?.admitBytes?.(bytes.byteLength);
       return template(parse2(new TextDecoder("utf-8", { fatal: true }).decode(bytes)), name);
     } catch (error) {
-      if (error instanceof FsError8 && error.code === "ENOENT") throw new Error(`Invalid template: ${name}`);
+      if (error instanceof FsError7 && error.code === "ENOENT") throw new Error(`Invalid template: ${name}`);
       throw error;
     }
   };
@@ -1193,7 +1076,7 @@ For more information check: https://developer.mozilla.org/en-US/docs/Web/HTTP/St
     try {
       expected = await context.fs.lstat(path, { signal: context.signal });
     } catch (error) {
-      if (!(error instanceof FsError8) || error.code !== "ENOENT") throw error;
+      if (!(error instanceof FsError7) || error.code !== "ENOENT") throw error;
       expected = null;
     }
     await publishConfiguration(context.fs, directory, path, bytes, parent, expected, context.signal);
@@ -1314,7 +1197,7 @@ Options:
         try {
           await context.fs.lstat(path, { signal: context.signal });
         } catch (error) {
-          if (!(error instanceof FsError8) || error.code !== "ENOENT") throw error;
+          if (!(error instanceof FsError7) || error.code !== "ENOENT") throw error;
           await publish(name, new TextEncoder().encode("prompt: "));
         }
         const editor = context.env.VISUAL || context.env.EDITOR || "vi";
@@ -1337,7 +1220,7 @@ Options:
       try {
         files = await context.fs.readdir(directory, { signal: context.signal });
       } catch (error) {
-        if (error instanceof FsError8 && error.code === "ENOENT") return 0;
+        if (error instanceof FsError7 && error.code === "ENOENT") return 0;
         throw error;
       }
       const values = [];
@@ -1495,7 +1378,7 @@ function parseLlmSchemaDsl(input, multi = false) {
 }
 
 // packages/safe-bash-command-llm/src/schema-input.ts
-import { FsError as FsError9 } from "../../safe-bash-contracts/index.js";
+import { FsError as FsError8 } from "../../safe-bash-contracts/index.js";
 import { pathOf as pathOf4 } from "../../safe-bash-contracts/path.js";
 async function resolveLlmSchemaInput(context, input, options) {
   context.signal.throwIfAborted();
@@ -1520,7 +1403,7 @@ async function resolveLlmSchemaInput(context, input, options) {
       try {
         stat = await context.fs.stat(path, { signal: context.signal });
       } catch (error) {
-        if (!(error instanceof FsError9) || error.code !== "ENOENT") throw error;
+        if (!(error instanceof FsError8) || error.code !== "ENOENT") throw error;
       }
       if (stat) {
         const source = await fileSource({ fs: context.fs, path, signal: context.signal, maxBytes: options.maxBytes ?? Infinity, expectedStat: stat });
@@ -1984,7 +1867,7 @@ async function execute(context, service, limits, templateLoaderOptions) {
   let outputBytes = 0;
   let writing = false;
   const write = async (chunk) => {
-    if (chunk.byteLength > (limits?.maxOutputBytes ?? Infinity) - outputBytes) throw new FsError10("EFBIG", { message: "llm output byte limit exceeded" });
+    if (chunk.byteLength > (limits?.maxOutputBytes ?? Infinity) - outputBytes) throw new FsError9("EFBIG", { message: "llm output byte limit exceeded" });
     outputBytes += chunk.byteLength;
     if (outputSpool) {
       await outputSpool.write(chunk);
@@ -2310,14 +2193,14 @@ ${args.prompt}` : evaluated.prompt;
             await source.dispose();
           },
           bytes: { async *[Symbol.asyncIterator]() {
-            if (closed2 || consumed) throw new FsError10("EBADF", { message: "LLM attachment source is closed" });
+            if (closed2 || consumed) throw new FsError9("EBADF", { message: "LLM attachment source is closed" });
             consumed = true;
             signal.throwIfAborted();
             if (!first.done) yield first.value;
             while (true) {
-              if (closed2) throw new FsError10("EBADF", { message: "LLM attachment source is closed" });
+              if (closed2) throw new FsError9("EBADF", { message: "LLM attachment source is closed" });
               const next = await interrupted(() => chunks.next(), signal);
-              if (closed2) throw new FsError10("EBADF", { message: "LLM attachment source is closed" });
+              if (closed2) throw new FsError9("EBADF", { message: "LLM attachment source is closed" });
               if (next.done) break;
               yield next.value;
             }
@@ -2415,7 +2298,7 @@ ${args.prompt}` : evaluated.prompt;
     controller.abort(error);
     if (writing) throw error;
     await operation.close();
-    await writeDiagnostic(context.stderr, `${error instanceof Error ? error.message.slice(0, 4096) : "llm provider failed"}
+    await writeDiagnostic(context.stderr, `${error instanceof Error || error instanceof TypeError ? error.message.slice(0, 4096) : "llm provider failed"}
 `, context.signal);
     return { exitCode: error instanceof LlmModelsUsageError ? 2 : 1 };
   } finally {
@@ -2452,7 +2335,6 @@ export {
   createLlmInputBudget,
   createLlmUrlSource,
   createLlmConfiguration,
-  createLlmSpool,
   validateLlmTemplateParameters,
   llmTemplateUsesInput,
   evaluateLlmTemplate,

package/dist/safe-bash/command-chunks/chunk-A7EMM3SB.js

@@ -0,0 +1,297 @@
+import {
+  matchesModelVfs,
+  modelContext
+} from "./chunk-2W54TAGI.js";
+import {
+  characterizeRasterHeader
+} from "./chunk-FZSQMMYV.js";
+import {
+  DocumentIo
+} from "./chunk-MQPWE22J.js";
+import {
+  UnsupportedEditError
+} from "./chunk-YPVBU7QF.js";
+import {
+  Emu,
+  Inches,
+  isLength,
+  plainLength,
+  snapshotSequence
+} from "./chunk-R4TYL2G6.js";
+import {
+  asciiKey
+} from "./chunk-WAKYUXVQ.js";
+import {
+  CancellationError,
+  InputTypeError,
+  InvalidValueError,
+  ResourceLimitError,
+  archiveSettings,
+  documentByteView
+} from "./chunk-IQFRPIXH.js";
+
+// packages/safe-bash-docx-engine/src/model-vfs.ts
+function modelVfsResolver(path, capability, context) {
+  if (typeof path !== "string" || capability === void 0 || capability === null || typeof capability !== "string" && typeof capability !== "object" || capability === "")
+    throw new InputTypeError("Expected a capability-bearing virtual path.");
+  if (path.length > context.limits.maxPathBytes)
+    throw new ResourceLimitError("Virtual path byte limit exceeded.");
+  context.budget.charge("work", path.length);
+  context.budget.charge("retainedBytes", path.length * 4);
+  if (new TextEncoder().encode(path).length > context.limits.maxPathBytes)
+    throw new ResourceLimitError("Virtual path byte limit exceeded.");
+  if (!path.startsWith("/") || path.includes("\\") || [...path].some((scalar) => {
+    const point = scalar.codePointAt(0);
+    return point < 32 || point === 127 || point >= 55296 && point <= 57343;
+  }) || path.slice(1).split("/").some((part) => !part || part === "." || part === ".."))
+    throw new InvalidValueError("Expected a canonical virtual path.");
+  const resolver = typeof capability === "string" ? context.binaryResolver?.capability === capability ? context.binaryResolver : void 0 : matchesModelVfs(capability, context) ? context.vfs : void 0;
+  if (!resolver)
+    throw new UnsupportedEditError("Virtual paths require a matching explicit capability.");
+  return resolver;
+}
+function modelVfsSource(path, capability, context, maxBytes) {
+  const resolver = modelVfsResolver(path, capability, context);
+  return {
+    open(signal) {
+      return {
+        async *[Symbol.asyncIterator]() {
+          context.budget.check("work", 0);
+          const source = await resolver.open(path, Object.freeze({ signal, maxBytes }));
+          context.budget.check("work", 0);
+          if (signal.aborted) throw new CancellationError("Virtual input admission cancelled.");
+          if (!source || typeof source[Symbol.asyncIterator] !== "function")
+            throw new InputTypeError("Expected a virtual byte source.");
+          const iterator = source[Symbol.asyncIterator]();
+          let exhausted = false, failed = false;
+          let failure;
+          try {
+            if (!iterator || typeof iterator.next !== "function")
+              throw new InputTypeError("Expected a virtual byte iterator.");
+            while (true) {
+              if (signal.aborted) throw new CancellationError("Virtual input admission cancelled.");
+              const item = await iterator.next();
+              if (item === null || typeof item !== "object" && typeof item !== "function")
+                throw new InputTypeError("Expected a virtual byte iterator result.");
+              if (item.done) {
+                exhausted = true;
+                break;
+              }
+              yield item.value;
+            }
+          } catch (error) {
+            failed = true;
+            failure = error;
+          } finally {
+            if (!exhausted && iterator?.return) {
+              try {
+                await iterator.return();
+              } catch (error) {
+                if (!failed) {
+                  failed = true;
+                  failure = error;
+                }
+              }
+            }
+          }
+          if (failed) throw failure;
+        }
+      };
+    }
+  };
+}
+
+// packages/safe-bash-docx-engine/src/image-model-input.ts
+async function acquireImageModelInput(input, context) {
+  const settings = modelContext(context), { budget, limits, signal } = settings;
+  if (settings.template !== void 0) throw new InputTypeError("A context template applies only to document creation.");
+  const maxBytes = Math.min(limits.maxEntryBytes, budget.limits.embeddedMediaBytes - budget.usage.embeddedMediaBytes);
+  let bytes, filename = null;
+  if (input instanceof Uint8Array) {
+    input = documentByteView(input);
+    if (input.length > maxBytes) throw new ResourceLimitError("Image input exceeds the media byte limit.");
+    budget.charge("retainedBytes", input.length);
+    budget.charge("work", input.length);
+    bytes = new Uint8Array(input);
+  } else {
+    if (!input || typeof input !== "object" || ![Object.prototype, null].includes(Object.getPrototypeOf(input))) throw new InputTypeError("Expected an explicit image input capability.");
+    const record = {};
+    for (const key of Reflect.ownKeys(input)) {
+      const descriptor = Object.getOwnPropertyDescriptor(input, key);
+      if (typeof key !== "string" || !["kind", "base64", "path", "capability", "open"].includes(key) || !("value" in descriptor)) throw new InputTypeError("Expected finite image input data.");
+      record[key] = descriptor.value;
+    }
+    if (record.kind === "bytes") {
+      if (Object.keys(record).some((key) => key !== "kind" && key !== "base64") || typeof record.base64 !== "string" || record.base64.length % 4 !== 0) throw new InvalidValueError("Expected canonical image base64.");
+      const encoded = record.base64, padding = encoded.endsWith("==") ? 2 : encoded.endsWith("=") ? 1 : 0, size = encoded.length / 4 * 3 - padding;
+      if (size > maxBytes) throw new ResourceLimitError("Image input exceeds the media byte limit.");
+      budget.charge("retainedBytes", size * 3);
+      budget.charge("work", encoded.length);
+      let decoded;
+      try {
+        decoded = atob(encoded);
+        if (btoa(decoded) !== encoded) throw new Error();
+      } catch {
+        throw new InvalidValueError("Expected canonical image base64.");
+      }
+      bytes = Uint8Array.from(decoded, (char) => char.charCodeAt(0));
+    } else {
+      let source;
+      if (typeof record.open === "function" && Object.keys(record).length === 1) source = { open: record.open.bind(input) };
+      else {
+        if (Object.keys(record).some((key) => !["kind", "path", "capability"].includes(key)) || record.kind !== void 0 && record.kind !== "vfs") throw new InputTypeError("Expected a capability-bearing image path.");
+        source = modelVfsSource(record.path, record.capability, settings, maxBytes);
+        const path = record.path;
+        filename = path.slice(path.lastIndexOf("/") + 1);
+      }
+      if (maxBytes < 1) throw new ResourceLimitError("Image input exceeds the media byte limit.");
+      const io = new DocumentIo({ ...settings, limits: { ...limits, maxArchiveBytes: maxBytes }, ...settings.registerCleanup ? { registerCleanup: settings.registerCleanup } : {} });
+      try {
+        bytes = await io.readBytes(source);
+      } finally {
+        await io.cleanup();
+      }
+    }
+  }
+  budget.check("work", 0);
+  return { bytes, filename, context: { limits, signal, budget } };
+}
+
+// packages/safe-bash-docx-engine/src/image-model.ts
+var imageAdmission = /* @__PURE__ */ Symbol("image admission");
+var copyImageForOwner = /* @__PURE__ */ Symbol("copy-image-for-owner");
+function sha1(bytes, context) {
+  const { budget } = archiveSettings(context), padded = Math.ceil((bytes.length + 9) / 64) * 64;
+  budget.charge("retainedBytes", padded + 80 * 4 + 256);
+  budget.charge("work", padded * 8);
+  const data = new Uint8Array(padded);
+  data.set(bytes);
+  data[bytes.length] = 128;
+  const view = new DataView(data.buffer), bits = bytes.length * 8;
+  view.setUint32(padded - 8, Math.floor(bits / 4294967296));
+  view.setUint32(padded - 4, bits >>> 0);
+  const words = new Uint32Array(80), rotate = (value, count) => (value << count | value >>> 32 - count) >>> 0;
+  let h0 = 1732584193, h1 = 4023233417, h2 = 2562383102, h3 = 271733878, h4 = 3285377520;
+  for (let offset = 0; offset < padded; offset += 64) {
+    budget.check("work", 0);
+    for (let i = 0; i < 16; i++) words[i] = view.getUint32(offset + i * 4);
+    for (let i = 16; i < 80; i++) words[i] = rotate(words[i - 3] ^ words[i - 8] ^ words[i - 14] ^ words[i - 16], 1);
+    let a = h0, b = h1, c = h2, d = h3, e = h4;
+    for (let i = 0; i < 80; i++) {
+      const mix = i < 20 ? b & c | ~b & d : i < 40 ? b ^ c ^ d : i < 60 ? b & c | b & d | c & d : b ^ c ^ d;
+      const constant = i < 20 ? 1518500249 : i < 40 ? 1859775393 : i < 60 ? 2400959708 : 3395469782;
+      const next = rotate(a, 5) + mix + e + constant + words[i] >>> 0;
+      e = d;
+      d = c;
+      c = rotate(b, 30);
+      b = a;
+      a = next;
+    }
+    h0 = h0 + a >>> 0;
+    h1 = h1 + b >>> 0;
+    h2 = h2 + c >>> 0;
+    h3 = h3 + d >>> 0;
+    h4 = h4 + e >>> 0;
+  }
+  return [h0, h1, h2, h3, h4].map((value) => value.toString(16).padStart(8, "0")).join("");
+}
+var Image = class _Image {
+  #bytes;
+  #header;
+  #context;
+  filename;
+  ext;
+  sha1;
+  constructor(acquired, token) {
+    if (token !== imageAdmission) throw new InputTypeError("Image values require an always-async admission factory.");
+    this.#context = acquired.context;
+    const { budget } = archiveSettings(this.#context);
+    budget.charge("embeddedMediaBytes", acquired.bytes.length);
+    this.#bytes = acquired.bytes;
+    this.#header = characterizeRasterHeader(this.#bytes, this.#context);
+    const extension = { "image/png": "png", "image/jpeg": "jpg", "image/gif": "gif", "image/bmp": "bmp", "image/tiff": "tiff" }[this.#header.mime];
+    this.filename = acquired.filename ?? "image." + extension;
+    const dot = this.filename.lastIndexOf(".");
+    this.ext = dot < 0 ? "" : this.filename.slice(dot + 1);
+    const assertion = { png: "image/png", jpg: "image/jpeg", jpeg: "image/jpeg", gif: "image/gif", bmp: "image/bmp", tif: "image/tiff", tiff: "image/tiff" }[asciiKey(this.ext)];
+    if (assertion && assertion !== this.#header.mime) throw new InvalidValueError("Image filename suffix conflicts with its byte signature.");
+    this.sha1 = sha1(this.#bytes, this.#context);
+    Object.freeze(this);
+  }
+  static async from_blob(blob, context) {
+    if (!(blob instanceof Uint8Array)) throw new InputTypeError("Expected image bytes.");
+    return new _Image(await acquireImageModelInput(blob, context), imageAdmission);
+  }
+  static async from_file(input, context) {
+    if (input && typeof input === "object" && Object.hasOwn(input, "kind")) throw new InputTypeError("Primary image input requires bytes, a byte source or an explicit path.");
+    return new _Image(await acquireImageModelInput(input, context), imageAdmission);
+  }
+  static async [copyImageForOwner](image, context) {
+    const acquired = await acquireImageModelInput(image.blob, context);
+    return new _Image({ ...acquired, filename: image.filename }, imageAdmission);
+  }
+  get blob() {
+    const { budget } = archiveSettings(this.#context);
+    budget.charge("retainedBytes", this.#bytes.length);
+    budget.charge("work", this.#bytes.length);
+    return new Uint8Array(this.#bytes);
+  }
+  get content_type() {
+    return this.#header.mime;
+  }
+  get px_width() {
+    return this.#header.pixelWidth;
+  }
+  get px_height() {
+    return this.#header.pixelHeight;
+  }
+  get horz_dpi() {
+    return this.#header.horizontalDpi ?? 72;
+  }
+  get vert_dpi() {
+    return this.#header.verticalDpi ?? 72;
+  }
+  get width() {
+    const value = Inches(this.px_width / this.horz_dpi);
+    if (value.emu <= 0) throw new InvalidValueError("Native image width must round to positive EMUs.");
+    return value;
+  }
+  get height() {
+    const value = Inches(this.px_height / this.vert_dpi);
+    if (value.emu <= 0) throw new InvalidValueError("Native image height must round to positive EMUs.");
+    return value;
+  }
+  scaled_dimensions(width, height) {
+    const convert = (value) => {
+      if (value === null || value === void 0) return null;
+      if (typeof value === "number") {
+        if (!Number.isFinite(value) || Math.abs(value) > Number.MAX_SAFE_INTEGER) throw new InvalidValueError("Image dimensions must be finite safe EMUs.");
+        return Emu(value).emu;
+      }
+      const length = isLength(value) ? plainLength(value) : value;
+      if (!length || typeof length !== "object" || ![Object.prototype, null].includes(Object.getPrototypeOf(length)) || !Object.hasOwn(length, "value") || !Object.hasOwn(length, "unit") || Reflect.ownKeys(length).some((key) => typeof key !== "string" || !["value", "unit"].includes(key) || !("value" in Object.getOwnPropertyDescriptor(length, key)))) throw new InputTypeError("Expected a shared length value.");
+      if (typeof length.value !== "number" || typeof length.unit !== "string") throw new InputTypeError("Image lengths require a numeric value and an explicit unit.");
+      if (!Number.isFinite(length.value)) throw new InvalidValueError("Image dimensions must be finite.");
+      const units = { emu: 1, in: 914400, cm: 36e4, mm: 36e3, pt: 12700, twip: 635 };
+      if (!Object.hasOwn(units, length.unit)) throw new InvalidValueError("Unknown image dimension unit.");
+      const converted = length.value * units[length.unit];
+      if (!Number.isFinite(converted) || Math.abs(converted) > Number.MAX_SAFE_INTEGER) throw new InvalidValueError("Image dimensions must fit safe EMUs.");
+      return Emu(converted).emu;
+    };
+    const explicitWidth = convert(width), explicitHeight = convert(height), nativeWidth = this.px_width / this.horz_dpi * 914400, nativeHeight = this.px_height / this.vert_dpi * 914400;
+    let x = explicitWidth ?? nativeWidth, y = explicitHeight ?? nativeHeight;
+    if (explicitWidth === null && explicitHeight !== null) x = explicitHeight * (nativeWidth / nativeHeight);
+    if (explicitHeight === null && explicitWidth !== null) y = explicitWidth * (nativeHeight / nativeWidth);
+    const result = [Emu(x), Emu(y)];
+    if (result.some((value) => value.emu <= 0)) throw new InvalidValueError("Image dimensions must be positive EMUs.");
+    return snapshotSequence(result);
+  }
+};
+
+export {
+  modelVfsResolver,
+  modelVfsSource,
+  acquireImageModelInput,
+  copyImageForOwner,
+  Image
+};

package/dist/safe-bash/command-chunks/{chunk-G3YO3JIN.js → chunk-ABH5FMMA.js}

@@ -1,4 +1,4 @@
-// packages/safe-bash-command-node/src/commands/safejs/types.ts
+// packages/safe-bash-command-safejs/src/types.ts
 var SafeJsCommandLimitError = class extends Error {
   constructor(resource) {
     super(`SafeJS command limit exceeded: ${resource}`);