@poe-platform/safe-bash 0.1.806 → 0.1.807

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

@@ -0,0 +1,294 @@
+import {
+  ControlClonePlanner,
+  editDocumentControlRepeats,
+  templateRepeatAdmission
+} from "./chunk-N4DY4FPA.js";
+import {
+  editDocumentControls,
+  inspectDocumentControls,
+  prepareControlPlaceholder
+} from "./chunk-2B6XWO6A.js";
+import {
+  DocumentArchiveEditor
+} from "./chunk-MAHX3IW3.js";
+import {
+  validateDocxInvocation
+} from "./chunk-DE66JRWJ.js";
+import {
+  pathContains
+} from "./chunk-IR6ZKAUH.js";
+import {
+  assertDocumentEditable,
+  publishDocumentArchive
+} from "./chunk-HPKUFWHW.js";
+import {
+  admitDocumentArchive,
+  admittedXml,
+  readDocumentArchive
+} from "./chunk-GLPIFP7N.js";
+import {
+  UnsupportedEditError
+} from "./chunk-YPVBU7QF.js";
+import {
+  SelectionError,
+  encodeGeneratedLocation
+} from "./chunk-LQOKYG3O.js";
+import {
+  DocxUsageError
+} from "./chunk-2P7BLWWI.js";
+import {
+  InputTypeError,
+  ResourceLimitError,
+  archiveSettings,
+  documentSession,
+  documentXmlCache
+} from "./chunk-IQFRPIXH.js";
+
+// packages/safe-bash-docx-engine/src/document-session.ts
+var DocumentSession = class _DocumentSession {
+  baseline;
+  context;
+  #input;
+  #settings;
+  #archive;
+  #admitted;
+  #parsed;
+  #generation = 0;
+  constructor(input, context, baseline) {
+    this.#settings = archiveSettings(context);
+    this.#input = input;
+    this.baseline = baseline;
+    this.#archive = baseline;
+    this.#admitted = baseline;
+    this.#parsed = baseline[admittedXml] ?? /* @__PURE__ */ new Map();
+    this.context = { ...context, ...this.#settings, [documentSession]: this };
+  }
+  static async open(input, context) {
+    if (context[documentSession]) throw new InputTypeError("Nested document sessions are unsupported.");
+    const settings = archiveSettings(context);
+    settings.budget[documentXmlCache].entries ??= /* @__PURE__ */ new Map();
+    settings.budget[documentXmlCache].admitted ??= /* @__PURE__ */ new WeakSet();
+    return new _DocumentSession(input, { ...context, ...settings }, await readDocumentArchive(input, settings));
+  }
+  get generation() {
+    return this.#generation;
+  }
+  async read(input) {
+    if (!(input instanceof Uint8Array)) throw new InputTypeError("Expected document session source bytes.");
+    if (input !== this.#input) {
+      this.#settings.budget.charge("work", input.length);
+      if (input.length !== this.#input.length || !input.every((value, index) => value === this.#input[index]))
+        throw new InputTypeError("Input differs from document session source.");
+    }
+    return this.snapshot();
+  }
+  async stage(archive) {
+    const { limits, budget, signal } = this.#settings;
+    signal.throwIfAborted();
+    if (!archive || !Array.isArray(archive.members) || !(archive.comment instanceof Uint8Array))
+      throw new InputTypeError("Expected an owned document archive.");
+    if (archive.members.length > limits.maxMembers || archive.comment.length > limits.maxCommentBytes)
+      throw new ResourceLimitError("Document snapshot metadata limit exceeded.");
+    let total = 0;
+    const names = /* @__PURE__ */ new Set();
+    const previous = new Map(this.#archive.members.map((member) => [member.name, member]));
+    const members = archive.members.map((member) => {
+      if (!member || typeof member.name !== "string" || !(member.bytes instanceof Uint8Array) || !(member.modified instanceof Date) || !Number.isFinite(member.modified.getTime()) || typeof member.directory !== "boolean")
+        throw new InputTypeError("Expected typed document members.");
+      if (names.has(member.name)) throw new InputTypeError("Duplicate document snapshot member.");
+      names.add(member.name);
+      total += member.bytes.length;
+      if (member.bytes.length > limits.maxEntryBytes || member.name.length > limits.maxPathBytes || total > limits.maxTotalBytes)
+        throw new ResourceLimitError("Document snapshot member limit exceeded.");
+      const old = previous.get(member.name);
+      budget.charge("work", member.bytes.length);
+      if (old && old.directory === member.directory && old.modified.getTime() === member.modified.getTime() && old.bytes.length === member.bytes.length && old.bytes.every((value, index) => value === member.bytes[index])) return old;
+      budget.charge("retainedBytes", member.bytes.length + member.name.length * 2 + 128);
+      return { ...member, bytes: new Uint8Array(member.bytes), modified: new Date(member.modified.getTime()) };
+    });
+    budget.check("expandedPackage", total);
+    budget.charge("retainedBytes", archive.comment.length + members.length * 8);
+    const changed = members.length !== this.#archive.members.length || members.some((member, index) => member !== this.#archive.members[index]) || archive.comment.length !== this.#archive.comment.length || !archive.comment.every((value, index) => value === this.#archive.comment[index]);
+    if (changed) {
+      if (this.#generation === Number.MAX_SAFE_INTEGER) throw new ResourceLimitError("Document generation limit exceeded.");
+      this.#generation++;
+    }
+    this.#archive = { members, comment: new Uint8Array(archive.comment) };
+    this.#admitted = void 0;
+  }
+  async snapshot() {
+    if (!this.#admitted) {
+      const retained = new Set(this.#archive.members.map((member) => member.bytes));
+      this.#parsed = new Map([...this.#parsed].filter(([bytes]) => retained.has(bytes)));
+      this.#admitted = await admitDocumentArchive(this.#archive, this.#settings, 0, this.#parsed);
+    }
+    return this.#admitted;
+  }
+};
+
+// packages/safe-bash-docx-engine/src/template.ts
+var inside = (parent, child) => parent.value.part === child.value.part && pathContains(parent.value.path, child.value.path);
+function declarations(items, budget, owner, depth = 0) {
+  budget.charge("work", items.length + 1);
+  let pathLength = 1;
+  for (const item of items) pathLength = Math.max(pathLength, item.location.value.path.length);
+  budget.charge("work", (items.length + 1) * (items.length + 1) * (32 + pathLength * 8));
+  budget.charge("retainedBytes", (items.length + 1) * 512);
+  budget.check("templateRepeatDepth", depth);
+  const candidates = items.filter((item) => (!owner || inside(owner.location, item.location) && owner !== item) && item.tag !== null && item.kind !== "repeating-item");
+  const direct = candidates.filter((item) => !candidates.some((parent) => parent !== item && parent.kind === "repeating-section" && inside(parent.location, item.location)));
+  const result = [];
+  for (const item of direct) {
+    if (result.some((declaration) => declaration.control.tag === item.tag)) continue;
+    const recipients = direct.filter((candidate) => candidate.tag === item.tag);
+    if (recipients.some((candidate) => candidate.kind !== item.kind || JSON.stringify(candidate.choices) !== JSON.stringify(item.choices)) || item.kind === "repeating-section" && recipients.length !== 1) throw new DocxUsageError("Template binding declarations conflict.");
+    if (recipients.some((candidate) => candidate.lock !== "unlocked" || candidate.binding !== null || candidate.support !== "supported")) throw new UnsupportedEditError("Template bindings must be admitted, unlocked and unbound.");
+    let fields = [];
+    if (item.kind === "repeating-section") {
+      const nativeItems = items.filter((candidate) => candidate.kind === "repeating-item" && inside(item.location, candidate.location) && !items.some((parent) => parent !== item && parent.kind === "repeating-section" && inside(item.location, parent.location) && inside(parent.location, candidate.location)));
+      if (!nativeItems.length) throw new UnsupportedEditError("A template repeat requires a native prototype.");
+      const schema = (fields2) => JSON.stringify(fields2.map((field) => ({ tag: field.control.tag, kind: field.control.kind, choices: field.control.choices, fields: JSON.parse(schema(field.fields)) })).sort((a, b) => a.tag < b.tag ? -1 : a.tag > b.tag ? 1 : 0));
+      for (const nativeItem of nativeItems) {
+        const candidate = declarations(items.filter((item2) => inside(nativeItem.location, item2.location)), budget, nativeItem, depth + 1);
+        if (nativeItem === nativeItems[0]) fields = candidate;
+        else if (schema(candidate) !== schema(fields)) throw new DocxUsageError("Prior template items have conflicting binding schemas.");
+      }
+    }
+    result.push({ control: item, recipients, fields });
+  }
+  return result;
+}
+function scalarOptions(item, value) {
+  if (["plain-text", "rich-text"].includes(item.kind) && typeof value === "string") return { text: value };
+  if (item.kind === "checkbox" && typeof value === "boolean") return { checked: value };
+  if (["dropdown", "combo-box"].includes(item.kind) && typeof value === "string") return { choice: value };
+  if (item.kind === "date" && typeof value === "string") return { date: value };
+  throw new DocxUsageError("Template value conflicts with its declared control type.");
+}
+function validateRecord(record, fields, budget) {
+  budget.charge("work", (record.values.length + 1) * (fields.length + 1) * 16);
+  if (record.values.length !== fields.length || record.values.some((value) => !fields.some((field) => field.control.tag === value.binding))) throw new DocxUsageError("Template records must exactly match their declared bindings.");
+  for (const field of fields) {
+    const value = record.values.find((value2) => value2.binding === field.control.tag).value;
+    if (field.control.kind === "repeating-section") {
+      if (!Array.isArray(value)) throw new DocxUsageError("A declared repeat requires a record array.");
+      budget.check("templateRepeatItems", value.length);
+      budget.charge("matches", Math.max(1, value.length));
+      for (const record2 of value) validateRecord(record2, field.fields, budget);
+    } else scalarOptions(field.control, value);
+  }
+}
+async function applyDocumentTemplate(input, options, context) {
+  const settings = archiveSettings(context), { input: identity, ...args } = options;
+  const opts = validateDocxInvocation({ operation: "template.apply", inputs: [identity?.path ?? "document"], options: args }, settings.budget).options;
+  const budget = settings.budget.lower(Object.fromEntries((opts.limit ?? []).map((item) => [item.name, item.value])));
+  const bounded = { ...context, ...settings, budget };
+  const session = context[documentSession] ?? await DocumentSession.open(input, bounded);
+  const staged = { ...bounded, [documentSession]: session };
+  const baseline = await session.read(input);
+  assertDocumentEditable(baseline, staged, baseline);
+  const initial = (await inspectDocumentControls(input, {}, staged)).items;
+  const fields = declarations(initial, budget);
+  const array = Array.isArray(opts.data);
+  let values;
+  if (array) {
+    const regions = fields.filter((field) => field.control.kind === "repeating-section");
+    if (regions.length !== 1) throw new SelectionError(regions.length ? "ambiguous-selection" : "missing-selection", regions.map((field) => field.control.location.token));
+    if (fields.length !== 1) throw new DocxUsageError("Top-level template arrays cannot omit singleton bindings.");
+    values = { values: [{ binding: regions[0].control.tag, value: opts.data }] };
+  } else values = opts.data;
+  validateRecord(values, fields, budget);
+  const repeated = fields.filter((field) => field.control.kind === "repeating-section");
+  if (repeated.length) {
+    const editor = new DocumentArchiveEditor(baseline, {}, void 0, budget), planner = new ControlClonePlanner(baseline, staged);
+    const child = (node, name, namespace = node.namespace) => node.children.find((child2) => child2.namespace === namespace && child2.localName === name);
+    for (const item of initial.filter((item2) => repeated.some((region) => inside(region.control.location, item2.location)))) {
+      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);
+      }
+      if (item.kind === "repeating-section") {
+        const content = child(node, "sdtContent");
+        if (!content?.children.length || content.children.some((item2) => item2.namespace !== node.namespace || item2.localName !== "sdt" || !child(item2, "sdtPr") || !child(child(item2, "sdtPr"), "repeatingSectionItem", "http://schemas.microsoft.com/office/word/2012/wordml"))) throw new UnsupportedEditError("Every prior native repeat requires only declared reusable items.");
+      } else if (item.kind === "repeating-item") {
+        const body = child(node, "sdtContent"), regionParent = ancestors.at(-4);
+        const row = regionParent?.namespace === node.namespace && regionParent.localName === "tbl";
+        if (!body || !body.children.length || (row ? body.children.length !== 1 || body.children[0].localName !== "tr" || body.children[0].namespace !== node.namespace : body.children.some((block) => block.namespace !== node.namespace || !(["p", "tbl"].includes(block.localName) || block.localName === "sdt" && child(block, "sdtPr") && child(child(block, "sdtPr"), "repeatingSection", "http://schemas.microsoft.com/office/word/2012/wordml"))))) throw new UnsupportedEditError("Every prior native template item requires an admitted row/block shape.");
+        planner.preflight(xml, node, item.location.value.part);
+        await planner.admitMedia(xml, node, item.location.value.part);
+      } else if (item.tag !== null && !["repeating-section", "picture"].includes(item.kind)) prepareControlPlaceholder(xml, node, item, staged);
+    }
+  }
+  const changes = [];
+  let inventory = initial, inventoryGeneration = session.generation;
+  const current = async (location) => {
+    if (inventoryGeneration !== session.generation) {
+      inventory = (await inspectDocumentControls(input, {}, staged)).items;
+      inventoryGeneration = session.generation;
+    }
+    const item = inventory.find((item2) => item2.location.value.part === location.value.part && item2.location.value.path.length === location.value.path.length && pathContains(location.value.path, item2.location.value.path));
+    if (!item) throw new UnsupportedEditError("A staged template declaration disappeared.");
+    return item;
+  };
+  const fill = async (fields2, record, top = false) => {
+    const ordered = [...fields2].sort((a, b) => {
+      const left = a.control.location.value.path, right = b.control.location.value.path;
+      for (let index = 0; index < Math.min(left.length, right.length); index++) if (left[index] !== right[index]) return right[index] - left[index];
+      return right.length - left.length;
+    });
+    for (const field of ordered) {
+      const value = record.values.find((value2) => value2.binding === field.control.tag).value;
+      const before = field.control.location;
+      if (field.control.kind !== "repeating-section") {
+        for (const recipient of [...field.recipients].reverse()) {
+          const item = await current(recipient.location);
+          const data2 = await editDocumentControls(input, { select: item.location.token, ...scalarOptions(item, value), dryRun: true }, staged);
+          if (top) changes.push({ kind: "replace", before: recipient.location, after: data2.changes[0].after });
+        }
+        continue;
+      }
+      const records = value;
+      const scalarRecords = records.map((record2) => ({ values: record2.values.filter((value2) => !Array.isArray(value2.value)) }));
+      const region = await current(before);
+      const repeated2 = await editDocumentControlRepeats(input, { select: region.location.token, data: scalarRecords, dryRun: true }, { ...staged, [templateRepeatAdmission]: true });
+      if (field.fields.some((field2) => field2.control.kind === "repeating-section")) {
+        const inventory2 = (await inspectDocumentControls(input, {}, staged)).items;
+        const items = inventory2.filter((item) => item.kind === "repeating-item" && inside(region.location, item.location) && !inventory2.some((parent) => parent.kind === "repeating-section" && parent.location.value.path.length > region.location.value.path.length && inside(region.location, parent.location) && inside(parent.location, item.location)));
+        for (let index = items.length - 1; index >= 0; index--) {
+          const item = items[index];
+          const nested = declarations(inventory2.filter((candidate) => inside(item.location, candidate.location)), budget, item).filter((field2) => field2.control.kind === "repeating-section");
+          const nestedRecord = records[index] ?? { values: nested.map((field2) => ({ binding: field2.control.tag, value: [] })) };
+          await fill(nested, nestedRecord);
+        }
+      }
+      if (top) {
+        changes.push({ kind: "replace", before, after: repeated2.changes[0].after });
+      }
+    }
+  };
+  await fill(fields, values, true);
+  const final = await session.read(input);
+  const data = { changed: changes.length > 0, changes: changes.map((change) => {
+    const value = { ...change.after.value, generation: session.generation };
+    return { ...change, after: { ...change.after, value, token: encodeGeneratedLocation(value) } };
+  }), dryRun: opts.dryRun ?? false, output: null };
+  const prospective = { ...data, output: opts.dryRun ? null : { path: opts.inPlace ? identity?.path ?? null : opts.output ?? null, bytes: Math.min(settings.limits.maxArchiveBytes, Number.MAX_SAFE_INTEGER), sha256: "0".repeat(64) } };
+  budget.check("serializedOutput", new TextEncoder().encode(JSON.stringify({ version: 1, operation: "template.apply", ok: true, data: prospective, affected: data.changes.length, locations: data.changes.map((change) => change.after), warnings: [], errors: [] })).length);
+  const intent = {
+    ...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 }
+  };
+  const published = await publishDocumentArchive(final, { ...intent, ...identity ? { input: identity } : {} }, bounded, baseline);
+  return { ...data, output: published.published.length ? { path: published.published[0].path, bytes: published.published[0].bytes, sha256: published.archiveSha256 } : null };
+}
+
+export {
+  DocumentSession,
+  applyDocumentTemplate
+};

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

@@ -0,0 +1,33 @@
+import {
+  documentDialects
+} from "./chunk-MG7AJD5E.js";
+import {
+  parseMediaType
+} from "./chunk-MWAAMNAM.js";
+
+// packages/safe-bash-docx-engine/src/document-part-roles.ts
+function documentPartRole(contentType, root) {
+  const types = {
+    "document.main": ["document", "story"],
+    "template.main": ["document", "story"],
+    header: ["hdr", "story"],
+    footer: ["ftr", "story"],
+    footnotes: ["footnotes", "story"],
+    endnotes: ["endnotes", "story"],
+    comments: ["comments", "story"],
+    "document.glossary": ["glossaryDocument", "glossary"],
+    settings: ["settings", "settings"]
+  };
+  const type = parseMediaType(contentType);
+  if (type === "application/vnd.openxmlformats-officedocument.customxmlproperties+xml") return root.namespace === "http://schemas.openxmlformats.org/officeDocument/2006/customXml" && root.localName === "datastoreItem" ? "custom-xml-properties" : null;
+  for (const [suffix, [name, role]] of Object.entries(types)) if (type === `application/vnd.openxmlformats-officedocument.wordprocessingml.${suffix}+xml` && root.localName === name && Object.values(documentDialects).some((dialect) => dialect.w === root.namespace)) return role;
+  return null;
+}
+var signatureContentTypes = Object.freeze(["application/vnd.openxmlformats-package.digital-signature-origin", "application/vnd.openxmlformats-package.digital-signature-xmlsignature+xml", "application/vnd.openxmlformats-package.digital-signature-certificate"]);
+var signatureRelationshipTypes = Object.freeze(["signature", "origin", "certificate"].map((role) => `http://schemas.openxmlformats.org/package/2006/relationships/digital-signature/${role}`));
+
+export {
+  documentPartRole,
+  signatureContentTypes,
+  signatureRelationshipTypes
+};