@poe-platform/safe-bash 0.1.817 → 0.1.819

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

@@ -0,0 +1,296 @@
+import {
+  base64Stream
+} from "./chunk-GQV5RWMN.js";
+import {
+  waitForSource
+} from "./chunk-QX3WKBLI.js";
+
+// packages/safe-bash-command-llm/src/file-source.ts
+import { FsError } from "../../safe-bash-contracts/index.js";
+function sameFile(actual, expected) {
+  const identified = 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 (!identified || expected.identityScope === void 0 || expected.identityScope !== actual.identityScope || 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 FsError("EBUSY", { message: "LLM attachment changed" });
+}
+async function fileSource({ fs, path, signal, maxBytes = Infinity, expectedStat }) {
+  signal.throwIfAborted();
+  const capabilities = await fs.capabilitiesFor?.(path, { signal }) ?? fs.capabilities;
+  if (!capabilities.retainedRead || !fs.openReadFile) throw new FsError("ENOTSUP", { message: "LLM attachment sources require retained reads" });
+  const expected = await fs.stat(path, { signal });
+  if (expectedStat) sameFile(expected, expectedStat);
+  if (expected.type !== "file") throw new FsError("EINVAL", { path });
+  if (expected.size > maxBytes) throw new FsError("EFBIG", { message: "LLM attachment input byte limit exceeded" });
+  const reader = await fs.openReadFile(path, { signal });
+  let closing;
+  const dispose = () => closing ??= reader.close();
+  try {
+    sameFile(await reader.stat({ signal }), expected);
+  } catch (error) {
+    await dispose();
+    throw error;
+  }
+  let consumed = false;
+  return {
+    dispose,
+    bytes: { async *[Symbol.asyncIterator]() {
+      if (consumed || closing) throw new FsError("EBADF", { message: "LLM attachment source is closed" });
+      consumed = true;
+      let position = 0;
+      while (position < expected.size) {
+        signal.throwIfAborted();
+        if (closing) throw new FsError("EBADF", { message: "LLM attachment source is closed" });
+        sameFile(await reader.stat({ signal }), expected);
+        const length = Math.min(16384, expected.size - position);
+        const bytes = await reader.read(position, length, { signal });
+        if (closing) throw new FsError("EBADF", { message: "LLM attachment source is closed" });
+        signal.throwIfAborted();
+        if (!bytes.byteLength || bytes.byteLength > length) throw new FsError("EIO", { message: "Invalid LLM attachment read" });
+        sameFile(await reader.stat({ signal }), expected);
+        position += bytes.byteLength;
+        yield bytes;
+      }
+      sameFile(await reader.stat({ signal }), expected);
+    } }
+  };
+}
+
+// packages/safe-bash-command-llm/src/retained-spool.ts
+import { FsError as FsError2 } 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 FsError2("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 FsError2("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 FsError2("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 FsError2) || error.code !== "EEXIST") throw error;
+    }
+  }
+  if (!staging) throw new FsError2("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 FsError2("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;
+  const leases = /* @__PURE__ */ new Set();
+  const seal = () => {
+    return sealing ??= (async () => {
+      sealed = await writer.finish({ signal });
+      if (sealed.size !== written) throw new FsError2("EIO", { message: "LLM spool size mismatch" });
+      signal.throwIfAborted();
+      if (closing) throw new FsError2("EBADF", { message: "LLM spool is closed" });
+    })();
+  };
+  return {
+    async write(bytes) {
+      signal.throwIfAborted();
+      if (sealing || closing) throw new FsError2("EBADF", { message: "LLM spool is closed" });
+      if (writing) throw new FsError2("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 FsError2("EBADF", { message: "LLM spool is closed" });
+      if (active || writing) throw new FsError2("EBUSY", { message: "LLM spool is in use" });
+      active = true;
+      try {
+        await seal();
+        if (!reader) {
+          const opened = await fs.openReadFile(owner.file.path, { signal });
+          if (closing || signal.aborted) {
+            await opened.close();
+            signal.throwIfAborted();
+            throw new FsError2("EBADF", { message: "LLM spool is closed" });
+          }
+          reader = opened;
+        }
+        signal.throwIfAborted();
+        if (closing || !reader) throw new FsError2("EBADF", { message: "LLM spool is closed" });
+        verifyRetainedFile(await reader.stat({ signal }), sealed);
+        const read = async (position2, maxBytes) => {
+          signal.throwIfAborted();
+          if (closing || !reader) throw new FsError2("EBADF", { message: "LLM spool is closed" });
+          if (!Number.isSafeInteger(position2) || position2 < 0 || position2 >= written || !Number.isSafeInteger(maxBytes) || maxBytes <= 0 || maxBytes > 16384) throw new FsError2("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 FsError2("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 FsError2("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;
+      }
+    },
+    /** A fresh identity-checked reader. Disposing it never closes the backing
+     * spool; closing the spool retires every outstanding reader. */
+    async lease(leaseSignal = signal) {
+      leaseSignal = AbortSignal.any([signal, leaseSignal]);
+      leaseSignal.throwIfAborted();
+      if (closing) throw new FsError2("EBADF", { message: "LLM spool is closed" });
+      if (writing) throw new FsError2("EBUSY", { message: "LLM spool write is active" });
+      await waitForSource(seal, leaseSignal);
+      if (closing) throw new FsError2("EBADF", { message: "LLM spool is closed" });
+      const source = await fileSource({ fs, path: owner.file.path, signal: leaseSignal, expectedStat: sealed });
+      if (closing || leaseSignal.aborted) {
+        await source.dispose();
+        leaseSignal.throwIfAborted();
+        throw new FsError2("EBADF", { message: "LLM spool is closed" });
+      }
+      let disposal;
+      const lease = { bytes: source.bytes, dispose() {
+        return disposal ??= (async () => {
+          leaseSignal.removeEventListener("abort", abort);
+          try {
+            await source.dispose();
+          } finally {
+            leases.delete(lease);
+          }
+        })();
+      } };
+      const abort = () => {
+        void lease.dispose().catch(() => void 0);
+      };
+      leases.add(lease);
+      leaseSignal.addEventListener("abort", abort, { once: true });
+      return lease;
+    },
+    close() {
+      closing ??= (async () => {
+        try {
+          const results = await Promise.allSettled([reader?.close(), ...Array.from(leases, (lease) => lease.dispose())]);
+          const rejected = results.find((result) => result.status === "rejected");
+          if (rejected?.status === "rejected") throw rejected.reason;
+        } finally {
+          try {
+            await cleanup.remove();
+          } finally {
+            await cleanup.close();
+          }
+        }
+      })();
+      return closing;
+    }
+  };
+}
+
+// packages/safe-bash-command-llm/src/python-whitespace.ts
+function isPythonWhitespace(char) {
+  return char !== "\uFEFF" && (!char.trim() || char >= "" && char <= "" || char === "\x85");
+}
+function stripPythonWhitespace(value) {
+  let start = 0, end = value.length;
+  while (start < end && isPythonWhitespace(value[start])) start++;
+  while (end > start && isPythonWhitespace(value[end - 1])) end--;
+  return value.slice(start, end);
+}
+
+// packages/safe-bash-command-llm/src/python-printable.ts
+var excluded = [0, 31, 127, 160, 173, 173, 888, 889, 896, 899, 907, 907, 909, 909, 930, 930, 1328, 1328, 1367, 1368, 1419, 1420, 1424, 1424, 1480, 1487, 1515, 1518, 1525, 1541, 1564, 1565, 1757, 1757, 1806, 1807, 1867, 1868, 1970, 1983, 2043, 2044, 2094, 2095, 2111, 2111, 2140, 2141, 2143, 2143, 2155, 2207, 2229, 2229, 2248, 2258, 2274, 2274, 2436, 2436, 2445, 2446, 2449, 2450, 2473, 2473, 2481, 2481, 2483, 2485, 2490, 2491, 2501, 2502, 2505, 2506, 2511, 2518, 2520, 2523, 2526, 2526, 2532, 2533, 2559, 2560, 2564, 2564, 2571, 2574, 2577, 2578, 2601, 2601, 2609, 2609, 2612, 2612, 2615, 2615, 2618, 2619, 2621, 2621, 2627, 2630, 2633, 2634, 2638, 2640, 2642, 2648, 2653, 2653, 2655, 2661, 2679, 2688, 2692, 2692, 2702, 2702, 2706, 2706, 2729, 2729, 2737, 2737, 2740, 2740, 2746, 2747, 2758, 2758, 2762, 2762, 2766, 2767, 2769, 2783, 2788, 2789, 2802, 2808, 2816, 2816, 2820, 2820, 2829, 2830, 2833, 2834, 2857, 2857, 2865, 2865, 2868, 2868, 2874, 2875, 2885, 2886, 2889, 2890, 2894, 2900, 2904, 2907, 2910, 2910, 2916, 2917, 2936, 2945, 2948, 2948, 2955, 2957, 2961, 2961, 2966, 2968, 2971, 2971, 2973, 2973, 2976, 2978, 2981, 2983, 2987, 2989, 3002, 3005, 3011, 3013, 3017, 3017, 3022, 3023, 3025, 3030, 3032, 3045, 3067, 3071, 3085, 3085, 3089, 3089, 3113, 3113, 3130, 3132, 3141, 3141, 3145, 3145, 3150, 3156, 3159, 3159, 3163, 3167, 3172, 3173, 3184, 3190, 3213, 3213, 3217, 3217, 3241, 3241, 3252, 3252, 3258, 3259, 3269, 3269, 3273, 3273, 3278, 3284, 3287, 3293, 3295, 3295, 3300, 3301, 3312, 3312, 3315, 3327, 3341, 3341, 3345, 3345, 3397, 3397, 3401, 3401, 3408, 3411, 3428, 3429, 3456, 3456, 3460, 3460, 3479, 3481, 3506, 3506, 3516, 3516, 3518, 3519, 3527, 3529, 3531, 3534, 3541, 3541, 3543, 3543, 3552, 3557, 3568, 3569, 3573, 3584, 3643, 3646, 3676, 3712, 3715, 3715, 3717, 3717, 3723, 3723, 3748, 3748, 3750, 3750, 3774, 3775, 3781, 3781, 3783, 3783, 3790, 3791, 3802, 3803, 3808, 3839, 3912, 3912, 3949, 3952, 3992, 3992, 4029, 4029, 4045, 4045, 4059, 4095, 4294, 4294, 4296, 4300, 4302, 4303, 4681, 4681, 4686, 4687, 4695, 4695, 4697, 4697, 4702, 4703, 4745, 4745, 4750, 4751, 4785, 4785, 4790, 4791, 4799, 4799, 4801, 4801, 4806, 4807, 4823, 4823, 4881, 4881, 4886, 4887, 4955, 4956, 4989, 4991, 5018, 5023, 5110, 5111, 5118, 5119, 5760, 5760, 5789, 5791, 5881, 5887, 5901, 5901, 5909, 5919, 5943, 5951, 5972, 5983, 5997, 5997, 6001, 6001, 6004, 6015, 6110, 6111, 6122, 6127, 6138, 6143, 6158, 6159, 6170, 6175, 6265, 6271, 6315, 6319, 6390, 6399, 6431, 6431, 6444, 6447, 6460, 6463, 6465, 6467, 6510, 6511, 6517, 6527, 6572, 6575, 6602, 6607, 6619, 6621, 6684, 6685, 6751, 6751, 6781, 6782, 6794, 6799, 6810, 6815, 6830, 6831, 6849, 6911, 6988, 6991, 7037, 7039, 7156, 7163, 7224, 7226, 7242, 7244, 7305, 7311, 7355, 7356, 7368, 7375, 7419, 7423, 7674, 7674, 7958, 7959, 7966, 7967, 8006, 8007, 8014, 8015, 8024, 8024, 8026, 8026, 8028, 8028, 8030, 8030, 8062, 8063, 8117, 8117, 8133, 8133, 8148, 8149, 8156, 8156, 8176, 8177, 8181, 8181, 8191, 8207, 8232, 8239, 8287, 8303, 8306, 8307, 8335, 8335, 8349, 8351, 8384, 8399, 8433, 8447, 8588, 8591, 9255, 9279, 9291, 9311, 11124, 11125, 11158, 11158, 11311, 11311, 11359, 11359, 11508, 11512, 11558, 11558, 11560, 11564, 11566, 11567, 11624, 11630, 11633, 11646, 11671, 11679, 11687, 11687, 11695, 11695, 11703, 11703, 11711, 11711, 11719, 11719, 11727, 11727, 11735, 11735, 11743, 11743, 11859, 11903, 11930, 11930, 12020, 12031, 12246, 12271, 12284, 12288, 12352, 12352, 12439, 12440, 12544, 12548, 12592, 12592, 12687, 12687, 12772, 12783, 12831, 12831, 40957, 40959, 42125, 42127, 42183, 42191, 42540, 42559, 42744, 42751, 42944, 42945, 42955, 42996, 43053, 43055, 43066, 43071, 43128, 43135, 43206, 43213, 43226, 43231, 43348, 43358, 43389, 43391, 43470, 43470, 43482, 43485, 43519, 43519, 43575, 43583, 43598, 43599, 43610, 43611, 43715, 43738, 43767, 43776, 43783, 43784, 43791, 43792, 43799, 43807, 43815, 43815, 43823, 43823, 43884, 43887, 44014, 44015, 44026, 44031, 55204, 55215, 55239, 55242, 55292, 63743, 64110, 64111, 64218, 64255, 64263, 64274, 64280, 64284, 64311, 64311, 64317, 64317, 64319, 64319, 64322, 64322, 64325, 64325, 64450, 64466, 64832, 64847, 64912, 64913, 64968, 65007, 65022, 65023, 65050, 65055, 65107, 65107, 65127, 65127, 65132, 65135, 65141, 65141, 65277, 65280, 65471, 65473, 65480, 65481, 65488, 65489, 65496, 65497, 65501, 65503, 65511, 65511, 65519, 65531, 65534, 65535, 65548, 65548, 65575, 65575, 65595, 65595, 65598, 65598, 65614, 65615, 65630, 65663, 65787, 65791, 65795, 65798, 65844, 65846, 65935, 65935, 65949, 65951, 65953, 65999, 66046, 66175, 66205, 66207, 66257, 66271, 66300, 66303, 66340, 66348, 66379, 66383, 66427, 66431, 66462, 66462, 66500, 66503, 66518, 66559, 66718, 66719, 66730, 66735, 66772, 66775, 66812, 66815, 66856, 66863, 66916, 66926, 66928, 67071, 67383, 67391, 67414, 67423, 67432, 67583, 67590, 67591, 67593, 67593, 67638, 67638, 67641, 67643, 67645, 67646, 67670, 67670, 67743, 67750, 67760, 67807, 67827, 67827, 67830, 67834, 67868, 67870, 67898, 67902, 67904, 67967, 68024, 68027, 68048, 68049, 68100, 68100, 68103, 68107, 68116, 68116, 68120, 68120, 68150, 68151, 68155, 68158, 68169, 68175, 68185, 68191, 68256, 68287, 68327, 68330, 68343, 68351, 68406, 68408, 68438, 68439, 68467, 68471, 68498, 68504, 68509, 68520, 68528, 68607, 68681, 68735, 68787, 68799, 68851, 68857, 68904, 68911, 68922, 69215, 69247, 69247, 69290, 69290, 69294, 69295, 69298, 69375, 69416, 69423, 69466, 69551, 69580, 69599, 69623, 69631, 69710, 69713, 69744, 69758, 69821, 69821, 69826, 69839, 69865, 69871, 69882, 69887, 69941, 69941, 69960, 69967, 70007, 70015, 70112, 70112, 70133, 70143, 70162, 70162, 70207, 70271, 70279, 70279, 70281, 70281, 70286, 70286, 70302, 70302, 70314, 70319, 70379, 70383, 70394, 70399, 70404, 70404, 70413, 70414, 70417, 70418, 70441, 70441, 70449, 70449, 70452, 70452, 70458, 70458, 70469, 70470, 70473, 70474, 70478, 70479, 70481, 70486, 70488, 70492, 70500, 70501, 70509, 70511, 70517, 70655, 70748, 70748, 70754, 70783, 70856, 70863, 70874, 71039, 71094, 71095, 71134, 71167, 71237, 71247, 71258, 71263, 71277, 71295, 71353, 71359, 71370, 71423, 71451, 71452, 71468, 71471, 71488, 71679, 71740, 71839, 71923, 71934, 71943, 71944, 71946, 71947, 71956, 71956, 71959, 71959, 71990, 71990, 71993, 71994, 72007, 72015, 72026, 72095, 72104, 72105, 72152, 72153, 72165, 72191, 72264, 72271, 72355, 72383, 72441, 72703, 72713, 72713, 72759, 72759, 72774, 72783, 72813, 72815, 72848, 72849, 72872, 72872, 72887, 72959, 72967, 72967, 72970, 72970, 73015, 73017, 73019, 73019, 73022, 73022, 73032, 73039, 73050, 73055, 73062, 73062, 73065, 73065, 73103, 73103, 73106, 73106, 73113, 73119, 73130, 73439, 73465, 73647, 73649, 73663, 73714, 73726, 74650, 74751, 74863, 74863, 74869, 74879, 75076, 77823, 78895, 82943, 83527, 92159, 92729, 92735, 92767, 92767, 92778, 92781, 92784, 92879, 92910, 92911, 92918, 92927, 92998, 93007, 93018, 93018, 93026, 93026, 93048, 93052, 93072, 93759, 93851, 93951, 94027, 94030, 94088, 94094, 94112, 94175, 94181, 94191, 94194, 94207, 100344, 100351, 101590, 101631, 101641, 110591, 110879, 110927, 110931, 110947, 110952, 110959, 111356, 113663, 113771, 113775, 113789, 113791, 113801, 113807, 113818, 113819, 113824, 118783, 119030, 119039, 119079, 119080, 119155, 119162, 119273, 119295, 119366, 119519, 119540, 119551, 119639, 119647, 119673, 119807, 119893, 119893, 119965, 119965, 119968, 119969, 119971, 119972, 119975, 119976, 119981, 119981, 119994, 119994, 119996, 119996, 120004, 120004, 120070, 120070, 120075, 120076, 120085, 120085, 120093, 120093, 120122, 120122, 120127, 120127, 120133, 120133, 120135, 120137, 120145, 120145, 120486, 120487, 120780, 120781, 121484, 121498, 121504, 121504, 121520, 122879, 122887, 122887, 122905, 122906, 122914, 122914, 122917, 122917, 122923, 123135, 123181, 123183, 123198, 123199, 123210, 123213, 123216, 123583, 123642, 123646, 123648, 124927, 125125, 125126, 125143, 125183, 125260, 125263, 125274, 125277, 125280, 126064, 126133, 126208, 126270, 126463, 126468, 126468, 126496, 126496, 126499, 126499, 126501, 126502, 126504, 126504, 126515, 126515, 126520, 126520, 126522, 126522, 126524, 126529, 126531, 126534, 126536, 126536, 126538, 126538, 126540, 126540, 126544, 126544, 126547, 126547, 126549, 126550, 126552, 126552, 126554, 126554, 126556, 126556, 126558, 126558, 126560, 126560, 126563, 126563, 126565, 126566, 126571, 126571, 126579, 126579, 126584, 126584, 126589, 126589, 126591, 126591, 126602, 126602, 126620, 126624, 126628, 126628, 126634, 126634, 126652, 126703, 126706, 126975, 127020, 127023, 127124, 127135, 127151, 127152, 127168, 127168, 127184, 127184, 127222, 127231, 127406, 127461, 127491, 127503, 127548, 127551, 127561, 127567, 127570, 127583, 127590, 127743, 128728, 128735, 128749, 128751, 128765, 128767, 128884, 128895, 128985, 128991, 129004, 129023, 129036, 129039, 129096, 129103, 129114, 129119, 129160, 129167, 129198, 129199, 129202, 129279, 129401, 129401, 129484, 129484, 129620, 129631, 129646, 129647, 129653, 129655, 129659, 129663, 129671, 129679, 129705, 129711, 129719, 129727, 129731, 129743, 129751, 129791, 129939, 129939, 129995, 130031, 130042, 131071, 173790, 173823, 177973, 177983, 178206, 178207, 183970, 183983, 191457, 194559, 195102, 196607, 201547, 917759, 918e3, 1114111];
+function isPythonPrintable(point) {
+  let low = 0, high = excluded.length / 2;
+  while (low < high) {
+    const middle = low + high >>> 1;
+    if (point < excluded[middle * 2]) high = middle;
+    else if (point > excluded[middle * 2 + 1]) low = middle + 1;
+    else return false;
+  }
+  return true;
+}
+
+// packages/safe-bash-command-llm/src/embed-output.ts
+import { yieldTurn } from "../../safe-bash-contracts/yield.js";
+function floatText(value) {
+  if (Object.is(value, -0)) return "-0.0";
+  const magnitude = Math.abs(value);
+  if (magnitude !== 0 && (magnitude < 1e-4 || magnitude >= 1e16)) {
+    const [mantissa, exponent] = value.toExponential().split("e");
+    const number = Number(exponent);
+    return `${mantissa}e${number < 0 ? "-" : "+"}${String(Math.abs(number)).padStart(2, "0")}`;
+  }
+  return Number.isInteger(value) ? `${value}.0` : String(value);
+}
+async function* serializeLlmEmbedding(vector, format, signal) {
+  signal.throwIfAborted();
+  if (format !== "json") for (let index = 0; index < vector.length; index++) {
+    if (index && index % 4096 === 0) await yieldTurn(signal);
+    if (!Number.isFinite(Math.fround(vector[index]))) throw new RangeError("Embedding value exceeds float32 range");
+  }
+  const encoder = new TextEncoder();
+  async function* binary() {
+    for (let offset = 0; offset < vector.length; offset += 3072) {
+      signal.throwIfAborted();
+      const bytes = new Uint8Array(Math.min(3072, vector.length - offset) * 4), view = new DataView(bytes.buffer);
+      for (let index = 0; index < bytes.length / 4; index++) {
+        const value = vector[offset + index];
+        view.setFloat32(index * 4, value, true);
+      }
+      yield bytes;
+    }
+  }
+  if (format === "json") {
+    yield encoder.encode("[");
+    for (let index = 0; index < vector.length; index++) {
+      signal.throwIfAborted();
+      yield encoder.encode((index ? ", " : "") + floatText(vector[index]));
+    }
+    yield encoder.encode("]");
+  } else if (format === "base64") {
+    for await (const text of base64Stream(binary(), signal)) yield encoder.encode(text);
+  } else {
+    for await (const bytes of binary()) yield format === "blob" ? bytes : encoder.encode(Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join(""));
+  }
+  signal.throwIfAborted();
+  yield Uint8Array.of(10);
+}
+
+export {
+  isPythonPrintable,
+  floatText,
+  serializeLlmEmbedding,
+  fileSource,
+  createLlmSpool,
+  isPythonWhitespace,
+  stripPythonWhitespace
+};

package/dist/safe-bash/command-chunks/{chunk-YXR4JE4U.js → chunk-C3FERGHU.js}

@@ -1,16 +1,16 @@
 import {
   readTextBodies,
   validateTextReadingOptions
-} from "./chunk-YKODRSGT.js";
+} from "./chunk-FCGMSOF6.js";
 import {
   loadShared
-} from "./chunk-A5SPMSKD.js";
+} from "./chunk-UDRJKA3P.js";
 import {
   SelectionError
-} from "./chunk-NCNHJRIY.js";
+} from "./chunk-SKF6PGA5.js";
 import {
   OfficeError
-} from "./chunk-KM2SMMXZ.js";
+} from "./chunk-VJQ5OWS5.js";
 
 // packages/safe-bash-presentation-engine/src/fields.ts
 import { SaxesParser } from "saxes";

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

@@ -0,0 +1,279 @@
+import {
+  openRetainedMedia,
+  readMedia
+} from "./chunk-ZTW2E5OT.js";
+import {
+  readPackage
+} from "./chunk-KVTZJBLM.js";
+import {
+  readBinary
+} from "./chunk-S5MBHFLB.js";
+import {
+  OfficeError,
+  RetainedValues,
+  equal,
+  literal,
+  resolveOfficeResources
+} from "./chunk-VJQ5OWS5.js";
+
+// packages/safe-bash-presentation-engine/src/retained-media-extraction.ts
+import { PagedStorage } from "@poe-platform/safe-fs/storage";
+async function* joined(...sources) {
+  for (const source of sources) yield* source;
+}
+async function openRetainedMediaExtraction(archive, fingerprint, options = {}, settings) {
+  const context = { ...resolveOfficeResources(settings), workingStorage: { ...settings.workingStorage } }, signal = context.signal ?? new AbortController().signal;
+  signal.throwIfAborted();
+  validateMediaExtractionOptions(options);
+  const { maxOutputBytes = Infinity, maxOutputs = Infinity, deduplicate, ...selection } = options;
+  const reader = await openRetainedMedia(archive, fingerprint, selection, context);
+  const pages = new PagedStorage(
+    { fs: context.workingStorage.fs, cwd: context.workingStorage.directory, env: {}, signal },
+    (context.workingStorage.cacheBytes ?? 1024 * 1024) / 16384
+  );
+  let closed = false, closing, head = 0, tail = 0, count = 0, total = 0;
+  const check = () => {
+    if (closed) throw new OfficeError("invalid-handle", "Media extraction is closed.", "serialize");
+    if (signal.aborted) throw new OfficeError("cancelled", "Operation cancelled.", "serialize");
+  };
+  const failure = (error) => error instanceof OfficeError ? error : new OfficeError(
+    signal.aborted ? "cancelled" : "io-failure",
+    "Media extraction storage operation failed.",
+    "serialize"
+  );
+  const close = () => {
+    closed = true;
+    return closing ??= (async () => {
+      const results = await Promise.allSettled([reader.close(), pages.close()]);
+      for (const result of results) if (result.status === "rejected") throw result.reason;
+    })();
+  };
+  const values = new RetainedValues(pages, check, signal);
+  async function write(pointer, numbers) {
+    check();
+    const bytes = new Uint8Array(numbers.length * 8), view = new DataView(bytes.buffer);
+    numbers.forEach((n, i) => view.setFloat64(i * 8, n, true));
+    await pages.write(pointer, bytes);
+  }
+  async function row(pointer, length) {
+    check();
+    const bytes = await pages.read(pointer, length * 8), view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    return Array.from({ length }, (_, i) => view.getFloat64(i * 8, true));
+  }
+  async function text(range) {
+    let value = "";
+    const decoder = new TextDecoder();
+    for await (const bytes of values.read(range)) value += decoder.decode(bytes, { stream: true });
+    return value + decoder.decode();
+  }
+  async function provenance(group, field, key) {
+    if (!await values.insert("group:" + group + ":" + field, key, key)) return;
+    const entry = pages.allocate(24);
+    await write(entry, [0, key.start, key.length]);
+    const links = await row(group, 7);
+    if (links[field + 1]) await write(links[field + 1], [entry]);
+    else await write(group + field * 8, [entry]);
+    await write(group + (field + 1) * 8, [entry]);
+  }
+  try {
+    for await (const ref of reader.resources()) {
+      check();
+      if (ref.external || !ref.part || !ref.sha256 || ref.bytes === null)
+        throw new OfficeError(
+          "unsupported-edit",
+          "External media requires explicit local bytes for extraction.",
+          "select"
+        );
+      const part = await values.store(literal(ref.part));
+      if (!await values.insert("seen:" + ref.occurrence, part, part)) continue;
+      const identity = () => joined(ref.contentType ? ref.contentType() : literal(""), literal(":" + ref.sha256));
+      let group = deduplicate ? (await values.find("hashes", identity))?.start : void 0;
+      if (!group) {
+        total += ref.bytes;
+        if (!Number.isSafeInteger(total) || total > maxOutputBytes || count >= maxOutputs)
+          throw new OfficeError(
+            "resource-limit",
+            "Media extraction output limit exceeded.",
+            "serialize"
+          );
+        let extension = "bin";
+        if (ref.contentType) {
+          for (const [type2, suffix] of mediaExtensions)
+            if (await equal(ref.contentType(), literal(type2))) {
+              extension = suffix;
+              break;
+            }
+        }
+        const type = ref.contentType ? await values.store(ref.contentType()) : null;
+        const metadata = {
+          part: ref.part,
+          name: "part-" + String(++count).padStart(6, "0") + "." + extension,
+          size: ref.bytes,
+          sha256: ref.sha256,
+          contentType: type
+        };
+        const saved = await values.store(literal(JSON.stringify(metadata)));
+        group = pages.allocate(56);
+        await write(group, [0, saved.start, saved.length, 0, 0, 0, 0]);
+        if (tail) await write(tail, [group]);
+        else head = group;
+        tail = group;
+        if (deduplicate) {
+          const key = await values.store(identity());
+          await values.insert("hashes", key, { start: group, length: 56 });
+        }
+      }
+      await provenance(group, 3, part);
+      await provenance(group, 5, await values.store(ref.occurrenceId()));
+    }
+    await reader.close();
+    check();
+    async function* list(pointer) {
+      check();
+      for (; pointer; ) {
+        const item = await row(pointer, 3);
+        pointer = item[0];
+        const range = { start: item[1], length: item[2] };
+        yield () => values.read(range);
+      }
+      check();
+    }
+    return Object.freeze({
+      close,
+      count,
+      async *members() {
+        try {
+          check();
+          for (let pointer = head; pointer; ) {
+            const item = await row(pointer, 7);
+            pointer = item[0];
+            const metadata = JSON.parse(
+              await text({ start: item[1], length: item[2] })
+            );
+            yield {
+              ...metadata,
+              contentType: metadata.contentType ? () => values.read(metadata.contentType) : null,
+              sourceParts: () => list(item[3]),
+              occurrenceIds: () => list(item[5]),
+              async *bytes() {
+                check();
+                for await (const bytes of archive.read(metadata.part)) {
+                  check();
+                  yield bytes;
+                }
+                check();
+              }
+            };
+          }
+          check();
+        } catch (error) {
+          throw failure(error);
+        }
+      }
+    });
+  } catch (error) {
+    await close().catch(() => {
+    });
+    throw failure(error);
+  }
+}
+
+// packages/safe-bash-presentation-engine/src/media-extraction.ts
+var mediaExtensions = /* @__PURE__ */ new Map([
+  ["video/mp4", "mp4"],
+  ["audio/mp4", "m4a"],
+  ["video/quicktime", "mov"],
+  ["video/mpeg", "mpeg"],
+  ["audio/mpeg", "mp3"],
+  ["audio/wav", "wav"],
+  ["audio/x-wav", "wav"],
+  ["video/x-msvideo", "avi"],
+  ["video/x-ms-wmv", "wmv"],
+  ["audio/x-ms-wma", "wma"],
+  ["video/webm", "webm"],
+  ["audio/webm", "webm"],
+  ["video/ogg", "ogv"],
+  ["audio/ogg", "ogg"]
+]);
+function validateMediaExtractionOptions(options) {
+  if (!options || typeof options !== "object" || ![Object.prototype, null].includes(Object.getPrototypeOf(options)) || Reflect.ownKeys(options).some(
+    (key) => typeof key !== "string" || ![
+      "scope",
+      "slide",
+      "shape",
+      "select",
+      "maxOutputBytes",
+      "maxOutputs",
+      "deduplicate"
+    ].includes(key) || !("value" in Object.getOwnPropertyDescriptor(options, key))
+  ) || ![options.maxOutputBytes, options.maxOutputs].every(
+    (value) => value === void 0 || value === Infinity || Number.isSafeInteger(value) && value > 0
+  ) || options.deduplicate !== void 0 && typeof options.deduplicate !== "boolean")
+    throw new OfficeError("invalid-value", "Invalid media extraction options or limits.", "usage");
+}
+async function extractMedia(input, options = {}, settings = {}) {
+  const context = resolveOfficeResources(settings);
+  context.signal?.throwIfAborted();
+  validateMediaExtractionOptions(options);
+  const { maxOutputBytes = Infinity, maxOutputs = Infinity, deduplicate, ...selection } = options;
+  const source = await readBinary(input, context);
+  const inventory = await readMedia(source, selection, context);
+  const groups = [];
+  const hashes = /* @__PURE__ */ new Map();
+  let total = 0;
+  let processed = 0;
+  for (const occurrence of inventory.occurrences) {
+    const seen = /* @__PURE__ */ new Set();
+    for (const ref of occurrence.relationships) {
+      if (++processed % 64 === 0) await new Promise((resolve) => setTimeout(resolve, 0));
+      context.signal?.throwIfAborted();
+      if (ref.external || !ref.mediaPart || !ref.sha256 || ref.bytes === null)
+        throw new OfficeError(
+          "unsupported-edit",
+          "External media requires explicit local bytes for extraction.",
+          "select"
+        );
+      if (seen.has(ref.mediaPart)) continue;
+      seen.add(ref.mediaPart);
+      const key = `${ref.contentType ?? ""}:${ref.sha256}`;
+      const existing = deduplicate ? hashes.get(key) : void 0;
+      if (existing) {
+        existing.parts.add(ref.mediaPart);
+        existing.ids.add(occurrence.id);
+        continue;
+      }
+      total += ref.bytes;
+      if (!Number.isSafeInteger(total) || total > maxOutputBytes || groups.length >= maxOutputs)
+        throw new OfficeError(
+          "resource-limit",
+          "Media extraction output limit exceeded.",
+          "serialize"
+        );
+      const group = { ref, parts: /* @__PURE__ */ new Set([ref.mediaPart]), ids: /* @__PURE__ */ new Set([occurrence.id]) };
+      groups.push(group);
+      hashes.set(key, group);
+    }
+  }
+  const reader = await readPackage(source, context);
+  const outputs = [];
+  for (const [index, group] of groups.entries()) {
+    if (index > 0 && index % 64 === 0) await new Promise((resolve) => setTimeout(resolve, 0));
+    context.signal?.throwIfAborted();
+    outputs.push({
+      name: `part-${String(index + 1).padStart(6, "0")}.${mediaExtensions.get(group.ref.contentType ?? "") ?? "bin"}`,
+      bytes: reader.get(group.ref.mediaPart),
+      sha256: group.ref.sha256,
+      contentType: group.ref.contentType,
+      sourceParts: [...group.parts],
+      occurrenceIds: [...group.ids]
+    });
+  }
+  return outputs;
+}
+
+export {
+  openRetainedMediaExtraction,
+  mediaExtensions,
+  validateMediaExtractionOptions,
+  extractMedia
+};

package/dist/safe-bash/command-chunks/{chunk-5O45KGW5.js → chunk-C5VUJOUQ.js}

@@ -1,6 +1,6 @@
 import {
   UnsupportedEditError
-} from "./chunk-LZY46GYY.js";
+} from "./chunk-QMWBKR4C.js";
 
 // packages/safe-bash-docx-engine/src/table-rows.ts
 var w15 = "http://schemas.microsoft.com/office/word/2012/wordml";

package/dist/safe-bash/command-chunks/{chunk-T4SEQU66.js → chunk-CI6KHUFK.js}

@@ -1,15 +1,15 @@
 import {
   measurePackageResourceSerialization
-} from "./chunk-RTHYAGKI.js";
-import {
-  validateDocxInvocation
-} from "./chunk-ZM7HMBAJ.js";
+} from "./chunk-KD4JUF6R.js";
 import {
   readDocumentArchive
 } from "./chunk-5BUL25DF.js";
+import {
+  validateDocxInvocation
+} from "./chunk-BDGNKRY4.js";
 import {
   UnsupportedEditError
-} from "./chunk-LZY46GYY.js";
+} from "./chunk-QMWBKR4C.js";
 import {
   documentDialects
 } from "./chunk-WLANDWNW.js";