@poe-platform/safe-bash 0.1.806 → 0.1.807

package/dist/safe-bash/command-chunks/chunk-2VGAC6S6.js

@@ -0,0 +1,393 @@
+import {
+  openDocumentLocations,
+  resolveDocxSelection
+} from "./chunk-LHDB4QO5.js";
+import {
+  measurePackageResourceSerialization
+} from "./chunk-W6DV2CLS.js";
+import {
+  validateDocxInvocation
+} from "./chunk-DE66JRWJ.js";
+import {
+  publishDocumentFiles
+} from "./chunk-HPKUFWHW.js";
+import {
+  PublicationError
+} from "./chunk-JGGRMERW.js";
+import {
+  DocumentPackage
+} from "./chunk-GLPIFP7N.js";
+import {
+  documentDialects
+} from "./chunk-MG7AJD5E.js";
+import {
+  docxOperationSchemas
+} from "./chunk-R4TYL2G6.js";
+import {
+  closedRecord
+} from "./chunk-LQOKYG3O.js";
+import {
+  parseDocumentXml,
+  parseMediaType
+} from "./chunk-MWAAMNAM.js";
+import {
+  DocxUsageError
+} from "./chunk-2P7BLWWI.js";
+import {
+  CancellationError,
+  archiveSettings
+} from "./chunk-IQFRPIXH.js";
+
+// packages/safe-bash-docx-engine/src/images.ts
+import { resolvePath } from "@poe-platform/safe-fs/core";
+var ImageExtractionPublicationError = class extends PublicationError {
+  constructor(error, data) {
+    super(error.code, error.message, error.published, error.stdoutMayBePartial, { cause: error });
+    this.data = data;
+  }
+  data;
+};
+var ImageExtractionCancellationError = class extends CancellationError {
+  constructor(error, data, published) {
+    super(error.message, { cause: error });
+    this.data = data;
+    this.published = published;
+  }
+  data;
+  published;
+};
+var svg = "http://schemas.microsoft.com/office/drawing/2016/SVG/main";
+var decorativeNamespace = "http://schemas.microsoft.com/office/drawing/2017/decorative";
+function ownData(value, keys) {
+  if (!value || typeof value !== "object" || Array.isArray(value) || ![Object.prototype, null].includes(Object.getPrototypeOf(value))) throw new DocxUsageError("Expected plain owned image option data.");
+  const result = /* @__PURE__ */ Object.create(null);
+  for (const key of Reflect.ownKeys(value)) {
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    if (typeof key !== "string" || ["__proto__", "constructor", "prototype"].includes(key) || keys && !keys.includes(key) || !("value" in descriptor)) throw new DocxUsageError("Image option accessors and unknown fields are not permitted.");
+    result[key] = descriptor.value;
+  }
+  return result;
+}
+var attribute = (node, name, namespace = "") => node?.attributes.find((attribute2) => attribute2.namespace === namespace && attribute2.localName === name)?.value;
+function nativeToken(value) {
+  if (value === void 0) return void 0;
+  let start = 0, end = value.length;
+  while (start < end && " 	\r\n".includes(value[start])) start++;
+  while (end > start && " 	\r\n".includes(value[end - 1])) end--;
+  return value.slice(start, end);
+}
+function integer(value, minimum, maximum = Number.MAX_SAFE_INTEGER) {
+  const token = nativeToken(value);
+  if (token === void 0 || !token || token.length > 32 || [...token].some((char, index) => !(char >= "0" && char <= "9") && !(index === 0 && ["-", "+"].includes(char)))) return null;
+  const result = Number(token);
+  return Number.isSafeInteger(result) && result >= minimum && result <= maximum ? result : null;
+}
+function boolean(value) {
+  const token = nativeToken(value);
+  return token === "1" || token === "true" ? true : token === "0" || token === "false" ? false : null;
+}
+async function hash(bytes, budget) {
+  budget.charge("work", bytes.length);
+  budget.charge("retainedBytes", bytes.length + 128);
+  const digest = new Uint8Array(await crypto.subtle.digest("SHA-256", new Uint8Array(bytes)));
+  budget.check("work", 0);
+  return [...digest].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function mediaType(bytes, declared, budget) {
+  budget.charge("work", Math.min(bytes.length, 64));
+  const begins = (...signature) => bytes.length >= signature.length && signature.every((value, index) => bytes[index] === value);
+  if (begins(137, 80, 78, 71, 13, 10, 26, 10)) return "image/png";
+  if (begins(255, 216, 255)) return "image/jpeg";
+  if (begins(71, 73, 70, 56, 55, 97) || begins(71, 73, 70, 56, 57, 97)) return "image/gif";
+  if (begins(66, 77)) return "image/bmp";
+  if (begins(73, 73, 42, 0) || begins(77, 77, 0, 42)) return "image/tiff";
+  if (begins(73, 73, 188, 1)) return "image/vnd.ms-photo";
+  if (bytes.length >= 44 && begins(1, 0, 0, 0) && bytes[40] === 32 && bytes[41] === 69 && bytes[42] === 77 && bytes[43] === 70) return "image/emf";
+  if (bytes.length >= 22 && begins(215, 205, 198, 154)) return "image/wmf";
+  if (declared.toLowerCase() === "image/svg+xml") {
+    try {
+      const root = parseDocumentXml(bytes, {}, budget).root;
+      if (root.namespace === "http://www.w3.org/2000/svg" && root.localName === "svg") return "image/svg+xml";
+    } catch (error) {
+      if (error && typeof error === "object" && "code" in error && ["limit-exceeded", "cancelled"].includes(String(error.code))) throw error;
+    }
+  }
+  return "application/octet-stream";
+}
+var extensions = { "image/png": "png", "image/jpeg": "jpg", "image/gif": "gif", "image/bmp": "bmp", "image/tiff": "tiff", "image/svg+xml": "svg", "image/emf": "emf", "image/wmf": "wmf", "image/vnd.ms-photo": "wdp", "application/octet-stream": "bin" };
+async function inventory(input, operation, options, context) {
+  const settings = archiveSettings(context), invocation = validateDocxInvocation({ operation, inputs: ["document"], options }, settings.budget);
+  const budget = settings.budget.lower(Object.fromEntries((options.limit ?? []).map((limit) => [limit.name, limit.value])));
+  const document = await openDocumentLocations(input, { ...settings, budget }, "inventory"), selected = resolveDocxSelection(document, invocation);
+  budget.check("matches", selected.length);
+  budget.charge("retainedBytes", selected.length * 1024);
+  const graph = new DocumentPackage(document.snapshot(), settings.limits, budget), roots = /* @__PURE__ */ new Map(), resources = /* @__PURE__ */ new Map(), warnings = [], occurrences = [];
+  const warn = (code, message) => {
+    if (warnings.some((warning) => warning.code === code)) return;
+    budget.check("diagnosticBytes", warnings.reduce((size, warning) => size + warning.message.length + warning.code.length + 9, 0) + code.length + message.length + 9);
+    budget.charge("retainedBytes", (message.length + code.length) * 4);
+    warnings.push({ code, message });
+  };
+  const resource = async (part) => {
+    const existing = resources.get(part);
+    if (existing) return existing;
+    const member = graph.getPart(part);
+    budget.check("embeddedMediaBytes", member.bytes.length);
+    const value = { part: member.partname, bytes: member.bytes, mime: mediaType(member.bytes, member.content_type, budget), sha256: await hash(member.bytes, budget) };
+    if (value.mime === "application/octet-stream" || value.mime !== parseMediaType(member.content_type)) warn("unrecognized-image-type", "Image bytes have an unknown or mismatched declared media type; exact bytes remain preserved.");
+    resources.set(part, value);
+    return value;
+  };
+  for (const location of selected) {
+    await budget.checkpoint();
+    let root = roots.get(location.value.part);
+    if (!root) {
+      root = parseDocumentXml(graph.getPart(location.value.part).bytes, {}, budget).root;
+      roots.set(location.value.part, root);
+    }
+    let node = root;
+    const ancestors = [root];
+    for (const index of location.value.path) {
+      node = node.children[index];
+      ancestors.push(node);
+    }
+    const dialect = root.namespace === documentDialects.strict.w ? documentDialects.strict : documentDialects.transitional, { r, a, wp } = dialect;
+    const native = node.namespace === a && node.localName === "blip", edges = graph.relationships(location.value.part), references = [];
+    const linked = attribute(node, native ? "link" : "href", native ? r : "") !== void 0;
+    const resolve = (id) => {
+      if (id === void 0) return null;
+      budget.charge("work", edges.length);
+      const edge = edges.find((edge2) => edge2.rId === id);
+      if (!edge) {
+        warn("unresolved-image", "Image relationship is unresolved; no bytes are fabricated or acquired.");
+        return null;
+      }
+      if (!references.some((reference) => reference.id === edge.rId)) references.push({ owner: location.value.part, id: edge.rId, type: edge.reltype, target: edge.target_ref, external: edge.is_external });
+      if (edge.reltype !== r + "/image") {
+        warn("unresolved-image", "Image carrier has an unsupported relationship role; bytes remain unacquired.");
+        return null;
+      }
+      if (edge.is_external) {
+        warn("linked-image", "External image references remain inert and are never fetched.");
+        return null;
+      }
+      return edge.target_part.partname;
+    };
+    const primaryPart = resolve(attribute(node, native ? "embed" : "id", r));
+    const linkId = native ? attribute(node, "link", r) : void 0;
+    if (linkId !== void 0) {
+      resolve(linkId);
+      if (primaryPart) warn("competing-image-link", "An embedded image also has a linked reference; embedded bytes remain primary and the link stays inert.");
+    }
+    const primary = primaryPart ? await resource(primaryPart) : null;
+    const frame = [...ancestors].reverse().find((node2) => node2.namespace === wp && ["inline", "anchor"].includes(node2.localName));
+    const metadata = [];
+    const visit = (current) => {
+      budget.charge("work", 1);
+      metadata.push(current);
+      for (const child of current.children) visit(child);
+    };
+    visit(frame ?? node);
+    const one = (namespace, name) => {
+      const matches = metadata.filter((node2) => node2.namespace === namespace && node2.localName === name);
+      return matches.length === 1 ? matches[0] : void 0;
+    };
+    const extent = frame?.children.find((node2) => node2.namespace === wp && node2.localName === "extent"), transform = one(a, "xfrm"), cropNode = one(a, "srcRect"), docPr = one(wp, "docPr");
+    const cropValues = cropNode ? ["l", "r", "t", "b"].map((name) => integer(attribute(cropNode, name), 0, 1e5)) : [];
+    const crop = cropValues.length === 4 && cropValues.every((value) => value !== null) && cropValues[0] + cropValues[1] < 1e5 && cropValues[2] + cropValues[3] < 1e5 ? { left: cropValues[0] / 1e5, right: cropValues[1] / 1e5, top: cropValues[2] / 1e5, bottom: cropValues[3] / 1e5 } : null;
+    const position = (name) => {
+      const positions = frame?.children.filter((node2) => node2.namespace === wp && node2.localName === name) ?? [];
+      if (positions.length !== 1) return null;
+      const axis = positions[0], offsets = axis.children.filter((node2) => node2.namespace === wp && node2.localName === "posOffset"), alignments = axis.children.filter((node2) => node2.namespace === wp && node2.localName === "align");
+      const relative = attribute(axis, "relativeFrom"), permitted = name === "positionH" ? ["page", "margin", "column", "character", "leftMargin", "rightMargin", "insideMargin", "outsideMargin"] : ["page", "margin", "paragraph", "line", "topMargin", "bottomMargin", "insideMargin", "outsideMargin"];
+      const alignment = alignments.length === 1 && offsets.length === 0 && (name === "positionH" ? ["left", "right", "center", "inside", "outside"] : ["top", "bottom", "center", "inside", "outside"]).includes(alignments[0].text) ? alignments[0].text : null;
+      return { relativeFrom: relative && permitted.includes(relative) ? relative : null, offsetEmu: offsets.length === 1 && alignments.length === 0 ? integer(offsets[0].text, -2147483648, 2147483647) : null, alignment };
+    };
+    const rotation = integer(attribute(transform, "rot"), -216e5, 216e5);
+    const wrapping = frame?.children.filter((node2) => node2.namespace === wp && ["wrapNone", "wrapSquare", "wrapTight", "wrapThrough", "wrapTopAndBottom"].includes(node2.localName)) ?? [];
+    const wraps = { wrapNone: "none", wrapSquare: "square", wrapTight: "tight", wrapThrough: "through", wrapTopAndBottom: "top-bottom" };
+    const wrapNode = wrapping.length === 1 ? wrapping[0] : void 0;
+    const wrapTextValue = attribute(wrapNode, "wrapText");
+    const wrapText = frame?.localName === "anchor" && wrapNode && ["wrapSquare", "wrapTight", "wrapThrough"].includes(wrapNode.localName) && ["bothSides", "left", "right", "largest"].includes(wrapTextValue ?? "") ? wrapTextValue : null;
+    const distance = (side) => {
+      if (frame?.localName !== "anchor") return null;
+      const applicable = wrapNode?.localName === "wrapSquare" || ["wrapTight", "wrapThrough"].includes(wrapNode?.localName ?? "") && ["L", "R"].includes(side) || wrapNode?.localName === "wrapTopAndBottom" && ["T", "B"].includes(side);
+      const override = applicable ? attribute(wrapNode, "dist" + side) : void 0;
+      return integer(override ?? attribute(frame, "dist" + side), 0, 4294967295);
+    };
+    let wrapPolygon = null;
+    const polygons = wrapNode?.children.filter((child) => child.namespace === wp && child.localName === "wrapPolygon") ?? [];
+    if (frame?.localName === "anchor" && wrapNode && ["wrapTight", "wrapThrough"].includes(wrapNode.localName) && polygons.length === 1) {
+      const polygon = polygons[0], start = polygon.children.filter((child) => child.namespace === wp && child.localName === "start"), lines = polygon.children.filter((child) => child.namespace === wp && child.localName === "lineTo");
+      budget.check("matches", polygon.children.length);
+      budget.charge("retainedBytes", polygon.children.length * 64);
+      budget.charge("work", polygon.children.length);
+      const point = (child) => {
+        const x = integer(attribute(child, "x"), -27273042329600, 27273042316900), y = integer(attribute(child, "y"), -27273042329600, 27273042316900);
+        return x !== null && y !== null && !child.children.length ? { x, y } : null;
+      };
+      if (start.length === 1 && polygon.children[0] === start[0] && lines.length >= 2 && polygon.children.length === lines.length + 1) {
+        const first = point(start[0]), others = lines.map(point);
+        if (first && others.every((value) => value !== null)) wrapPolygon = { start: first, lineTo: others };
+      }
+      if (!wrapPolygon) warn("unrecognized-image-metadata", "Missing, invalid or unsupported image metadata remains null; no layout or decoding is inferred.");
+    }
+    const frameProperties = frame?.children.filter((child) => child.namespace === wp && child.localName === "cNvGraphicFramePr") ?? [], pictureProperties = metadata.filter((child) => child.namespace === dialect.pic && child.localName === "cNvPicPr");
+    const frameLocks = frameProperties.length === 1 ? frameProperties[0].children.filter((child) => child.namespace === a && child.localName === "graphicFrameLocks") : [], pictureLocks = pictureProperties.length === 1 ? pictureProperties[0].children.filter((child) => child.namespace === a && child.localName === "picLocks") : [];
+    const frameLock = frameLocks.length === 1 ? boolean(attribute(frameLocks[0], "noChangeAspect")) : null, pictureLock = pictureLocks.length === 1 ? boolean(attribute(pictureLocks[0], "noChangeAspect")) : null;
+    const lockAspect = frameLock !== null && pictureLock !== null && frameLock === pictureLock ? frameLock : null;
+    if (lockAspect === null) warn("unrecognized-image-metadata", "Missing, invalid or unsupported image metadata remains null; no layout or decoding is inferred.");
+    const alternates = node.children.filter((node2) => node2.namespace === a && node2.localName === "extLst").flatMap((list) => list.children.filter((node2) => node2.namespace === a && node2.localName === "ext").flatMap((extension) => extension.children.filter((node2) => node2.namespace === svg && node2.localName === "svgBlip")));
+    const alternateParts = [...new Set(alternates.map((node2) => resolve(attribute(node2, "embed", documentDialects.transitional.r))).filter((part) => part !== null))];
+    const alternateLinked = alternates.some((node2) => attribute(node2, "link", documentDialects.transitional.r) !== void 0);
+    for (const alternate of alternates) {
+      const link = attribute(alternate, "link", documentDialects.transitional.r);
+      if (link !== void 0) resolve(link);
+    }
+    let complete = primary !== null;
+    if (alternateLinked || alternates.length > 1 || alternates.length !== alternateParts.length) {
+      complete = false;
+      warn("ambiguous-image-alternate", "Image alternate associations are unresolved or ambiguous; no preferred encoding is invented.");
+    }
+    const admitted = primary ? [primary] : [];
+    let fallbackPart = null;
+    if (!alternateLinked && alternates.length === 1 && alternateParts.length === 1) {
+      const alternate = await resource(alternateParts[0]);
+      if (alternate.mime === "image/svg+xml" && alternate.part !== primary?.part) {
+        admitted.push(alternate);
+        if (primary && ["image/png", "image/jpeg", "image/gif", "image/bmp", "image/tiff"].includes(primary.mime)) fallbackPart = primary.part;
+      } else {
+        complete = false;
+        warn("ambiguous-image-alternate", "An image alternate does not identify a distinct admitted SVG resource; the original relationship remains preserved.");
+      }
+    }
+    const details = {
+      kind: "images",
+      part: primary?.part ?? null,
+      mime: primary?.mime ?? null,
+      declaredMime: primary ? graph.getPart(primary.part).content_type : null,
+      bytes: primary?.bytes.length ?? null,
+      sha256: primary?.sha256 ?? null,
+      pixelWidth: null,
+      pixelHeight: null,
+      widthEmu: native ? integer(attribute(extent, "cx"), 1) : null,
+      heightEmu: native ? integer(attribute(extent, "cy"), 1) : null,
+      placement: frame ? frame.localName === "inline" ? "inline" : "floating" : null,
+      crop: native ? crop : null,
+      rotation: native && rotation !== null ? rotation / 6e4 : null,
+      flipHorizontal: native ? boolean(attribute(transform, "flipH")) : null,
+      flipVertical: native ? boolean(attribute(transform, "flipV")) : null,
+      wrapText,
+      wrapPolygon,
+      distances: frame?.localName === "anchor" ? { top: distance("T"), bottom: distance("B"), left: distance("L"), right: distance("R") } : null,
+      allowOverlap: frame?.localName === "anchor" ? boolean(attribute(frame, "allowOverlap")) : null,
+      behindText: frame?.localName === "anchor" ? boolean(attribute(frame, "behindDoc")) : null,
+      lockAspect,
+      wrap: wrapping.length === 1 ? wraps[wrapping[0].localName] ?? null : null,
+      zOrder: frame?.localName === "anchor" ? integer(attribute(frame, "relativeHeight"), 0, 4294967295) : null,
+      horizontalPosition: frame?.localName === "anchor" ? position("positionH") : null,
+      verticalPosition: frame?.localName === "anchor" ? position("positionV") : null,
+      alt: native ? attribute(docPr, "descr") ?? null : null,
+      decorative: native ? boolean(attribute(one(decorativeNamespace, "decorative"), "val")) : null,
+      owners: [location],
+      fallbackPart,
+      alternateParts,
+      linked: linked || alternateLinked || references.some((reference) => reference.external)
+    };
+    if (!native || !frame || details.widthEmu === null || details.heightEmu === null || details.rotation === null || details.crop === null || details.decorative === null) warn("unrecognized-image-metadata", "Missing, invalid or unsupported image metadata remains null; no layout or decoding is inferred.");
+    if (!primary) warn("unresolved-image", "Image media is linked, missing or unresolved; no bytes are fabricated or acquired.");
+    occurrences.push({ record: { kind: "images", location, ...primary ? { name: primary.part } : {}, properties: [], references, support: native && primary !== null && primary.mime !== "application/octet-stream" ? "read" : "preserve", details }, resources: admitted, complete });
+  }
+  return { occurrences, warnings, budget };
+}
+async function inspectDocumentImages(input, options, context) {
+  const dataOptions = ownData(options), admittedOperation = dataOptions.operation;
+  if (admittedOperation !== "images.list" && admittedOperation !== "images.get") throw new DocxUsageError("Expected image list or get operation.");
+  const declaration = docxOperationSchemas[admittedOperation];
+  closedRecord(dataOptions, ["operation", ...Object.keys(declaration.fields), ...declaration.commonOptions]);
+  options = dataOptions;
+  const { operation, ...selection } = options, result = await inventory(input, operation, selection, context);
+  const items = [], hashes = /* @__PURE__ */ new Map(), owners = [], references = [], parts = [];
+  for (const { record } of result.occurrences) {
+    const key = "unique" in selection && selection.unique ? record.details.sha256 : null, previous = key ? hashes.get(key) : void 0;
+    const index = previous ?? items.length;
+    result.budget.charge("work", record.references.length + record.details.alternateParts.length + 2);
+    result.budget.charge("retainedBytes", 32 * (record.references.length + record.details.alternateParts.length + 2));
+    if (previous === void 0) {
+      if (key) hashes.set(key, index);
+      items.push(record);
+      owners.push([]);
+      references.push(/* @__PURE__ */ new Map());
+      parts.push(/* @__PURE__ */ new Set());
+    }
+    owners[index].push(record.location);
+    for (const reference of record.references) references[index].set(JSON.stringify([reference.owner, reference.id]), reference);
+    if (record.details.part && record.details.part !== items[index].details.part) parts[index].add(record.details.part);
+    for (const part of record.details.alternateParts) parts[index].add(part);
+  }
+  const finalized = items.map((record, index) => ({ ...record, references: [...references[index].values()], details: { ...record.details, owners: owners[index], alternateParts: [...parts[index]] } }));
+  result.budget.charge("retainedBytes", finalized.length * 256);
+  const data = operation === "images.get" ? { item: finalized[0], warnings: result.warnings } : { items: finalized, warnings: result.warnings };
+  if (selection.json) measurePackageResourceSerialization(data, result.budget);
+  return data;
+}
+async function extractDocumentImages(input, options, context) {
+  const declaration = docxOperationSchemas["images.extract"];
+  options = ownData(options, ["input", ...Object.keys(declaration.fields), ...declaration.commonOptions]);
+  const { input: borrowedIdentity, ...selection } = options;
+  let identity;
+  if (borrowedIdentity !== void 0) {
+    const admitted = ownData(borrowedIdentity, ["path", "stat"]), stat = ownData(admitted.stat, ["type", "filesystemType", "size", "allocatedBytes", "ioBlockSize", "preferredIoBlockSize", "mode", "mtimeMs", "atimeMs", "ctimeMs", "birthtimeMs", "revision", "identityScope", "ino", "dev", "rdevMajor", "rdevMinor", "nlink", "uid", "gid"]);
+    if (typeof admitted.path !== "string" || !admitted.path) throw new DocxUsageError("Image input identity requires an explicit path.");
+    identity = { path: admitted.path, stat };
+  }
+  const result = await inventory(input, "images.extract", selection, context), directory = selection.outputDir;
+  if (!directory || !directory.startsWith("/") || resolvePath("/", directory) !== directory || directory.includes("\0")) throw new DocxUsageError("Image extraction requires a canonical absolute VFS output directory.");
+  if (!context.filesystem) throw new PublicationError("unsupported-publication", "Image extraction requires an explicitly supplied publication filesystem.");
+  const entries = [], files = [];
+  for (const occurrence of result.occurrences) for (const resource of occurrence.resources) {
+    result.budget.charge("retainedBytes", resource.bytes.length);
+    result.budget.charge("work", resource.bytes.length);
+    const path = resolvePath(directory, `image-${entries.length + 1}.${extensions[resource.mime] ?? "bin"}`);
+    entries.push({ path, part: resource.part, bytes: resource.bytes.length, sha256: resource.sha256, locations: [occurrence.record.location], published: false });
+    files.push({ path, bytes: new Uint8Array(resource.bytes) });
+  }
+  const manifestValue = { version: 1, kind: "images", entries: entries.map(({ path, part, bytes, sha256, locations }) => ({ path: path.slice(directory === "/" ? 1 : directory.length + 1), part, bytes, sha256, locations })) };
+  const size = measurePackageResourceSerialization(manifestValue, result.budget);
+  result.budget.charge("retainedBytes", size * 6);
+  const manifestBytes = new TextEncoder().encode(JSON.stringify(manifestValue)), manifest = { path: resolvePath(directory, "manifest.json"), bytes: manifestBytes.length, sha256: await hash(manifestBytes, result.budget), published: false };
+  files.push({ path: manifest.path, bytes: manifestBytes });
+  const data = { complete: result.occurrences.every((occurrence) => occurrence.complete), inventory: null, manifest, entries, warnings: result.warnings };
+  if (selection.json) measurePackageResourceSerialization(data, result.budget);
+  if (context.admitPublication) {
+    result.budget.charge("retainedBytes", entries.length * 128 + 128);
+    const planned = Object.freeze({ ...data, manifest: Object.freeze({ ...manifest }), entries: Object.freeze(entries.map((entry) => Object.freeze({ ...entry, locations: Object.freeze([...entry.locations]) }))), warnings: Object.freeze([...result.warnings]) });
+    const admitted = context.admitPublication(planned);
+    if (admitted !== void 0) {
+      void Promise.resolve(admitted).catch(() => {
+      });
+      throw new DocxUsageError("Image publication admission must complete synchronously and return undefined.");
+    }
+  }
+  result.budget.charge("retainedBytes", (entries.length + 1) * 256);
+  result.budget.charge("work", (entries.length + 1) * 8);
+  let published;
+  try {
+    published = await publishDocumentFiles(files, { ...identity ? { input: identity } : {}, ...selection.force === void 0 ? {} : { force: selection.force }, ...selection.allowPartialOutput === void 0 ? {} : { allowPartialOutput: selection.allowPartialOutput } }, { ...context, filesystem: context.filesystem, budget: result.budget });
+  } catch (error) {
+    if (!(error instanceof PublicationError) && !(error instanceof CancellationError)) throw error;
+    const receipts = "published" in error && Array.isArray(error.published) ? error.published : [], paths2 = new Set(receipts.map((file) => file.path));
+    const partial = { ...data, complete: false, manifest: { ...manifest, published: paths2.has(manifest.path) }, entries: entries.map((entry) => ({ ...entry, published: paths2.has(entry.path) })) };
+    if (error instanceof CancellationError) throw new ImageExtractionCancellationError(error, partial, receipts);
+    throw new ImageExtractionPublicationError(error, partial);
+  }
+  const paths = new Set(published.published.map((file) => file.path));
+  return { ...data, manifest: { ...manifest, published: paths.has(manifest.path) }, entries: entries.map((entry) => ({ ...entry, published: paths.has(entry.path) })) };
+}
+
+export {
+  ImageExtractionPublicationError,
+  ImageExtractionCancellationError,
+  inspectDocumentImages,
+  extractDocumentImages
+};

package/dist/safe-bash/command-chunks/chunk-2W54TAGI.js

@@ -0,0 +1,162 @@
+import {
+  DocumentBudget,
+  InputTypeError,
+  InvalidValueError,
+  ResourceLimitError,
+  archiveSettings,
+  documentByteView,
+  documentLimitDefaults
+} from "./chunk-IQFRPIXH.js";
+
+// packages/safe-bash-docx-engine/src/model-context.ts
+var admitted = /* @__PURE__ */ new WeakSet();
+var vfsOrigins = /* @__PURE__ */ new WeakMap();
+var fontMeasurements = /* @__PURE__ */ new WeakMap();
+function contextData(value, keys) {
+  if (!value || typeof value !== "object" || ![Object.prototype, null].includes(Object.getPrototypeOf(value)))
+    throw new InputTypeError("Expected finite context capability data.");
+  const result = {};
+  for (const key of Reflect.ownKeys(value)) {
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    if (!("value" in descriptor) || keys && (typeof key !== "string" || !keys.includes(key)))
+      throw new InputTypeError("Expected finite context capability data.");
+    Object.defineProperty(result, key, { value: descriptor.value, enumerable: true });
+  }
+  return result;
+}
+function matchesModelVfs(capability, context) {
+  return context.vfs !== void 0 && (vfsOrigins.get(capability) ?? capability) === (vfsOrigins.get(context.vfs) ?? context.vfs);
+}
+function captureVfs(value) {
+  contextData(value, ["open", "filesystem"]);
+  if (typeof value.open !== "function")
+    throw new InputTypeError("Expected an explicit virtual read capability.");
+  if (value.filesystem !== void 0 && (!value.filesystem || typeof value.filesystem.lstat !== "function"))
+    throw new InputTypeError("Expected an explicit publication filesystem.");
+  const result = Object.freeze({ open: value.open.bind(value), ...value.filesystem ? { filesystem: value.filesystem } : {} });
+  vfsOrigins.set(result, vfsOrigins.get(value) ?? value);
+  return result;
+}
+function captureFonts(value, budget) {
+  contextData(value, ["measure"]);
+  if (typeof value.measure !== "function")
+    throw new InputTypeError("Expected explicit font metrics.");
+  const measure = fontMeasurements.get(value) ?? value.measure.bind(value);
+  const captured = Object.freeze({
+    measure(text, font, points) {
+      budget.check("work", 0);
+      if (typeof text !== "string" || typeof font !== "string" || !font || typeof points !== "number" || !Number.isFinite(points) || points <= 0 || points > Number.MAX_SAFE_INTEGER)
+        throw new InputTypeError("Expected text, an explicit font and positive finite points.");
+      budget.charge("work", text.length + font.length + 1);
+      const width = measure(text, font, points);
+      budget.check("work", 0);
+      if (typeof width !== "number" || !Number.isFinite(width) || width < 0 || width > Number.MAX_SAFE_INTEGER)
+        throw new InvalidValueError(
+          "Font metrics must return a finite nonnegative width in points."
+        );
+      return width;
+    }
+  });
+  fontMeasurements.set(captured, measure);
+  return captured;
+}
+function modelContext(context = {}, defaultLimits = {}) {
+  if (context && admitted.has(context)) return context;
+  contextData(context);
+  if (context.signal !== void 0 && !(context.signal instanceof AbortSignal))
+    throw new InputTypeError("Expected a cancellation signal.");
+  if (context.budget !== void 0 && !(context.budget instanceof DocumentBudget))
+    throw new InputTypeError("Expected an explicit document budget.");
+  const signal = context.signal ?? new AbortController().signal;
+  const defaults = documentLimitDefaults;
+  if (context.limits !== void 0) contextData(context.limits);
+  const namedLimits = context.limits !== void 0 && Object.keys(context.limits).every((key) => Object.hasOwn(defaults, key));
+  const budget = namedLimits ? (context.budget ?? new DocumentBudget({}, signal)).lower(
+    context.limits,
+    signal
+  ) : context.budget;
+  const limits = {
+    ...defaultLimits,
+    ...!namedLimits ? context.limits : {}
+  };
+  const timestamp = context.timestamp;
+  if (timestamp !== void 0 && (!(timestamp instanceof Date) || !Number.isFinite(Date.prototype.getTime.call(timestamp))))
+    throw new InputTypeError("Expected a valid UTC Date.");
+  const time = timestamp === void 0 ? void 0 : Math.floor(Date.prototype.getTime.call(timestamp) / 1e3) * 1e3;
+  const author = context.author === void 0 ? "" : context.author, initials = context.initials === void 0 ? "" : context.initials;
+  if (typeof author !== "string" || author.length > 510 || [...author].length > 255 || initials !== null && (typeof initials !== "string" || initials.length > 510 || [...initials].length > 255))
+    throw new InputTypeError("Expected bounded model identity strings.");
+  if (context.fonts !== void 0 && context.metrics !== void 0)
+    throw new InputTypeError("Supply fonts or the legacy metrics adapter, not both.");
+  if (context.registerCleanup !== void 0 && typeof context.registerCleanup !== "function")
+    throw new InputTypeError("Expected a cleanup registrar.");
+  const settings = archiveSettings({ ...context, limits, signal, ...budget ? { budget } : {} });
+  settings.budget.check("work", 0);
+  const selectedFonts = context.fonts !== void 0 ? context.fonts : context.metrics;
+  const fonts = selectedFonts === void 0 ? void 0 : captureFonts(selectedFonts, settings.budget);
+  let binaryResolver, fontResolver;
+  if (context.binaryResolver !== void 0) {
+    contextData(context.binaryResolver, ["capability", "open", "filesystem"]);
+    if (typeof context.binaryResolver.capability !== "string" || !context.binaryResolver.capability || typeof context.binaryResolver.open !== "function")
+      throw new InputTypeError("Expected an explicit binary resolver capability.");
+    binaryResolver = Object.freeze({
+      capability: context.binaryResolver.capability,
+      ...captureVfs({ open: context.binaryResolver.open.bind(context.binaryResolver), ...context.binaryResolver.filesystem ? { filesystem: context.binaryResolver.filesystem } : {} })
+    });
+  }
+  if (context.fontResolver !== void 0) {
+    contextData(context.fontResolver, ["capability", "fonts"]);
+    if (typeof context.fontResolver.capability !== "string" || !context.fontResolver.capability)
+      throw new InputTypeError("Expected an explicit font resolver token.");
+    fontResolver = Object.freeze({
+      capability: context.fontResolver.capability,
+      fonts: captureFonts(context.fontResolver.fonts, settings.budget)
+    });
+  }
+  let template;
+  if (context.template !== void 0) {
+    const bytes = documentByteView(context.template);
+    if (bytes.length > settings.limits.maxArchiveBytes)
+      throw new ResourceLimitError("Template input byte limit exceeded.");
+    settings.budget.charge("retainedBytes", bytes.length);
+    settings.budget.charge("work", bytes.length);
+    template = new Uint8Array(bytes);
+  }
+  const result = {
+    ...settings,
+    limits: Object.freeze(settings.limits),
+    codecLimits: Object.freeze(settings.codecLimits),
+    author,
+    initials,
+    ...fonts ? { fonts } : {},
+    ...context.vfs === void 0 ? {} : { vfs: captureVfs(context.vfs) },
+    ...binaryResolver ? { binaryResolver } : {},
+    ...fontResolver ? { fontResolver } : {},
+    ...context.registerCleanup ? { registerCleanup: context.registerCleanup } : {}
+  };
+  if (time !== void 0)
+    Object.defineProperty(result, "timestamp", {
+      enumerable: true,
+      get() {
+        return new Date(time);
+      }
+    });
+  if (template !== void 0)
+    Object.defineProperty(result, "template", {
+      enumerable: true,
+      get() {
+        settings.budget.charge("retainedBytes", template.length);
+        settings.budget.charge("work", template.length);
+        return new Uint8Array(template);
+      }
+    });
+  Object.freeze(result);
+  admitted.add(result);
+  return result;
+}
+
+export {
+  contextData,
+  matchesModelVfs,
+  modelContext
+};