@poe-platform/safe-bash 0.1.806 → 0.1.807

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

@@ -0,0 +1,552 @@
+import {
+  structureModelBatchActions
+} from "./chunk-DKNNYPOI.js";
+import {
+  ModelSaveStage,
+  modelSaveOperations,
+  styleModelBatchActions,
+  styleModelBatchBootstrap,
+  styleModelBatchOperations
+} from "./chunk-JQE256UO.js";
+import {
+  imageBatchActions
+} from "./chunk-Q6W5FRZG.js";
+import {
+  packageViewBatchActions
+} from "./chunk-IKHBXETN.js";
+import {
+  documentBatchActions
+} from "./chunk-TZ2J6LGM.js";
+import {
+  inspectDocumentParagraph,
+  inspectDocumentRun
+} from "./chunk-5AU5ENL5.js";
+import {
+  DocumentSession
+} from "./chunk-DV745GFU.js";
+import {
+  docxBatchMutates,
+  validateDocxBatch,
+  validateDocxInvocation
+} from "./chunk-DE66JRWJ.js";
+import {
+  Comment,
+  Comments,
+  Document,
+  DocumentView,
+  Drawing,
+  Hyperlink,
+  InlineShape,
+  InlineShapes,
+  Paragraph,
+  RenderedPageBreak,
+  Run,
+  Section,
+  Sections,
+  Settings,
+  Table,
+  _Cell,
+  _Column,
+  _Columns,
+  _Footer,
+  _Header,
+  _Row,
+  _Rows
+} from "./chunk-6PJIQEH4.js";
+import {
+  BaseStyle,
+  CharacterStyle,
+  ColorFormat,
+  Font,
+  LatentStyle,
+  LatentStyles,
+  ParagraphFormat,
+  ParagraphStyle,
+  RGBColor,
+  Styles,
+  TabStop,
+  TabStops,
+  TableStyle
+} from "./chunk-YQYVEVUE.js";
+import {
+  CommentsPart,
+  CoreProperties,
+  CorePropertiesPartView,
+  DocumentPartView,
+  FooterPart,
+  HeaderPart,
+  ImagePartView,
+  ImageParts,
+  NumberingPart,
+  PackageView,
+  PartView,
+  RelationshipView,
+  Relationships,
+  SettingsPart,
+  StoryPart,
+  StylesPart,
+  XmlElementView,
+  XmlPartView,
+  _NumberingDefinitions
+} from "./chunk-RZJRR4UJ.js";
+import {
+  PackURI
+} from "./chunk-S6PPBBXX.js";
+import {
+  Image
+} from "./chunk-A7EMM3SB.js";
+import {
+  modelContext
+} from "./chunk-2W54TAGI.js";
+import {
+  publishDocumentArchive
+} from "./chunk-HPKUFWHW.js";
+import {
+  admittedXml
+} from "./chunk-GLPIFP7N.js";
+import {
+  styleIds
+} from "./chunk-YPVBU7QF.js";
+import {
+  documentDialects
+} from "./chunk-MG7AJD5E.js";
+import {
+  Cm,
+  Inches,
+  Length,
+  Mm,
+  Pt,
+  Twips,
+  docxOperationSchemas,
+  isLength,
+  plainLength
+} from "./chunk-R4TYL2G6.js";
+import {
+  BoundsError
+} from "./chunk-OBK24KGM.js";
+import {
+  closedRecord,
+  encodeGeneratedLocation
+} from "./chunk-LQOKYG3O.js";
+import {
+  normalizePartName
+} from "./chunk-WAKYUXVQ.js";
+import {
+  UnsupportedProfileError,
+  parseDocumentXml
+} from "./chunk-MWAAMNAM.js";
+import {
+  DocxUsageError
+} from "./chunk-2P7BLWWI.js";
+import {
+  InputTypeError,
+  archiveSettings,
+  documentByteView
+} from "./chunk-IQFRPIXH.js";
+
+// packages/safe-bash-docx-engine/src/model-batch-effects.ts
+var ModelBatchEffects = class {
+  constructor(previous, sourceSha256, budget) {
+    this.previous = previous;
+    this.sourceSha256 = sourceSha256;
+    this.budget = budget;
+  }
+  previous;
+  sourceSha256;
+  budget;
+  generation = 0;
+  changes = [];
+  record(next) {
+    const before = new Map(this.previous.members.filter((member) => !member.directory).map((member) => [member.name, member.bytes]));
+    const after = new Map(next.members.filter((member) => !member.directory).map((member) => [member.name, member.bytes]));
+    const changed = [];
+    for (const name of /* @__PURE__ */ new Set([...before.keys(), ...after.keys()])) {
+      const a = before.get(name), b = after.get(name);
+      this.budget.charge("work", (a?.length ?? 0) + (b?.length ?? 0) + 1);
+      if (!a || !b || a.length !== b.length || !a.every((byte, index) => byte === b[index])) changed.push(name);
+    }
+    const locate = (name, generation) => {
+      const part = name.toLowerCase() === "[content_types].xml" ? "/[Content_Types].xml" : normalizePartName("/" + name);
+      const value = { version: 1, sourceSha256: this.sourceSha256, generation, part, story: "package", path: [], range: null };
+      const token = encodeGeneratedLocation(value);
+      this.budget.charge("retainedBytes", token.length * 4 + 256);
+      return { kind: "part", token, value, positions: {} };
+    };
+    const changes = changed.map((name) => ({
+      kind: !before.has(name) ? "add" : !after.has(name) ? "remove" : "set",
+      before: before.has(name) ? locate(name, this.generation) : null,
+      after: after.has(name) ? locate(name, this.generation + 1) : null
+    }));
+    if (changes.length) this.generation++;
+    this.previous = next;
+    this.changes.push(...changes);
+    return changes;
+  }
+};
+
+// packages/safe-bash-docx-engine/src/style-model-batch.ts
+var modelTypes = [
+  [DocumentView, "DocumentModel"],
+  [_NumberingDefinitions, "NumberingDefinitionsView"],
+  [_Header, "_Header"],
+  [_Footer, "_Footer"],
+  [XmlElementView, "XmlElementView"],
+  [ImagePartView, "ImagePart"],
+  [CorePropertiesPartView, "CorePropertiesPart"],
+  [DocumentPartView, "DocumentPart"],
+  [NumberingPart, "NumberingPart"],
+  [HeaderPart, "HeaderPart"],
+  [FooterPart, "FooterPart"],
+  [CommentsPart, "CommentsPart"],
+  [StoryPart, "StoryPart"],
+  [SettingsPart, "SettingsPart"],
+  [StylesPart, "StylesPart"],
+  [XmlPartView, "XmlPartView"],
+  [PartView, "PartView"],
+  [PackageView, "PackageView"],
+  [RelationshipView, "RelationshipView"],
+  [TableStyle, "_TableStyle"],
+  [ParagraphStyle, "ParagraphStyle"],
+  [CharacterStyle, "CharacterStyle"],
+  [BaseStyle, "BaseStyle"],
+  [LatentStyle, "_LatentStyle"],
+  [Drawing, "Drawing"],
+  [InlineShape, "InlineShape"],
+  [InlineShapes, "InlineShapes"],
+  [Settings, "Settings"],
+  [Paragraph, "Paragraph"],
+  [Run, "Run"],
+  [Table, "Table"],
+  [_Cell, "_Cell"],
+  [_Row, "_Row"],
+  [_Column, "_Column"],
+  [_Rows, "_Rows"],
+  [_Columns, "_Columns"],
+  [Section, "Section"],
+  [Sections, "Sections"],
+  [Comments, "Comments"],
+  [Comment, "Comment"],
+  [Hyperlink, "Hyperlink"],
+  [RenderedPageBreak, "RenderedPageBreak"],
+  [Styles, "Styles"],
+  [LatentStyles, "LatentStyles"],
+  [Font, "Font"],
+  [ParagraphFormat, "ParagraphFormat"],
+  [TabStops, "TabStops"],
+  [TabStop, "TabStop"],
+  [ColorFormat, "ColorFormat"],
+  [RGBColor, "RGBColor"],
+  [Relationships, "Relationships"],
+  [CoreProperties, "CoreProperties"],
+  [ImageParts, "ImageParts"]
+];
+async function applyStyleModelBatch(input, operations, context = {}) {
+  const settings = modelContext(context);
+  const batch = validateDocxBatch(operations, settings.budget);
+  for (const item of batch.operations) if (!styleModelBatchOperations.includes(item.operation) && !structureModelBatchActions.has(item.operation) && !["paragraphs.get", "runs.get"].includes(item.operation)) throw new UnsupportedProfileError("This model operation is not implemented by the style batch executor.");
+  const borrowed = documentByteView(input);
+  settings.budget.check("compressedInput", borrowed.length);
+  settings.budget.charge("retainedBytes", borrowed.length);
+  const source = new Uint8Array(borrowed);
+  const document = await Document(source, settings);
+  const readSession = batch.operations.some((item) => ["paragraphs.get", "runs.get"].includes(item.operation)) ? await DocumentSession.open(source, { ...settings, encoding: { order: "input", compression: "store" } }) : void 0;
+  const model = { package: document.store.package, warnings: [], save: (output, options) => document.save(output, options), publish: (options, context2) => document.store.publish(options, context2) };
+  const saved = new ModelSaveStage(settings);
+  const named = /* @__PURE__ */ new Map();
+  const objectIds = /* @__PURE__ */ new Map();
+  const results = [];
+  const operationResults = [];
+  settings.budget.charge("work", source.length);
+  const sourceSha256 = [...new Uint8Array(await crypto.subtle.digest("SHA-256", source))].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+  const effects = new ModelBatchEffects(document.store.snapshot(), sourceSha256, settings.budget);
+  let affected = 0;
+  const currentRevision = () => document.store.revision + model.package.revision;
+  let revision = currentRevision();
+  const isModel = (value) => modelTypes.some(([constructor]) => value instanceof constructor);
+  const type = (value) => modelTypes.find(([constructor]) => value instanceof constructor)[1];
+  function encode(value) {
+    if (value instanceof Date) return value.toISOString();
+    if (isLength(value)) return plainLength(value);
+    if (value instanceof PackURI) return value.toString();
+    if (value instanceof Uint8Array) {
+      const encodedLength = Math.ceil(value.length / 3) * 4;
+      settings.budget.charge("retainedBytes", value.length + encodedLength * 2);
+      settings.budget.charge("work", value.length + encodedLength);
+      settings.budget.check("serializedOutput", encodedLength + 40);
+      let binary = "";
+      for (let offset = 0; offset < value.length; offset += 4096) binary += String.fromCharCode(...value.subarray(offset, offset + 4096));
+      return { kind: "bytes", base64: btoa(binary) };
+    }
+    if (value instanceof Image) {
+      let id = objectIds.get(value);
+      if (!id) {
+        id = `handle${objectIds.size + 1}`;
+        objectIds.set(value, id);
+      }
+      return { id, type: "Image", owner: "batch", revision: 0 };
+    }
+    if (value instanceof Map) return [...value].map(([key, value2]) => ({ key, value: encode(value2) }));
+    if (isModel(value)) {
+      let id = objectIds.get(value);
+      if (!id) {
+        id = `handle${objectIds.size + 1}`;
+        objectIds.set(value, id);
+      }
+      return { id, type: type(value), owner: "document", revision: 0 };
+    }
+    if (Array.isArray(value)) return value.map(encode);
+    if (value && typeof value === "object" && Symbol.iterator in value) return [...value].map(encode);
+    return value === void 0 ? null : structuredClone(value);
+  }
+  function resolve(value) {
+    if (!value || typeof value !== "object") return value;
+    if (value instanceof Uint8Array || value instanceof Date) return value;
+    if (Array.isArray(value)) return value.map(resolve);
+    const record = value;
+    if (record.resultHandle === "document" && Object.keys(record).length === 1 || record.id === "document" && record.type === "DocumentModel" && record.owner === "document" && record.revision === 0) return document;
+    if (Object.keys(record).length === 2 && typeof record.value === "number" && typeof record.unit === "string") {
+      const constructors = { emu: Length, in: Inches, cm: Cm, mm: Mm, pt: Pt, twip: Twips };
+      const constructor = constructors[record.unit];
+      if (constructor) return constructor(record.value);
+    }
+    if (Object.hasOwn(record, "resultHandle")) {
+      if (typeof record.resultHandle !== "string" || !named.has(record.resultHandle)) throw new DocxUsageError("Unknown model result handle.");
+      let found = named.get(record.resultHandle);
+      if (record.index !== void 0) {
+        const sequence = Array.isArray(found) || found instanceof InlineShapes || found instanceof Sections || found instanceof _Rows || found instanceof _Columns;
+        if (!sequence) throw new DocxUsageError("The result handle does not support indexed selection.");
+        if (!Number.isSafeInteger(record.index) || Number(record.index) < 0 || Number(record.index) >= found.length) throw new BoundsError("Result handle index is out of bounds.");
+        found = Array.isArray(found) ? found[Number(record.index)] : found.at(Number(record.index));
+      }
+      if (record.key !== void 0) {
+        if (typeof record.key === "string" && found instanceof Map) {
+          if (!found.has(record.key)) throw new DocxUsageError("Unknown map key.");
+          return found.get(record.key);
+        }
+        if (typeof record.key !== "string" || !(found instanceof Styles || found instanceof LatentStyles)) throw new DocxUsageError("The result handle does not support keyed selection.");
+        found = found.at(record.key);
+      }
+      return found;
+    }
+    if (Object.hasOwn(record, "id") && Object.hasOwn(record, "owner")) {
+      throw new DocxUsageError("Use a named result handle from this batch for nonroot receivers.");
+    }
+    return Object.fromEntries(Object.entries(record).map(([key, item]) => [key, resolve(item)]));
+  }
+  for (const [index, item] of batch.operations.entries()) {
+    const utilityId = item.operation === "paragraphs.get" || item.operation === "runs.get" ? item.id ?? `step${index + 1}` : void 0;
+    try {
+      await settings.budget.checkpoint();
+      let value;
+      let resultValue;
+      let readLocations;
+      if (item.operation === "paragraphs.get" || item.operation === "runs.get") {
+        const read = item.operation === "paragraphs.get" ? inspectDocumentParagraph : inspectDocumentRun;
+        const data = await read(source, item.arguments, readSession.context);
+        const location = data.item.location;
+        let node = document.store.xml(location.value.part).root;
+        for (const position of location.value.path) node = node.children[position];
+        const ref = document.store.ref(location.value.part, node);
+        value = item.operation === "paragraphs.get" ? document.store.paragraph(ref) : document.store.run(ref);
+        resultValue = data;
+        readLocations = [location];
+      } else if (item.operation === styleModelBatchBootstrap) {
+        const receiver = resolve(item.receiver);
+        if (!(receiver instanceof DocumentView)) throw new DocxUsageError("Expected an admitted document owner.");
+        value = receiver.styles;
+      } else if (modelSaveOperations.includes(item.operation)) {
+        const receiver = resolve(item.receiver);
+        const valid = item.operation === "model.document.Document.save.call" ? receiver instanceof DocumentView : item.operation === "model.parts.document.DocumentPart.save.call" ? receiver instanceof DocumentPartView : receiver instanceof PackageView;
+        if (!valid || !(receiver instanceof DocumentView || receiver instanceof DocumentPartView || receiver instanceof PackageView))
+          throw new DocxUsageError("Expected an admitted save owner.");
+        await saved.capture(item.arguments.output, (sink) => receiver.save(sink));
+        value = void 0;
+      } else if (item.operation === "model.types.ProvidesStoryPart.part.get" || item.operation === "model.types.ProvidesXmlPart.part.get") {
+        const receiver = resolve(item.receiver);
+        if (!isModel(receiver) || !("part" in receiver)) throw new DocxUsageError("Expected an admitted part provider.");
+        const part = receiver.part;
+        if (!(part instanceof XmlPartView) || item.operation === "model.types.ProvidesStoryPart.part.get" && !(part instanceof StoryPart))
+          throw new DocxUsageError("The provider does not own the required native part role.");
+        value = part;
+      } else {
+        const receiver = resolve(item.receiver);
+        const args = Object.fromEntries(Object.entries(item.arguments).map(([key, value2]) => [key, resolve(value2)]));
+        const supplied = item.arguments.value;
+        if (receiver instanceof ParagraphFormat && item.operation.endsWith(".set") && supplied !== null && typeof supplied === "object" && "value" in supplied && "unit" in supplied) args.value = supplied;
+        const imageAction = imageBatchActions.get(item.operation), packageAction = packageViewBatchActions.get(item.operation);
+        value = await (imageAction ? imageAction(receiver, args, settings) : packageAction ? packageAction(receiver, args, settings) : (structureModelBatchActions.get(item.operation) ?? styleModelBatchActions.get(item.operation))(receiver, args));
+      }
+      if (item.resultHandle) {
+        if (value && typeof value === "object" && Symbol.iterator in value && "next" in value) {
+          const members = [];
+          for (const member of value) {
+            settings.budget.charge("work", 1);
+            settings.budget.charge("retainedBytes", 8);
+            members.push(member);
+          }
+          value = Object.freeze(members);
+        }
+        named.set(item.resultHandle, value);
+      }
+      const encoded = resultValue ?? encode(value);
+      results.push({ operation: item.operation, value: encoded });
+      const nextRevision = currentRevision();
+      const changes = nextRevision !== revision ? effects.record(document.store.snapshot()) : [];
+      if (readSession && changes.length) await readSession.stage(document.store.snapshot());
+      const count = changes.length ? 1 : 0;
+      affected += count;
+      const result = {
+        version: 1,
+        operation: item.operation,
+        ok: true,
+        data: encoded,
+        affected: count,
+        warnings: [],
+        errors: [],
+        locations: readLocations ?? changes.flatMap((change) => change.after ? [change.after] : [])
+      };
+      operationResults.push(utilityId === void 0 ? result : { ...result, id: utilityId });
+      revision = nextRevision;
+    } catch (cause) {
+      const error = cause instanceof Error ? cause : new Error("Document model batch operation failed.", { cause });
+      Object.assign(error, { operationIndex: index, ...utilityId === void 0 ? {} : { operationId: utilityId } });
+      throw error;
+    }
+  }
+  return {
+    save: saved.staged ? saved.save.bind(saved) : model.save,
+    publish: saved.staged ? saved.publish.bind(saved) : model.publish,
+    warnings: model.warnings,
+    results: Object.freeze(results),
+    operationResults: Object.freeze(operationResults),
+    changes: Object.freeze(effects.changes),
+    affected
+  };
+}
+
+// packages/safe-bash-docx-engine/src/batch.ts
+function rebaseLocations(value, generation, beforeGeneration, budget) {
+  budget.charge("work", 1);
+  if (!value || typeof value !== "object") return value;
+  if (Array.isArray(value)) return value.map((item) => rebaseLocations(item, generation, beforeGeneration, budget));
+  const record = value;
+  if (typeof record.token === "string" && record.token.startsWith("docx-loc-v1.") && record.value && typeof record.value === "object") {
+    const location = value;
+    const payload = { ...location.value, generation };
+    return { ...location, value: payload, token: encodeGeneratedLocation(payload) };
+  }
+  return Object.fromEntries(Object.entries(record).map(([key, child]) => [key, rebaseLocations(child, key === "before" ? beforeGeneration : generation, beforeGeneration, budget)]));
+}
+async function executeDocumentBatch(input, value, options, context) {
+  const settings = archiveSettings(context);
+  closedRecord(options, ["input", "output", "inPlace", "force", "dryRun", "json", "limit", "author", "timestamp"]);
+  if (![Object.prototype, null].includes(Object.getPrototypeOf(options))) throw new InputTypeError("Expected owned batch options.");
+  if (options.input !== void 0) {
+    closedRecord(options.input, ["path", "stat"]);
+    if (!options.input.stat || typeof options.input.stat !== "object" || Reflect.ownKeys(options.input.stat).some((key) => !Object.hasOwn(Object.getOwnPropertyDescriptor(options.input.stat, key), "value"))) throw new InputTypeError("Expected owned input identity.");
+  }
+  const { input: identity, ...operationOptions } = options;
+  const initial = validateDocxBatch(value, settings.budget, { author: options.author, timestamp: options.timestamp });
+  const invocation = validateDocxInvocation({ operation: "batch", inputs: [identity?.path ?? "document"], options: { ...operationOptions, ...initial } }, settings.budget);
+  const batch = { version: 1, operations: invocation.options.operations };
+  const budget = settings.budget.lower(Object.fromEntries((options.limit ?? []).map((item) => [item.name, item.value])));
+  if (batch.operations.length && batch.operations.some((item) => !documentBatchActions.has(item.operation) || item.resultHandle) && batch.operations.every((item) => !documentBatchActions.has(item.operation) || ["paragraphs.get", "runs.get"].includes(item.operation))) {
+    const model = await applyStyleModelBatch(input, batch, {
+      ...settings,
+      budget,
+      ...context.binaryResolver ? { binaryResolver: context.binaryResolver } : {},
+      ...context.registerCleanup ? { registerCleanup: context.registerCleanup } : {},
+      ...context.fontResolver ? { fontResolver: context.fontResolver } : {},
+      ...options.timestamp === void 0 ? {} : { timestamp: new Date(options.timestamp) },
+      ...options.author === void 0 ? {} : { author: options.author }
+    });
+    const mutates2 = docxBatchMutates(batch);
+    const publication2 = mutates2 ? { changed: model.affected > 0, changes: model.changes, dryRun: options.dryRun ?? false, output: null } : null;
+    const prospective2 = publication2 ? { ...publication2, output: options.dryRun ? null : { path: options.inPlace ? identity?.path ?? null : options.output === "-" ? null : options.output ?? null, bytes: settings.limits.maxArchiveBytes, sha256: "0".repeat(64) } } : null;
+    budget.check("serializedOutput", new TextEncoder().encode(JSON.stringify({
+      version: 1,
+      operation: "batch",
+      ok: true,
+      data: { results: model.operationResults, publication: prospective2 },
+      warnings: [],
+      errors: [],
+      affected: model.affected,
+      locations: []
+    }) + "\n").length);
+    if (publication2) {
+      const { limit: ignoredLimit, author: ignoredAuthor, timestamp: ignoredTimestamp, ...intent } = options;
+      const published = await model.publish(intent, { ...context, ...settings, budget });
+      if (published.published.length) Object.assign(publication2, { output: { path: options.output === "-" ? null : published.published[0].path, bytes: published.published[0].bytes, sha256: published.archiveSha256 } });
+    }
+    return { results: model.operationResults, publication: publication2 };
+  }
+  for (const item of batch.operations) if (!documentBatchActions.has(item.operation)) throw new UnsupportedProfileError("This operation is not implemented by the ordered utility batch executor.");
+  budget.charge("batchOperations", batch.operations.length);
+  if (!batch.operations.length) return { results: [], publication: null };
+  const session = await DocumentSession.open(input, { ...context, ...settings, budget });
+  let publicationSource = session.baseline;
+  const results = [];
+  const addedStyles = /* @__PURE__ */ new Map();
+  let changed = false;
+  for (const [index, item] of batch.operations.entries()) {
+    const id = item.id ?? `step${index + 1}`;
+    try {
+      await budget.checkpoint(1);
+      const mutates2 = docxOperationSchemas[item.operation].mutates;
+      const beforeGeneration = session.generation;
+      const previousMatches = budget.usage.matches;
+      const arguments_ = { ...item.arguments, ...mutates2 ? { output: "-" } : {} };
+      const priorStyles = item.operation === "styles.add" ? await session.snapshot() : void 0;
+      const data = rebaseLocations(await documentBatchActions.get(item.operation)(input, { ...item, arguments: arguments_ }, session.context), session.generation, beforeGeneration, budget);
+      if (priorStyles) {
+        const edge = priorStyles.package.relationships("/" + priorStyles.mainPart).find((edge2) => edge2.reltype === `${documentDialects[priorStyles.dialect].r}/styles` && !edge2.is_external);
+        const member = edge && priorStyles.members.find((member2) => member2.name === edge.target_part.name);
+        const previousIds = member ? styleIds(priorStyles[admittedXml]?.get(member.bytes) ?? parseDocumentXml(member.bytes, {}, budget).root, budget) : /* @__PURE__ */ new Set();
+        budget.charge("retainedBytes", previousIds.size * 32 + 64);
+        const ids = data.changes.filter((change) => !previousIds.has(change.id)).map((change) => change.id);
+        budget.charge("retainedBytes", ids.reduce((size2, id2) => size2 + id2.length * 4 + 32, 64));
+        addedStyles.set(id, new Set(ids));
+      }
+      const record = data;
+      const affected = mutates2 && record.changed !== false ? record.changes?.length ?? record.removedParts?.length ?? 0 : 0;
+      if (item.operation === "signatures.remove" && record.changed)
+        publicationSource = await session.snapshot();
+      const matches = mutates2 ? record.changes?.length ?? 0 : record.items?.length ?? (record.item ? 1 : 0);
+      budget.charge("matches", Math.max(0, matches - (budget.usage.matches - previousMatches)));
+      changed ||= record.changed === true;
+      const locations = record.changes ? record.changes.flatMap((change) => change.after ? [change.after] : []) : record.items?.flatMap((item2) => item2.location ? [item2.location] : []) ?? (record.item ? [record.item.location] : []);
+      const resultData = item.operation === "properties.get" ? { item: record.items[0] } : item.operation === "properties.list" ? { items: record.items } : ["images.list", "images.get", "custom-xml.list", "glossary.list"].includes(item.operation) ? Object.fromEntries(Object.entries(data).filter(([key]) => key !== "warnings")) : data;
+      results.push({ id, version: 1, operation: item.operation, ok: true, data: resultData, warnings: record.warnings ?? [], errors: [], affected, locations });
+      const size = new TextEncoder().encode(JSON.stringify(results)).length;
+      budget.check("serializedOutput", size);
+      budget.charge("retainedBytes", new TextEncoder().encode(JSON.stringify(results.at(-1))).length);
+    } catch (cause) {
+      const error = cause instanceof Error ? cause : new Error("Document batch operation failed.", { cause });
+      Object.assign(error, { operationIndex: index, operationId: id });
+      throw error;
+    }
+  }
+  const mutates = docxBatchMutates(batch);
+  const changes = results.flatMap((result) => {
+    const data = result.data;
+    return (data.changes ?? []).map((change) => {
+      const kind = change.kind === "style" ? result.operation === "styles.add" ? addedStyles.get(result.id).has(change.id) ? "add" : "set" : result.operation.endsWith(".add") ? "add" : result.operation.endsWith(".remove") ? "remove" : "set" : change.kind === "insert" ? "add" : change.kind === "format" ? "set" : change.kind === "delete" ? "remove" : change.kind;
+      return { kind, before: change.before ?? null, after: change.after ?? null };
+    });
+  });
+  const publication = mutates ? { changed, changes, dryRun: options.dryRun ?? false, output: null } : null;
+  const prospective = { results, publication: publication ? { ...publication, output: options.dryRun ? null : { path: options.inPlace ? identity?.path ?? null : options.output === "-" ? null : options.output ?? null, bytes: Math.min(settings.limits.maxArchiveBytes, Number.MAX_SAFE_INTEGER), sha256: "0".repeat(64) } } : null };
+  budget.check("serializedOutput", new TextEncoder().encode(JSON.stringify({ version: 1, operation: "batch", ok: true, data: prospective, warnings: [], errors: [], affected: results.reduce((sum, result) => sum + result.affected, 0), locations: [] }) + "\n").length);
+  if (mutates) {
+    const archive = await session.snapshot();
+    const { limit: ignoredLimit, author: ignoredAuthor, timestamp: ignoredTimestamp, ...intent } = options;
+    const published = await publishDocumentArchive(archive, intent, { ...context, ...settings, budget }, publicationSource);
+    if (publication && published.published.length) Object.assign(publication, { output: { path: options.output === "-" ? null : published.published[0].path, bytes: published.published[0].bytes, sha256: published.archiveSha256 } });
+  }
+  return { results: Object.freeze(results), publication };
+}
+
+export {
+  applyStyleModelBatch,
+  executeDocumentBatch
+};