@poe-platform/safe-bash 0.1.806 → 0.1.807

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

@@ -0,0 +1,243 @@
+import {
+  readImages
+} from "./chunk-GIESJLR2.js";
+import {
+  nodeFor
+} from "./chunk-QHS7PDG3.js";
+import {
+  applyShapeUpdate,
+  validateShapeOptions
+} from "./chunk-HHLVI2CB.js";
+import {
+  attr,
+  child,
+  escape,
+  invalid,
+  loadShared,
+  required
+} from "./chunk-RAXJVM4U.js";
+import {
+  SelectionError
+} from "./chunk-CKEODJVT.js";
+import {
+  OfficeError
+} from "./chunk-RR6QQ25D.js";
+
+// packages/safe-bash-presentation-engine/src/image-formatting.ts
+var sides = [
+  ["cropLeft", "l"],
+  ["cropTop", "t"],
+  ["cropRight", "r"],
+  ["cropBottom", "b"]
+];
+function fields(value, allowed) {
+  if (!value || typeof value !== "object" || ![Object.prototype, null].includes(Object.getPrototypeOf(value)) || Reflect.ownKeys(value).some(
+    (key) => typeof key !== "string" || !allowed.includes(key) || !("value" in Object.getOwnPropertyDescriptor(value, key))
+  ))
+    invalid("Invalid picture options.");
+}
+function quantize(value, scale) {
+  return Math.sign(value) * Math.round(Math.abs(value) * scale);
+}
+function validate(options) {
+  fields(options, [
+    ...sides.map((x) => x[0]),
+    "rotation",
+    "flipHorizontal",
+    "flipVertical",
+    "opacity",
+    "borderColor",
+    "borderWidth",
+    "altText",
+    "all",
+    "allowEmpty"
+  ]);
+  for (const [key] of sides) {
+    const value = options[key];
+    if (value !== void 0 && (typeof value !== "number" || !Number.isFinite(value) || value < -21474.83648 || value > 21474.83647))
+      invalid("Crop requires a bounded signed fraction.");
+  }
+  for (const key of ["all", "allowEmpty", "flipHorizontal", "flipVertical"])
+    if (options[key] !== void 0 && typeof options[key] !== "boolean")
+      invalid("Picture switches require booleans.");
+  if (options.opacity !== void 0 && (typeof options.opacity !== "number" || !Number.isFinite(options.opacity) || options.opacity < 0 || options.opacity > 1))
+    invalid("Opacity requires a fraction from zero to one.");
+  if (options.borderWidth !== void 0 && (!Number.isSafeInteger(options.borderWidth) || options.borderWidth < 0 || options.borderWidth > 20116800))
+    invalid("Picture outline width requires bounded integer EMUs.");
+  if (options.altText !== void 0 && typeof options.altText !== "string")
+    invalid("Picture alternative text requires text.");
+  if (options.borderColor !== void 0 && typeof options.borderColor !== "string")
+    invalid("Picture outline color requires a hex string.");
+  validateShapeOptions({
+    ...options.rotation === void 0 ? {} : { rotation: options.rotation },
+    ...options.borderColor === void 0 ? {} : { lineColor: options.borderColor }
+  });
+  if (!Object.keys(options).some((key) => key !== "all" && key !== "allowEmpty"))
+    invalid("Provide a picture property to set.");
+}
+function applyPictureUpdate(document, node, options, cropPolicy = "visible-area") {
+  validate(options);
+  const p = node.name.namespace;
+  const a = p === "http://purl.oclc.org/ooxml/presentationml/main" ? "http://purl.oclc.org/ooxml/drawingml/main" : "http://schemas.openxmlformats.org/drawingml/2006/main";
+  if (node.name.localName !== "pic")
+    throw new OfficeError(
+      "unsupported-edit",
+      "Picture formatting requires a picture shape.",
+      "validate-intent"
+    );
+  const id = attr(required(required(node, "nvPicPr"), "cNvPr"), "id");
+  const current = () => nodeFor(document.root, id);
+  if (sides.some(([key]) => options[key] !== void 0)) {
+    const fill = required(current(), "blipFill"), crop = child(fill, "srcRect", a);
+    const values = sides.map(([key, attribute]) => {
+      if (options[key] !== void 0) return quantize(options[key], 1e5);
+      const raw = crop && attr(crop, attribute);
+      if (raw === void 0) return 0;
+      const value = raw.trim();
+      const result = value.endsWith("%") ? Number(value.slice(0, -1)) * 1e3 : Number(value);
+      if (!Number.isFinite(result) || result < -2147483648 || result > 2147483647)
+        invalid("Stored crop is outside the editable range.");
+      return result;
+    });
+    if (cropPolicy === "visible-area" && (values[0] + values[2] >= 1e5 || values[1] + values[3] >= 1e5))
+      invalid("Crop must leave positive visible width and height after rounding.");
+    if (crop)
+      document = document.merge(crop, {
+        attributes: sides.flatMap(
+          ([key, attribute]) => options[key] === void 0 ? [] : [
+            {
+              namespace: "",
+              localName: attribute,
+              value: String(quantize(options[key], 1e5))
+            }
+          ]
+        )
+      });
+    else
+      document = document.spliceChildren(
+        fill,
+        child(fill, "blip", a) ? fill.children.indexOf(child(fill, "blip", a)) + 1 : 0,
+        0,
+        [
+          `<a:srcRect xmlns:a="${a}" ${sides.filter(([key]) => options[key] !== void 0).map(([key, attribute]) => `${attribute}="${quantize(options[key], 1e5)}"`).join(" ")}/>`
+        ]
+      );
+  }
+  const transform = {
+    ...options.rotation === void 0 ? {} : { rotation: options.rotation },
+    ...options.flipHorizontal === void 0 ? {} : { flipHorizontal: options.flipHorizontal },
+    ...options.flipVertical === void 0 ? {} : { flipVertical: options.flipVertical }
+  };
+  if (Object.keys(transform).length) document = applyShapeUpdate(document, current(), transform);
+  if (options.opacity !== void 0) {
+    const blip = child(required(current(), "blipFill"), "blip", a);
+    if (!blip)
+      throw new OfficeError("unsupported-edit", "Picture has no image binding.", "validate-intent");
+    const alpha = child(blip, "alphaModFix", a);
+    if (alpha)
+      document = document.merge(alpha, {
+        attributes: [
+          { namespace: "", localName: "amt", value: String(quantize(options.opacity, 1e5)) }
+        ]
+      });
+    else {
+      const extension = child(blip, "extLst", a);
+      document = document.spliceChildren(
+        blip,
+        extension ? blip.children.indexOf(extension) : blip.children.length,
+        0,
+        [`<a:alphaModFix xmlns:a="${a}" amt="${quantize(options.opacity, 1e5)}"/>`]
+      );
+    }
+  }
+  if (options.borderColor !== void 0 || options.borderWidth !== void 0) {
+    let properties = required(current(), "spPr"), line = child(properties, "ln", a);
+    if (!line) {
+      const following = properties.children.findIndex(
+        (x) => x.name.namespace === a && ["effectLst", "effectDag", "scene3d", "sp3d", "extLst"].includes(x.name.localName)
+      );
+      document = document.spliceChildren(
+        properties,
+        following < 0 ? properties.children.length : following,
+        0,
+        [`<a:ln xmlns:a="${a}"/>`]
+      );
+    }
+    properties = required(current(), "spPr");
+    line = child(properties, "ln", a);
+    if (options.borderWidth !== void 0)
+      document = document.merge(line, {
+        attributes: [{ namespace: "", localName: "w", value: String(options.borderWidth) }]
+      });
+    if (options.borderColor !== void 0) {
+      line = child(required(current(), "spPr"), "ln", a);
+      const fills = line.children.filter(
+        (x) => x.name.namespace === a && ["noFill", "solidFill", "gradFill", "pattFill"].includes(x.name.localName)
+      );
+      if (fills.length > 1)
+        throw new OfficeError(
+          "unsupported-edit",
+          "Ambiguous picture outline fill.",
+          "validate-intent"
+        );
+      const old = fills[0];
+      document = document.spliceChildren(line, old ? line.children.indexOf(old) : 0, old ? 1 : 0, [
+        `<a:solidFill xmlns:a="${a}"><a:srgbClr val="${escape(options.borderColor.toUpperCase())}"/></a:solidFill>`
+      ]);
+    }
+  }
+  if (options.altText !== void 0)
+    document = document.merge(required(required(current(), "nvPicPr"), "cNvPr"), {
+      attributes: [{ namespace: "", localName: "descr", value: options.altText }]
+    });
+  return document;
+}
+async function setImage(input, selector, options, context) {
+  context.signal?.throwIfAborted();
+  validate(options);
+  fields(selector, ["scope", "slide", "image", "select"]);
+  if (selector.scope === "shared" || !options.all && selector.image === void 0 && selector.select === void 0 || selector.select !== void 0 && options.all !== void 0 || selector.image !== void 0 && selector.slide === void 0 && (selector.scope === void 0 || selector.scope === "slides"))
+    throw new SelectionError("invalid-selection");
+  options = { ...options };
+  selector = { ...selector };
+  const s = await loadShared(input, context);
+  const occurrences = (await readImages(s.source, selector, context)).occurrences;
+  if (!occurrences.length && !options.allowEmpty) throw new SelectionError("missing-selection");
+  if (occurrences.length > 1 && !options.all)
+    throw new SelectionError(
+      "ambiguous-selection",
+      occurrences.map((x) => x.location)
+    );
+  if (occurrences.some((x) => x.kind !== "picture" || x.role !== "primary" || !x.shapeId))
+    throw new OfficeError(
+      "unsupported-edit",
+      "Select primary picture occurrences for formatting.",
+      "validate-intent"
+    );
+  for (const occurrence of occurrences) {
+    context.signal?.throwIfAborted();
+    const doc = s.doc(occurrence.sourcePart);
+    s.save(
+      occurrence.sourcePart,
+      applyPictureUpdate(doc, nodeFor(doc.root, occurrence.shapeId), options)
+    );
+  }
+  const affectedSlides = s.index.inventory.slides.filter(
+    (slide) => occurrences.some((x) => x.sourcePart === slide.part || x.inheritedBy.includes(slide.position))
+  ).map((x) => x.position);
+  const bytes = occurrences.length ? (await s.finish(occurrences[0].sourcePart, affectedSlides)).bytes : s.source;
+  const ids = new Set(occurrences.map((x) => x.id));
+  return {
+    bytes,
+    affected: occurrences.length,
+    affectedSlides,
+    occurrences: (await readImages(bytes, { scope: "shared" }, context)).occurrences.filter(
+      (x) => ids.has(x.id)
+    )
+  };
+}
+
+export {
+  applyPictureUpdate,
+  setImage
+};

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

@@ -0,0 +1,266 @@
+import {
+  inspectDocumentObjects
+} from "./chunk-LHL6RWGJ.js";
+import {
+  editDocumentLinks,
+  inspectDocumentLinks
+} from "./chunk-SM733XRT.js";
+import {
+  editDocumentRevisionDecisions
+} from "./chunk-7LEADSSA.js";
+import {
+  editDocumentProperties,
+  inspectDocumentProperties
+} from "./chunk-AIOB34IX.js";
+import {
+  editDocumentComments,
+  inspectDocumentComments
+} from "./chunk-TVAEX4WQ.js";
+import {
+  assertOutsideFields,
+  parseFields
+} from "./chunk-6EHVFKM7.js";
+import {
+  DocumentArchiveEditor
+} from "./chunk-MAHX3IW3.js";
+import {
+  measurePackageResourceSerialization
+} from "./chunk-W6DV2CLS.js";
+import {
+  validateDocxInvocation
+} from "./chunk-DE66JRWJ.js";
+import {
+  retainedRelationshipTargets
+} from "./chunk-4LXDJES2.js";
+import {
+  assertDocumentEditable,
+  publishDocumentArchive
+} from "./chunk-HPKUFWHW.js";
+import {
+  DocumentPackage,
+  readDocumentArchive
+} from "./chunk-GLPIFP7N.js";
+import {
+  DocumentXmlEditor,
+  UnsupportedEditError,
+  assertOutsideRevisionRanges,
+  editActiveRelationshipXml
+} from "./chunk-YPVBU7QF.js";
+import {
+  relationshipXmlRows
+} from "./chunk-2PSVE7I5.js";
+import {
+  documentDialects
+} from "./chunk-MG7AJD5E.js";
+import {
+  documentCompatibilityProfile
+} from "./chunk-GZ2N24A2.js";
+import {
+  SelectionError,
+  closedRecord
+} from "./chunk-LQOKYG3O.js";
+import {
+  asciiKey
+} from "./chunk-WAKYUXVQ.js";
+import {
+  DocxUsageError
+} from "./chunk-2P7BLWWI.js";
+import {
+  InputTypeError,
+  archiveSettings
+} from "./chunk-IQFRPIXH.js";
+
+// packages/safe-bash-docx-engine/src/object-sanitization.ts
+async function prepareObjectSanitization(staged, context) {
+  const settings = archiveSettings(context), budget = settings.budget;
+  const records = [], gaps = [];
+  const inventory = await inspectDocumentObjects(staged, {}, { ...settings, budget });
+  const archive = await readDocumentArchive(staged, { ...settings, budget }), editor = new DocumentArchiveEditor(archive, {}, { ...documentCompatibilityProfile, understoodElements: [...documentCompatibilityProfile.understoodElements ?? [], { namespace: "urn:schemas-microsoft-com:office:office", localName: "OLEObject", attributes: [...Object.values(documentDialects).map((d) => ({ namespace: d.r, localName: "id" })), ...["Type", "ProgID", "ShapeID", "DrawAspect", "ObjectID", "UpdateMode"].map((localName) => ({ namespace: "", localName }))] }] }, budget);
+  const targets = /* @__PURE__ */ new Set();
+  for (const item of inventory.items) {
+    if (!item.location.value.path.length || !["internal", "external"].includes(item.details.status)) throw new UnsupportedEditError("Unbound or opaque embedded objects cannot be sanitized safely.");
+    const xml = editor.xml(item.location.value.part.slice(1));
+    let node = xml.root;
+    const ancestors = [node];
+    for (const index of item.location.value.path) {
+      node = node.children[index];
+      ancestors.push(node);
+    }
+    const carrier = ancestors.at(-2);
+    const native = node.namespace === carrier.namespace && ["objectEmbed", "objectLink"].includes(node.localName);
+    if (!native && (node.namespace !== "urn:schemas-microsoft-com:office:office" || node.localName !== "OLEObject") || node.children.length || node.content.some((content) => content.kind !== "text" || content.text.trim()) || carrier.localName !== "object" || !Object.values(documentDialects).some((d) => carrier.namespace === d.w) || carrier.children.length !== 1 || ancestors.at(-3)?.localName !== "r" || ancestors.some((n) => ["sdt", "ins", "del", "hyperlink", "fldSimple"].includes(n.localName))) throw new UnsupportedEditError("Only direct inert object carriers without previews or compound owners are supported.");
+    let storyIndex = -1;
+    ancestors.forEach((ancestor, index) => {
+      if (ancestor.namespace === carrier.namespace && ["body", "hdr", "ftr", "footnote", "endnote", "comment", "txbxContent"].includes(ancestor.localName)) storyIndex = index;
+    });
+    if (storyIndex < 0) throw new UnsupportedEditError("Object removal requires an admitted story.");
+    assertOutsideFields(parseFields(ancestors[storyIndex], item.location.value.path.slice(0, storyIndex), budget, xml.compatibility.content), item.location.value.path.slice(0, -1));
+    assertOutsideRevisionRanges(xml.root, carrier, budget, xml.compatibility.branches);
+    const permissions = /* @__PURE__ */ new Set();
+    const scan = (current) => {
+      budget.charge("work", 1);
+      if (current === carrier && permissions.size) throw new UnsupportedEditError("Object removal cannot cross a permission boundary.");
+      if (current.namespace === carrier.namespace) {
+        const id = current.attributes.find((attribute) => attribute.namespace === carrier.namespace && attribute.localName === "id")?.value ?? "";
+        if (current.localName === "permStart") permissions.add(id);
+        if (current.localName === "permEnd") permissions.delete(id);
+      }
+      current.children.forEach(scan);
+    };
+    scan(xml.root);
+    xml.assertShapeEditAllowed(carrier);
+    xml.replaceElement(carrier, "");
+    records.push(item.location.token);
+    if (item.details.resource) targets.add(item.details.resource.part);
+  }
+  let result = editor.snapshot();
+  const retired = /* @__PURE__ */ new Set();
+  for (const item of inventory.items) for (const reference of item.references.filter((edge) => edge.owner === item.location.value.part && Object.values(documentDialects).some((dialect) => edge.type === `${dialect.r}/oleObject` || edge.type === `${dialect.r}/package`))) {
+    const split = reference.owner.lastIndexOf("/"), name = reference.owner.slice(1, split + 1) + "_rels/" + reference.owner.slice(split + 1) + ".rels";
+    const owner = editor.xml(reference.owner.slice(1));
+    const used = (node) => {
+      budget.charge("work", 1);
+      return node.attributes.some((a) => Object.values(documentDialects).some((d) => a.namespace === d.r) && a.value === reference.id) || node.children.some(used);
+    };
+    const current = new DocumentXmlEditor(owner.serialize(), {}, void 0, budget);
+    if (!used(current.root)) {
+      const rels = editor.xml(name), edge = relationshipXmlRows(rels.root, budget).find((row) => row.rId === reference.id);
+      if (edge) rels[editActiveRelationshipXml](edge.element, null);
+    }
+  }
+  result = editor.snapshot();
+  const packageView = new DocumentPackage(result, settings.limits, budget);
+  const retainedTargets = retainedRelationshipTargets(packageView, budget);
+  for (const target of targets) if (!retainedTargets.has(asciiKey(target))) {
+    if (packageView.relationships(target).length) {
+      gaps.push("Unreferenced embedded targets with outgoing graphs are retained.");
+      continue;
+    }
+    retired.add(target.slice(1));
+    const split = target.lastIndexOf("/");
+    retired.add(target.slice(1, split + 1) + "_rels/" + target.slice(split + 1) + ".rels");
+  }
+  if (retired.size) {
+    const member = result.members.find((member2) => member2.name === "[Content_Types].xml"), types = new DocumentXmlEditor(member.bytes, {}, void 0, budget);
+    for (const node of types.root.children) if (node.localName === "Override" && node.attributes.some((a) => a.localName === "PartName" && retired.has(a.value.slice(1)))) types.replaceElement(node, "");
+    result = { ...result, members: result.members.filter((member2) => !retired.has(member2.name)).map((current) => current === member ? { ...current, bytes: types.serialize() } : current) };
+  }
+  await publishDocumentArchive(result, { dryRun: true }, { ...settings, budget, encoding: context.encoding }, archive);
+  gaps.push("Preview-bearing, compound, unbound and opaque objects reject; shared targets and unrelated payloads are retained.");
+  return { archive: result, records, gaps };
+}
+
+// packages/safe-bash-docx-engine/src/sanitize.ts
+var categories = ["properties", "comments", "revisions", "links", "objects"];
+async function sanitizeDocument(input, options, context) {
+  if (!(input instanceof Uint8Array)) throw new InputTypeError("Expected admitted document bytes.");
+  closedRecord(options, ["remove", "revisionPolicy", "input", "output", "inPlace", "force", "dryRun", "allowEmpty", "json", "limit"]);
+  const { input: identity, ...args } = options;
+  const settings = archiveSettings(context), invocation = validateDocxInvocation({ operation: "sanitize", inputs: ["document"], options: args }, settings.budget);
+  const opts = invocation.options;
+  const budget = settings.budget.lower(Object.fromEntries((opts.limit ?? []).map((item) => [item.name, item.value])));
+  budget.check("compressedInput", input.length);
+  budget.charge("retainedBytes", input.length);
+  const original = new Uint8Array(input), baseline = await readDocumentArchive(original, { ...settings, budget });
+  assertDocumentEditable(baseline, { ...settings, budget });
+  let staged = original;
+  const actions = [];
+  const gaps = ["Unselected categories, inactive or unknown markup and unrelated package data are retained.", "No comprehensive privacy or recoverability removal is provided."];
+  if (opts.remove.includes("revisions")) await editDocumentRevisionDecisions(original, { operation: opts.revisionPolicy === "accept" ? "revisions.accept" : "revisions.reject", options: { all: true, allowEmpty: true, scope: "all-stories", dryRun: true } }, { ...settings, budget, encoding: context.encoding });
+  const preflight = { ...settings, budget, encoding: context.encoding };
+  if (opts.remove.includes("properties")) {
+    const inventory = await inspectDocumentProperties(original, {}, preflight);
+    for (const item of inventory.items.filter((item2) => item2.support === "edit")) await editDocumentProperties(original, { operation: "properties.remove", name: item.name, dryRun: true }, preflight);
+  }
+  if (opts.remove.includes("comments")) await editDocumentComments(original, { operation: "comments.remove", options: { all: true, allowEmpty: true, dryRun: true } }, preflight);
+  if (opts.remove.includes("links")) {
+    const inventory = await inspectDocumentLinks(original, { scope: "all-stories" }, preflight);
+    for (const item of inventory.items.filter((item2) => item2.address !== "")) await editDocumentLinks(original, { operation: "links.remove", options: { select: item.location.token, dryRun: true } }, preflight);
+  }
+  if (opts.remove.includes("objects")) await prepareObjectSanitization(original, preflight);
+  async function stage(edit) {
+    const chunks = [];
+    const result = await edit({ ...settings, budget, encoding: context.encoding, stdout: { async write(bytes) {
+      budget.charge("retainedBytes", bytes.length);
+      chunks.push(new Uint8Array(bytes));
+    } } });
+    const length = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+    budget.charge("retainedBytes", length);
+    staged = new Uint8Array(length);
+    let offset = 0;
+    for (const chunk of chunks) {
+      staged.set(chunk, offset);
+      offset += chunk.length;
+    }
+    return result.changes.length;
+  }
+  for (const category of categories.filter((item) => opts.remove.includes(item))) {
+    let affected = 0, action;
+    const records = [];
+    if (category === "properties") {
+      action = "remove-supported-properties";
+      const inventory = await inspectDocumentProperties(staged, {}, { ...settings, budget });
+      if (inventory.items.some((item) => item.support !== "edit")) gaps.push("Cached, invalid, opaque or ambiguously owned properties are retained.");
+      for (const item of inventory.items.filter((item2) => item2.support === "edit")) {
+        affected += await stage((scope) => editDocumentProperties(staged, { operation: "properties.remove", name: item.name, output: "-" }, scope));
+        records.push(item.name);
+      }
+    } else if (category === "comments") {
+      action = "remove-supported-comments-and-markers";
+      const inventory = await inspectDocumentComments(staged, { operation: "comments.list", options: {} }, { ...settings, budget });
+      if (inventory.issues.length) throw new UnsupportedEditError("Comment structures cannot be sanitized safely.");
+      if (inventory.items.length) affected = await stage((scope) => editDocumentComments(staged, { operation: "comments.remove", options: { all: true, output: "-" } }, scope));
+      records.push(...inventory.items.map((item) => String(item.comment_id)));
+      gaps.push("Empty comment parts and unrelated comment resources may remain.");
+    } else if (category === "revisions") {
+      action = opts.revisionPolicy === "accept" ? "accept-supported-revisions" : "reject-supported-revisions";
+      affected = await stage(async (scope) => {
+        const result = await editDocumentRevisionDecisions(staged, { operation: opts.revisionPolicy === "accept" ? "revisions.accept" : "revisions.reject", options: { all: true, allowEmpty: true, scope: "all-stories", output: "-" } }, scope);
+        records.push(...result.changes.map((change) => change.before.token));
+        return result;
+      });
+    } else if (category === "links") {
+      action = "unwrap-external-hyperlinks-preserving-labels";
+      for (; ; ) {
+        const inventory = await inspectDocumentLinks(staged, { scope: "all-stories" }, { ...settings, budget });
+        const item = inventory.items.find((item2) => item2.address !== "");
+        if (!item) break;
+        affected += await stage((scope) => editDocumentLinks(staged, { operation: "links.remove", options: { select: item.location.token, output: "-" } }, scope));
+        records.push(item.location.token);
+      }
+      gaps.push("Internal anchors, field instructions and external bindings other than supported hyperlinks are retained.");
+    } else {
+      action = "remove-supported-inert-object-carriers";
+      const prepared = await prepareObjectSanitization(staged, { ...settings, budget, encoding: context.encoding });
+      records.push(...prepared.records);
+      gaps.push(...prepared.gaps);
+      affected = await stage(async (scope) => {
+        await publishDocumentArchive(prepared.archive, { output: "-" }, scope);
+        return { changes: records };
+      });
+    }
+    actions.push({ category, action, affected, records });
+  }
+  const changed = actions.some((action) => action.affected > 0);
+  if (!changed && !opts.allowEmpty) throw new SelectionError("missing-selection");
+  const archive = await readDocumentArchive(staged, { ...settings, budget });
+  const removedParts = baseline.package.parts.filter((part) => !archive.package.parts.some((next) => next.partname === part.partname)).map((part) => part.partname);
+  const removedRelationships = ["/", ...baseline.package.parts.filter((part) => part.content_type.toLowerCase() !== "application/vnd.openxmlformats-package.relationships+xml").map((part) => part.partname)].flatMap((owner) => baseline.package.relationships(owner).filter((edge) => !archive.package.parts.some((part) => part.partname === owner) && owner !== "/" || !archive.package.relationships(owner).some((next) => next.rId === edge.rId)).map((edge) => ({ owner, id: edge.rId })));
+  const data = { changed, actions, retained: categories.filter((item) => !opts.remove.includes(item)), gaps, removedParts, removedRelationships, dryRun: opts.dryRun ?? false, output: null };
+  measurePackageResourceSerialization({ ...data, output: { path: opts.output ?? identity?.path ?? null, bytes: Math.min(settings.limits.maxArchiveBytes, Number.MAX_SAFE_INTEGER), sha256: "0".repeat(64) } }, budget);
+  if (context.admitSanitization) {
+    const planned = Object.freeze({ ...data, actions: Object.freeze(actions.map((action) => Object.freeze({ ...action, records: Object.freeze([...action.records]) }))), retained: Object.freeze([...data.retained]), gaps: Object.freeze([...gaps]), removedParts: Object.freeze([...removedParts]), removedRelationships: Object.freeze(removedRelationships.map((edge) => Object.freeze({ ...edge }))), output: opts.dryRun ? null : Object.freeze({ path: opts.inPlace ? identity?.path ?? null : opts.output === "-" ? null : opts.output ?? null, bytes: Math.min(settings.limits.maxArchiveBytes, Number.MAX_SAFE_INTEGER), sha256: "0".repeat(64) }) });
+    const admitted = context.admitSanitization(planned);
+    if (admitted !== void 0) {
+      void Promise.resolve(admitted).catch(() => {
+      });
+      throw new DocxUsageError("Sanitization admission must be synchronous and return undefined.");
+    }
+  }
+  const published = await publishDocumentArchive(archive, { ...identity ? { input: identity } : {}, ...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 } }, { ...context, budget }, baseline, changed ? void 0 : original);
+  return { ...data, output: published.published.length ? { path: published.published[0].path, bytes: published.published[0].bytes, sha256: published.archiveSha256 } : null };
+}
+
+export {
+  sanitizeDocument
+};

package/dist/safe-bash/command-chunks/{chunk-OZHPB4KD.js → chunk-OU4VE5CR.js}

@@ -1,3 +1,12 @@
+import {
+  Exclusions
+} from "./chunk-2GILUQJY.js";
+import {
+  Reader
+} from "./chunk-5H7ZHP7F.js";
+import {
+  TransformedNames
+} from "./chunk-LSYPQ2W5.js";
 import {
   applyPax,
   numberField,
@@ -7,15 +16,6 @@ import {
 import {
   quoteName
 } from "./chunk-PYIG32ZI.js";
-import {
-  Exclusions
-} from "./chunk-CZLX3KVF.js";
-import {
-  Reader
-} from "./chunk-5H7ZHP7F.js";
-import {
-  TransformedNames
-} from "./chunk-LSYPQ2W5.js";
 
 // packages/safe-bash-command-tar/src/extract.ts
 import { compareIdentity } from "@poe-platform/safe-fs/contracts";
@@ -258,10 +258,10 @@ function verbose(entry, options) {
     if (entry.mode & special) permissions = permissions.slice(0, offset) + (entry.mode & execute ? lower : upper) + permissions.slice(offset + 1);
   }
   const suffix = entry.type === "2" ? ` -> ${quoteName(entry.linkname, options.quotingStyle)}` : entry.type === "1" ? ` link to ${quoteName(entry.linkname, options.quotingStyle)}` : "";
-  let timestamp = entry.mtime ?? "-";
-  if ((options.utc || options.metadata.fullTime) && entry.mtime !== void 0) {
+  let timestamp = "-";
+  if (entry.mtime !== void 0) {
     const iso = new Date((options.utc ? Math.floor(entry.mtime) : entry.mtime) * 1e3).toISOString().split("T").join(" ");
-    timestamp = options.utc ? iso.slice(0, options.metadata.fullTime ? 19 : 16) : iso.slice(0, -1);
+    timestamp = !options.metadata.fullTime ? iso.slice(0, 16) : options.utc ? iso.slice(0, 19) : iso.slice(0, -1);
     if (options.utc && options.metadata.fullTime) {
       let fraction = entry.mtime.toLocaleString("en-US", { useGrouping: false, maximumFractionDigits: 9 }).split(".")[1] ?? "";
       if (entry.mtime < 0 && fraction) fraction = String(10n ** BigInt(fraction.length) - BigInt(fraction)).padStart(fraction.length, "0");