@poe-platform/safe-bash 0.1.806 → 0.1.807

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

@@ -0,0 +1,134 @@
+// packages/safe-bash-presentation-engine/src/image-metadata.ts
+function normalizeImageDpi(value) {
+  const axes = Array.isArray(value) ? value : [];
+  const axis = (raw) => {
+    if (typeof raw !== "number" || !Number.isFinite(raw)) return 72;
+    const lower = Math.floor(raw);
+    const rounded = raw - lower === 0.5 ? lower + (lower % 2 === 0 ? 0 : 1) : Math.round(raw);
+    return rounded >= 1 && rounded <= 2048 ? rounded : 72;
+  };
+  return [axis(axes[0]), axis(axes[1])];
+}
+function tiffMetadata(bytes) {
+  const result = { pixelWidth: null, pixelHeight: null, dpiX: 72, dpiY: 72 };
+  if (bytes.length < 8) return result;
+  const little = bytes[0] === 73 && bytes[1] === 73;
+  if (!little && !(bytes[0] === 77 && bytes[1] === 77)) return result;
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  if (view.getUint16(2, little) !== 42) return result;
+  const start = view.getUint32(4, little);
+  if (start < 8 || start > bytes.length - 2) return result;
+  const count = view.getUint16(start, little);
+  if (count > Math.floor((bytes.length - start - 2) / 12)) return result;
+  let x, y, unit = 2;
+  for (let index = 0; index < count; index++) {
+    const offset = start + 2 + index * 12;
+    const tag = view.getUint16(offset, little), type = view.getUint16(offset + 2, little);
+    if (view.getUint32(offset + 4, little) !== 1) continue;
+    let value;
+    if (type === 3) value = view.getUint16(offset + 8, little);
+    if (type === 4) value = view.getUint32(offset + 8, little);
+    if (type === 5) {
+      const pointer = view.getUint32(offset + 8, little);
+      if (pointer <= bytes.length - 8) {
+        const denominator = view.getUint32(pointer + 4, little);
+        if (denominator !== 0) value = view.getUint32(pointer, little) / denominator;
+      }
+    }
+    if (value === void 0) continue;
+    if (tag === 256 && (type === 3 || type === 4) && value > 0) result.pixelWidth = value;
+    if (tag === 257 && (type === 3 || type === 4) && value > 0) result.pixelHeight = value;
+    if (tag === 282) x = value;
+    if (tag === 283) y = value;
+    if (tag === 296) unit = value;
+  }
+  const multiplier = unit === 3 ? 2.54 : unit === 2 ? 1 : 0;
+  [result.dpiX, result.dpiY] = normalizeImageDpi([
+    x === void 0 ? null : x * multiplier,
+    y === void 0 ? null : y * multiplier
+  ]);
+  return result;
+}
+function imageMetadata(bytes, mediaType) {
+  if (mediaType === "image/tiff") return tiffMetadata(bytes);
+  const result = { pixelWidth: null, pixelHeight: null, dpiX: 72, dpiY: 72 };
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const matches = (offset, values) => values.every((value, index) => bytes[offset + index] === value);
+  if (mediaType === "image/x-wmf" && bytes.length >= 22 && view.getUint32(0, true) === 2596720087) {
+    const units = view.getUint16(14, true);
+    const width = view.getInt16(10, true) - view.getInt16(6, true);
+    const height = view.getInt16(12, true) - view.getInt16(8, true);
+    if (units && width > 0 && height > 0) {
+      result.pixelWidth = Math.max(1, Math.floor(width * 72 / units));
+      result.pixelHeight = Math.max(1, Math.floor(height * 72 / units));
+    }
+  } else if (mediaType === "image/png" && bytes.length >= 33 && matches(0, [137, 80, 78, 71, 13, 10, 26, 10]) && view.getUint32(8) === 13 && matches(12, [73, 72, 68, 82])) {
+    result.pixelWidth = view.getUint32(16) || null;
+    result.pixelHeight = view.getUint32(20) || null;
+    let offset = 33;
+    while (offset <= bytes.length - 12) {
+      const length = view.getUint32(offset);
+      if (length > bytes.length - offset - 12) break;
+      if (matches(offset + 4, [112, 72, 89, 115]) && length === 9 && bytes[offset + 16] === 1) {
+        [result.dpiX, result.dpiY] = normalizeImageDpi([
+          view.getUint32(offset + 8) * 0.0254,
+          view.getUint32(offset + 12) * 0.0254
+        ]);
+      }
+      if (matches(offset + 4, [73, 69, 78, 68])) break;
+      offset += length + 12;
+    }
+  } else if (mediaType === "image/gif" && bytes.length >= 13 && (matches(0, [71, 73, 70, 56, 55, 97]) || matches(0, [71, 73, 70, 56, 57, 97]))) {
+    result.pixelWidth = view.getUint16(6, true) || null;
+    result.pixelHeight = view.getUint16(8, true) || null;
+  } else if (mediaType === "image/bmp" && bytes.length >= 26 && matches(0, [66, 77])) {
+    const headerSize = view.getUint32(14, true);
+    if (headerSize === 12) {
+      result.pixelWidth = view.getUint16(18, true) || null;
+      result.pixelHeight = view.getUint16(20, true) || null;
+    } else if (headerSize >= 40 && headerSize <= bytes.length - 14) {
+      const width = view.getInt32(18, true), height = view.getInt32(22, true);
+      result.pixelWidth = width > 0 ? width : null;
+      result.pixelHeight = Math.abs(height) || null;
+      [result.dpiX, result.dpiY] = normalizeImageDpi([
+        view.getInt32(38, true) * 0.0254,
+        view.getInt32(42, true) * 0.0254
+      ]);
+    }
+  } else if (mediaType === "image/jpeg" && matches(0, [255, 216])) {
+    let offset = 2;
+    while (offset < bytes.length) {
+      if (bytes[offset++] !== 255) break;
+      while (bytes[offset] === 255) offset++;
+      const marker = bytes[offset++];
+      if (marker === void 0 || marker === 217 || marker === 218) break;
+      if (marker === 1 || marker >= 208 && marker <= 215) continue;
+      if (offset > bytes.length - 2) break;
+      const length = view.getUint16(offset);
+      if (length < 2 || length > bytes.length - offset) break;
+      if ([192, 193, 194, 195, 197, 198, 199, 201, 202, 203, 205, 206, 207].includes(marker) && length >= 8) {
+        result.pixelHeight = view.getUint16(offset + 3) || null;
+        result.pixelWidth = view.getUint16(offset + 5) || null;
+      }
+      if (marker === 224 && length >= 16 && matches(offset + 2, [74, 70, 73, 70, 0])) {
+        const unit = bytes[offset + 9], multiplier = unit === 1 ? 1 : unit === 2 ? 2.54 : 0;
+        [result.dpiX, result.dpiY] = normalizeImageDpi([
+          view.getUint16(offset + 10) * multiplier,
+          view.getUint16(offset + 12) * multiplier
+        ]);
+      }
+      if (marker === 225 && length >= 16 && matches(offset + 2, [69, 120, 105, 102, 0, 0])) {
+        const metadata = tiffMetadata(bytes.subarray(offset + 8, offset + length));
+        result.dpiX = metadata.dpiX;
+        result.dpiY = metadata.dpiY;
+      }
+      offset += length;
+    }
+  }
+  return result;
+}
+
+export {
+  normalizeImageDpi,
+  imageMetadata
+};

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

@@ -0,0 +1,272 @@
+import {
+  sectionState
+} from "./chunk-L2JAP5KO.js";
+import {
+  openDocumentLocations
+} from "./chunk-LHDB4QO5.js";
+import {
+  validateDocxInvocation
+} from "./chunk-DE66JRWJ.js";
+import {
+  sectionAttribute
+} from "./chunk-VU3YUC3U.js";
+import {
+  paragraphTextRun,
+  replaceParagraphContent
+} from "./chunk-GGOZXIGH.js";
+import {
+  findRelationshipPart,
+  retainedRelationshipTargets
+} from "./chunk-4LXDJES2.js";
+import {
+  assertDocumentEditable,
+  publishDocumentArchive
+} from "./chunk-HPKUFWHW.js";
+import {
+  DocumentPackage
+} from "./chunk-GLPIFP7N.js";
+import {
+  DocumentXmlEditor,
+  UnsupportedEditError,
+  activeXmlChildren,
+  editActiveRelationshipXml,
+  xmlValue
+} from "./chunk-YPVBU7QF.js";
+import {
+  relationshipXmlRows
+} from "./chunk-2PSVE7I5.js";
+import {
+  documentDialects
+} from "./chunk-MG7AJD5E.js";
+import {
+  compatibilityContainers
+} from "./chunk-GZ2N24A2.js";
+import {
+  SelectionError,
+  closedRecord,
+  encodeGeneratedLocation
+} from "./chunk-LQOKYG3O.js";
+import {
+  asciiKey,
+  relativePartTarget
+} from "./chunk-WAKYUXVQ.js";
+import {
+  parseDocumentXml
+} from "./chunk-MWAAMNAM.js";
+import {
+  DocxUsageError
+} from "./chunk-2P7BLWWI.js";
+import {
+  archiveSettings
+} from "./chunk-IQFRPIXH.js";
+
+// packages/safe-bash-docx-engine/src/stories.ts
+var variants = ["default", "first", "even"];
+var relNamespace = "http://schemas.openxmlformats.org/package/2006/relationships";
+var typeNamespace = "http://schemas.openxmlformats.org/package/2006/content-types";
+function relationshipName(part) {
+  const split = part.lastIndexOf("/");
+  return part.slice(0, split + 1) + "_rels/" + part.slice(split + 1) + ".rels";
+}
+function selectedSections(document, items, options, kind) {
+  if (options.select !== void 0) {
+    const location = document.resolve(options.select);
+    if (location.kind === "section") return items.filter((item) => item.location.token === location.token);
+    if (location.kind !== "story" || !document.list("story", { scope: kind }).some((s) => s.token === location.token)) throw new SelectionError("missing-selection");
+    const found = items.filter((item) => item[kind][options.variant ?? "default"].part === location.value.part);
+    if (!found.length) throw new SelectionError("missing-selection");
+    if (found.length !== 1) throw new SelectionError("ambiguous-selection");
+    return found;
+  }
+  return options.section === void 0 ? items : items.filter((item) => item.position === options.section);
+}
+function partOwners(items, part) {
+  return part === null ? [] : items.filter((item) => ["headers", "footers"].some((kind) => variants.some((variant) => item[kind][variant].part === part))).map((item) => item.position);
+}
+async function inspectDocumentStories(input, request, context) {
+  closedRecord(request, ["operation", "options"]);
+  if (!["headers.list", "headers.get", "footers.list", "footers.get"].includes(request.operation)) throw new DocxUsageError("Expected a story read operation.");
+  const settings = archiveSettings(context);
+  const invocation = validateDocxInvocation({ operation: request.operation, inputs: ["document"], options: request.options }, settings.budget);
+  const opts = invocation.options;
+  const budget = settings.budget.lower(Object.fromEntries((opts.limit ?? []).map((item) => [item.name, item.value])));
+  const document = await openDocumentLocations(input, { ...settings, budget });
+  const current = sectionState(document, document.snapshot(), { ...settings, budget });
+  const kind = request.operation.split(".")[0];
+  const selected = selectedSections(document, current.items, opts, kind);
+  if (!selected.length && request.operation.endsWith(".get")) throw new SelectionError("missing-selection");
+  const stories = document.list("story", { scope: kind });
+  const text = /* @__PURE__ */ new Map();
+  const items = [];
+  for (const item of selected) for (const variant of request.operation.endsWith(".list") ? variants : [opts.variant ?? "default"]) {
+    budget.charge("work", 1 + stories.length + current.items.length * 6);
+    budget.check("matches", items.length + 1);
+    const binding = item[kind][variant];
+    const location = stories.find((story) => story.value.part === binding.part) ?? item.location;
+    if (binding.part && !text.has(binding.part)) text.set(binding.part, document.text({ select: location.token }).text);
+    items.push({
+      kind,
+      section: item.position,
+      variant,
+      part: binding.part,
+      linked: binding.linkedToPrevious,
+      sourceSection: binding.sourceSection,
+      owners: partOwners(current.items, binding.part),
+      location,
+      text: binding.part ? text.get(binding.part) : ""
+    });
+  }
+  const data = { items };
+  budget.check("serializedOutput", new TextEncoder().encode(JSON.stringify(data)).length);
+  return data;
+}
+async function editDocumentStories(input, request, context) {
+  closedRecord(request, ["operation", "options", "input"]);
+  if (!["headers.set", "headers.remove", "footers.set", "footers.remove"].includes(request.operation)) throw new DocxUsageError("Expected a story editing operation.");
+  const settings = archiveSettings(context);
+  const invocation = validateDocxInvocation({ operation: request.operation, inputs: [request.input?.path ?? "document"], options: request.options }, settings.budget);
+  const opts = invocation.options;
+  if (opts.shared && opts.linkToPrevious !== void 0) throw new DocxUsageError("Shared editing and binding changes conflict.");
+  const budget = settings.budget.lower(Object.fromEntries((opts.limit ?? []).map((item2) => [item2.name, item2.value])));
+  const document = await openDocumentLocations(input, { ...settings, budget });
+  const archive = document.snapshot();
+  assertDocumentEditable(archive, { ...settings, budget });
+  const current = sectionState(document, archive, { ...settings, budget });
+  const { xml, main, graph, owners, items } = current;
+  const kind = request.operation.split(".")[0], variant = opts.variant ?? "default";
+  const selected = selectedSections(document, items, opts, kind);
+  if (!selected.length) throw new SelectionError("missing-selection");
+  if (selected.length !== 1) throw new SelectionError("ambiguous-selection");
+  const item = selected[0], binding = item[kind][variant], name = kind === "headers" ? "header" : "footer";
+  const remove = request.operation.endsWith(".remove"), link = opts.linkToPrevious === true;
+  if (link && item.position === 1) throw new DocxUsageError("The initial section cannot link to a previous section.");
+  budget.charge("work", items.length * 6);
+  const slots = items.flatMap((section) => variants.filter((v) => section[kind][v].part === binding.part));
+  if (!remove && !link && opts.linkToPrevious !== false && !opts.shared && (binding.linkedToPrevious || slots.length > 1)) throw new SelectionError("ambiguous-selection");
+  if (opts.shared && !binding.part) throw new SelectionError("missing-selection");
+  if (remove && binding.linkedToPrevious && !opts.allowEmpty) throw new SelectionError("missing-selection");
+  const w = xml.root.namespace, r = documentDialects[current.dialect].r;
+  const staged = /* @__PURE__ */ new Map();
+  const deleted = /* @__PURE__ */ new Set();
+  const relName = findRelationshipPart(graph, "/" + main, budget)?.name ?? relationshipName(main);
+  const relMember = archive.members.find((member) => member.name === relName);
+  let relXml = new DocumentXmlEditor(relMember?.bytes ?? new TextEncoder().encode(`<Relationships xmlns="${relNamespace}"/>`), {}, void 0, budget);
+  const types = new DocumentXmlEditor(archive.members.find((member) => member.name === "[Content_Types].xml").bytes, {}, void 0, budget);
+  const refs = /* @__PURE__ */ new Map();
+  const newTypes = [], newRelationships = [];
+  const edgeFor = (part) => graph.relationships("/" + main).find((edge) => !edge.is_external && edge.reltype === r + "/" + name && edge.target_part.partname === part);
+  const clone = (source) => {
+    const directory = source ? source.slice(0, source.lastIndexOf("/") + 1) : "/" + main.slice(0, main.lastIndexOf("/") + 1);
+    const part = graph.allocatePartName(directory + name, ".xml"), id = graph.allocateRelationshipId("/" + main);
+    const sourcePart = source ? graph.getPart(source) : void 0;
+    const bytes = sourcePart?.bytes ?? new TextEncoder().encode(`<w:${name === "header" ? "hdr" : "ftr"} xmlns:w="${w}"><w:p/></w:${name === "header" ? "hdr" : "ftr"}>`);
+    staged.set(part.slice(1), bytes);
+    const relationships = sourcePart && findRelationshipPart(graph, sourcePart.partname, budget);
+    if (relationships) staged.set(relationshipName(part.slice(1)), relationships.bytes);
+    newTypes.push(`<Override xmlns="${typeNamespace}" PartName="${xmlValue(part)}" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.${name}+xml"/>`);
+    newRelationships.push(`<Relationship xmlns="${relNamespace}" Id="${id}" Type="${r}/${name}" Target="${xmlValue(relativePartTarget("/" + main, part))}"/>`);
+    return { part, id };
+  };
+  let target = binding.part;
+  let changed = remove ? !binding.linkedToPrevious : link ? !binding.linkedToPrevious : opts.linkToPrevious === false || opts.text !== void 0;
+  if (changed && !opts.shared && (remove || link || opts.linkToPrevious === false)) {
+    const next = items[item.position];
+    if (next?.[kind][variant].linkedToPrevious) refs.set(next.position, binding.part ? edgeFor(binding.part).rId : clone(null).id);
+    if (remove || link) {
+      refs.set(item.position, null);
+      target = null;
+    } else {
+      const copied = clone(binding.part);
+      refs.set(item.position, copied.id);
+      target = copied.part;
+    }
+  }
+  if (opts.text !== void 0 && target) {
+    const targetName = staged.has(target.slice(1)) ? target.slice(1) : graph.getPart(target).name;
+    const story = new DocumentXmlEditor(staged.get(targetName) ?? graph.getPart(target).bytes, {}, void 0, budget);
+    const projected = activeXmlChildren(story, budget), paragraphs = projected(story.root);
+    const containers = new Set(story.compatibility[compatibilityContainers]);
+    if (story.root.children.some((child) => !containers.has(child) && (child.namespace !== w || child.localName !== "p")))
+      throw new UnsupportedEditError("Story text assignment cannot discard tables or opaque blocks; use scoped content operations.");
+    const patches = /* @__PURE__ */ new Map();
+    for (const [index, child] of paragraphs.entries()) {
+      if (child.namespace !== w || child.localName !== "p") throw new UnsupportedEditError("Story text assignment cannot discard tables or opaque blocks; use scoped content operations.");
+      if (index && (child.children.some((c) => !["pPr", "r", "hyperlink"].includes(c.localName)) || child.content.some((c) => c.kind !== "element" && (c.kind !== "text" || c.text.trim()))))
+        throw new UnsupportedEditError("Story text assignment cannot remove paragraph annotations.");
+      const props = projected(child).find((c) => c.namespace === w && c.localName === "pPr");
+      const replacement = replaceParagraphContent(story, child, props ? story.sourceXml(props) : "", index ? "" : opts.text, budget);
+      patches.set(child, index ? "" : replacement);
+    }
+    const plain = (node) => node.namespace === w && ["p", "r", "t"].includes(node.localName) && node.attributes.every((a) => a.namespace === "http://www.w3.org/XML/1998/namespace" && a.localName === "space") && node.children.every(plain);
+    const plainText = (node) => node.localName === "t" ? node.text : node.children.map(plainText).join("");
+    const same = story.root.children.length === 1 && plain(story.root.children[0]) && plainText(story.root.children[0]) === opts.text;
+    if (same) {
+      if (!refs.size) changed = false;
+    } else {
+      if (patches.size) for (const [child, replacement] of patches) story.replaceElement(child, replacement);
+      else story.insertChildren(story.root, `<pi:p xmlns:pi="${w}">${paragraphTextRun(w, opts.text)}</pi:p>`);
+      staged.set(targetName, story.serialize());
+    }
+  }
+  const removedIds = /* @__PURE__ */ new Set();
+  for (const [position, id] of refs) {
+    const owner = owners[position - 1];
+    const old = owner.node && current.children(owner.node).find((node) => node.namespace === w && node.localName === name + "Reference" && sectionAttribute(node, "type") === variant);
+    const oldId = old?.attributes.find((a) => a.namespace === r && a.localName === "id")?.value;
+    if (oldId) removedIds.add(oldId);
+    const markup = id === null ? "" : `<sb:${name}Reference xmlns:sb="${w}" xmlns:sr="${r}" sb:type="${variant}" sr:id="${xmlValue(id)}"/>`;
+    if (old) xml.replaceElement(old, markup);
+    else if (markup && owner.node) xml.insertChildren(owner.node, markup, owner.node.children.find((n) => name === "header" ? n.localName !== "headerReference" : !["headerReference", "footerReference"].includes(n.localName)));
+    else if (markup) xml.insertChildren(current.body, `<sb:sectPr xmlns:sb="${w}">${markup}</sb:sectPr>`);
+  }
+  staged.set(main, xml.serialize());
+  const used = /* @__PURE__ */ new Set();
+  const visit = (node) => {
+    budget.charge("work", 1);
+    for (const a of node.attributes) if (a.namespace === r) used.add(a.value);
+    for (const child of node.children) visit(child);
+  };
+  visit(parseDocumentXml(staged.get(main), {}, budget).root);
+  const candidates = /* @__PURE__ */ new Set();
+  for (const { element: node, rId: id } of relationshipXmlRows(relXml.root, budget)) {
+    if (!id || !removedIds.has(id) || used.has(id)) continue;
+    const edge = graph.relationships("/" + main).find((edge2) => edge2.rId === id);
+    if (!edge.is_external) candidates.add(edge.target_part.partname);
+    relXml[editActiveRelationshipXml](node, null);
+  }
+  relXml = new DocumentXmlEditor(relXml.serialize(), {}, void 0, budget);
+  if (newRelationships.length) relXml.insertChildren(relXml.root, newRelationships.join(""));
+  if (newTypes.length) types.insertChildren(types.root, newTypes.join(""));
+  staged.set(relName, relXml.serialize());
+  staged.set("[Content_Types].xml", types.serialize());
+  const snapshot = () => ({ ...archive, members: [
+    ...archive.members.filter((m) => !deleted.has(m.name)).map((m) => ({ ...m, bytes: staged.get(m.name) ?? m.bytes })),
+    ...[...staged].filter(([name2]) => !deleted.has(name2) && !archive.members.some((m) => m.name === name2)).map(([name2, bytes]) => ({ name: name2, bytes, directory: false, modified: /* @__PURE__ */ new Date("1980-01-01T00:00:00Z") }))
+  ] });
+  const candidateGraph = new DocumentPackage(snapshot(), settings.limits, budget);
+  const retainedTargets = retainedRelationshipTargets(candidateGraph, budget);
+  for (const part of candidates) {
+    const incoming = retainedTargets.has(asciiKey(part));
+    if (incoming) continue;
+    deleted.add(part.slice(1));
+    deleted.add(relationshipName(part.slice(1)));
+    for (const node of types.root.children) if (node.localName === "Override" && node.attributes.some((a) => a.localName === "PartName" && a.value === part)) types.replaceElement(node, "");
+  }
+  staged.set("[Content_Types].xml", types.serialize());
+  const affectedSections = changed ? opts.shared ? partOwners(items, binding.part) : [item.position] : [];
+  const changes = affectedSections.map((position) => {
+    const before = items[position - 1].location;
+    const owner = owners[position - 1];
+    const value = { ...before.value, generation: 1, path: owner.node || !refs.get(position) ? before.value.path : [...before.value.path, current.body.children.length] };
+    return { kind: remove ? "remove" : opts.text === void 0 ? "bind" : "replace", before, after: { ...before, value, token: encodeGeneratedLocation(value) } };
+  });
+  const publication = { ...request.input ? { input: request.input } : {}, ...opts.output === void 0 ? {} : { output: opts.output }, ...opts.inPlace === void 0 ? {} : { inPlace: opts.inPlace }, ...opts.force === void 0 ? {} : { force: opts.force }, ...opts.dryRun === void 0 ? {} : { dryRun: opts.dryRun }, ...opts.json === void 0 ? {} : { json: opts.json } };
+  budget.check("serializedOutput", new TextEncoder().encode(JSON.stringify({ version: 1, operation: request.operation, ok: true, data: { changed, affectedSections, changes, dryRun: opts.dryRun ?? false, output: { path: opts.output ?? request.input?.path ?? null, bytes: Math.min(settings.limits.maxArchiveBytes, Number.MAX_SAFE_INTEGER), sha256: "0".repeat(64) } }, affected: changes.length, locations: changes.map((c) => c.after), warnings: [], errors: [] })).length + 1);
+  const result = await publishDocumentArchive(snapshot(), publication, { ...context, budget });
+  return { changed, affectedSections, changes, dryRun: opts.dryRun ?? false, output: result.published.length ? { path: result.published[0].path, bytes: result.published[0].bytes, sha256: result.archiveSha256 } : null };
+}
+
+export {
+  inspectDocumentStories,
+  editDocumentStories
+};

package/dist/safe-bash/command-chunks/{chunk-5FMXQUDY.js → chunk-UZOGSYJP.js}

@@ -1,6 +1,6 @@
 import {
   SafeJsCommandLimitError
-} from "./chunk-G3YO3JIN.js";
+} from "./chunk-JJK3CU7Z.js";
 
 // packages/safe-bash-command-node/src/commands/node/source-maps.ts
 import { decodeBytes, encodeBytes } from "../../safe-bash-io-engine/byte-encoding.js";

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

@@ -0,0 +1,125 @@
+// packages/safe-bash-command-llm/src/retained-spool.ts
+import { FsError } 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 FsError("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 FsError("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 FsError("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 FsError) || error.code !== "EEXIST") throw error;
+    }
+  }
+  if (!staging) throw new FsError("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 FsError("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 FsError("EBADF", { message: "LLM spool is closed" });
+      if (writing) throw new FsError("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 FsError("EBADF", { message: "LLM spool is closed" });
+      if (active || writing) throw new FsError("EBUSY", { message: "LLM spool is in use" });
+      active = true;
+      try {
+        sealing ??= (async () => {
+          sealed = await writer.finish({ signal });
+          if (sealed.size !== written) throw new FsError("EIO", { message: "LLM spool size mismatch" });
+          signal.throwIfAborted();
+          if (closing) throw new FsError("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 FsError("EBADF", { message: "LLM spool is closed" });
+          }
+          reader = opened;
+        })();
+        await sealing;
+        signal.throwIfAborted();
+        if (closing || !reader) throw new FsError("EBADF", { message: "LLM spool is closed" });
+        verifyRetainedFile(await reader.stat({ signal }), sealed);
+        const read = async (position2, maxBytes) => {
+          signal.throwIfAborted();
+          if (closing || !reader) throw new FsError("EBADF", { message: "LLM spool is closed" });
+          if (!Number.isSafeInteger(position2) || position2 < 0 || position2 >= written || !Number.isSafeInteger(maxBytes) || maxBytes <= 0 || maxBytes > 16384) throw new FsError("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 FsError("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 FsError("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;
+    }
+  };
+}
+
+export {
+  createLlmSpool
+};