@poe-platform/safe-bash 0.1.806 → 0.1.807

package/dist/safe-bash/command-chunks/{chunk-Z7UIOPHJ.js → chunk-DCMSPMMD.js}

@@ -1,6 +1,6 @@
 import {
   encode
-} from "./chunk-OOB7YCFQ.js";
+} from "./chunk-FMJKCVSQ.js";
 import {
   CurlError
 } from "./chunk-QYXWTNUN.js";

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

@@ -0,0 +1,352 @@
+import {
+  normalizeDocxPropertyOptions
+} from "./chunk-7Y3ZQ6FE.js";
+import {
+  partProviderReceivers
+} from "./chunk-RMJNV6Q7.js";
+import {
+  validateDocxSelection
+} from "./chunk-SSRGI476.js";
+import {
+  validateDocxOptionRules
+} from "./chunk-BZOY2UMP.js";
+import {
+  assertDocxFields,
+  docxCommonOptions,
+  docxEnumCanonicalNames,
+  docxOperationSchemas,
+  splitDocxType,
+  validateDocxValue
+} from "./chunk-R4TYL2G6.js";
+import {
+  BoundsError
+} from "./chunk-OBK24KGM.js";
+import {
+  decodeLocation
+} from "./chunk-LQOKYG3O.js";
+import {
+  DocxUsageError,
+  copyDocxBytes,
+  docxByteLength
+} from "./chunk-2P7BLWWI.js";
+import {
+  DocumentBudget
+} from "./chunk-IQFRPIXH.js";
+
+// packages/safe-bash-docx-engine/src/invocation.ts
+var SourceError = class extends Error {
+  code = "source-failure";
+  constructor(cause) {
+    super("Unable to acquire the declared JSON source.", { cause });
+  }
+};
+var selectors = ["section", "paragraph", "run", "table", "cell", "image", "comment", "note", "link", "control", "revision", "shape", "field", "bookmark"];
+var publication = ["output", "outputDir", "inPlace", "force", "dryRun", "json", "limit", "timestamp", "author"];
+var docxInvocationBudgets = /* @__PURE__ */ new WeakMap();
+function usage(message) {
+  throw new DocxUsageError(message);
+}
+function schemaFor(id) {
+  if (!Object.hasOwn(docxOperationSchemas, id)) usage("Unknown document operation.");
+  return docxOperationSchemas[id];
+}
+function record(value, allowed) {
+  if (!value || typeof value !== "object" || Array.isArray(value) || ![Object.prototype, null].includes(Object.getPrototypeOf(value))) usage("Expected a closed argument object.");
+  const result = {};
+  for (const key of Reflect.ownKeys(value).sort((a, b) => String(a) < String(b) ? -1 : String(a) > String(b) ? 1 : 0)) {
+    if (typeof key !== "string" || ["__proto__", "constructor", "prototype"].includes(key) || allowed && !allowed.includes(key)) usage("Unknown argument field.");
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    if (!("value" in descriptor)) usage("Argument accessors are not permitted.");
+    if (descriptor.value !== void 0) result[key] = descriptor.value;
+  }
+  return result;
+}
+function path(value) {
+  if (typeof value !== "string" || value.length === 0 || value.includes("\0") || !validateDocxValue("string", value)) usage("Expected a nonempty Unicode path.");
+}
+function owned(value, budget) {
+  if (typeof value === "string") budget.charge("retainedBytes", new TextEncoder().encode(value).length);
+  if (value instanceof Uint8Array) {
+    budget.charge("retainedBytes", docxByteLength(value));
+    return copyDocxBytes(value);
+  }
+  if (value instanceof Date) return new Date(value.getTime());
+  if (Array.isArray(value)) return Object.freeze(value.map((item) => owned(item, budget)));
+  if (value && typeof value === "object") return Object.freeze(Object.fromEntries(Object.entries(value).filter(([, v]) => v !== void 0).map(([key, v]) => [key, owned(v, budget)])));
+  return value;
+}
+function structuredBudget(value, budget) {
+  let nodes = 0;
+  const visit = (item, depth) => {
+    budget.check("xmlNodes", ++nodes);
+    budget.check("xmlDepth", depth);
+    if (!item || typeof item !== "object" || item instanceof Date || item instanceof Uint8Array) return;
+    if (!Array.isArray(item) && item.kind === "table") {
+      const rows = item.rows;
+      if (Array.isArray(rows) && Array.isArray(rows[0])) budget.table(rows.length, rows[0].length);
+    }
+    for (const child of Object.values(item)) visit(child, depth + 1);
+  };
+  visit(value, 1);
+}
+function lowerLimits(value, budget) {
+  if (value === void 0) return budget;
+  if (!validateDocxValue(docxCommonOptions.limit.type, value)) usage("Invalid document limits.");
+  const entries = value;
+  if (new Set(entries.map((item) => item.name)).size !== entries.length) usage("Repeated document limit.");
+  try {
+    return budget.lower(Object.fromEntries(entries.map((item) => [item.name, item.value])));
+  } catch {
+    return usage("Document limits must be valid safe integers.");
+  }
+}
+function optionFields(schema, cli) {
+  return Object.fromEntries([...schema.commonOptions.map((name) => [name, docxCommonOptions[name]]), ...Object.entries(cli ? schema.fields : schema.sdkFields)]);
+}
+function validateSelections(operation, options) {
+  const selected = selectors.filter((key) => options[key] !== void 0 && !(key === "bookmark" && ["links.add", "links.set"].includes(operation)));
+  if (options.select !== void 0) {
+    try {
+      decodeLocation(options.select);
+    } catch {
+      usage("Invalid selection token.");
+    }
+    if (selected.length || options.scope !== void 0) usage("Token and simple selection cannot be combined.");
+  }
+  if (options.run !== void 0 && options.paragraph === void 0) usage("Run selection requires paragraph.");
+  if (options.cell !== void 0 && options.table === void 0) usage("Cell selection requires table.");
+  if (options.comment !== void 0 && options.note !== void 0 || ["image", "link", "control", "revision", "shape", "field", "bookmark"].filter((key) => selected.includes(key)).length > 1) usage("Sibling selectors cannot be combined.");
+  const paragraphOwner = operation === "paragraphs.set" && selected.length > 0 && selected.every((key) => ["section", "table", "cell", "note", "comment"].includes(key));
+  if (options.all === true && operation !== "text.replace" && (selected.length && !paragraphOwner || options.select !== void 0)) usage("All conflicts with a target selection.");
+  if (options.before === true && options.paragraph === void 0 && !(operation === "paragraphs.add" && options.select !== void 0)) usage("Before requires a paragraph anchor.");
+  if (operation.startsWith("headers.") || operation.startsWith("footers.")) {
+    const scope = operation.split(".")[0];
+    if (options.scope !== void 0 && options.scope !== scope && options.scope !== "all-stories") usage("Inapplicable story scope.");
+  }
+  const global = ["styles", "properties", "settings", "signatures", "custom-xml", "glossary"];
+  if (global.includes(operation.split(".")[0]) && (selected.length || options.select !== void 0 || options.scope !== void 0)) usage("Package-global resources reject story selection.");
+}
+function validateEffects(operation, options, schema) {
+  const has = (name) => options[name] !== void 0;
+  if (operation === "text.replace") {
+    if (options.trackChanges === true) {
+      if (!has("author") || !has("timestamp")) usage("Tracked replacement requires explicit author and timestamp.");
+    } else if (has("author") || has("timestamp")) usage("Untracked replacement rejects author and timestamp.");
+    if (options.find === "") usage("Search text must not be empty.");
+    if (Number(options.first === true) + Number(options.all === true) + Number(has("occurrence")) !== 1) usage("Choose exactly one text match cardinality.");
+  }
+  if (operation.endsWith(".set") && !operation.startsWith("model.") && !Object.keys(schema.sdkFields).some((key) => has(key) && (!["name", "variant", "kind", "covered"].includes(key) || operation === "fields.set" && key === "kind"))) usage("Set requires an effect field.");
+  if (has("style") && has("level")) usage("Style and heading level conflict.");
+  if (options.superscript === true && options.subscript === true) usage("Conflicting baseline formatting.");
+  if (operation === "tables.set" && has("text") && !has("cell") && !has("select")) usage("Table text requires a cell.");
+  if (operation === "lists.set" && has("start") && options.restart !== true) usage("Start requires restart.");
+  if ((operation === "links.add" || operation === "links.set") && Number(has("target")) + Number(has("bookmark")) !== 1) usage("Choose one link target.");
+  if (operation === "controls.set" && ["text", "checked", "choice", "date", "file"].filter(has).length !== 1) usage("Choose one control value.");
+  if (options.linkToPrevious === true && (has("text") || options.shared === true)) usage("Conflicting linked story options.");
+  if (has("fit") && (!has("width") || !has("height"))) usage("Fit requires both dimensions.");
+  if (has("fit") && ["cropLeft", "cropRight", "cropTop", "cropBottom"].some(has)) usage("Fit conflicts with crop.");
+  if (options.shared === true && operation === "images.replace" && (has("width") || has("height"))) usage("Shared replacement cannot resize occurrences.");
+  if (options.decorative === true && typeof options.alt === "string" && options.alt.length > 0) usage("Decorative content cannot have nonempty alt text.");
+  for (const [left, right] of [["cropLeft", "cropRight"], ["cropTop", "cropBottom"]]) {
+    if (Number(options[left] ?? 0) + Number(options[right] ?? 0) >= 1) usage("Opposing crops must total less than one.");
+  }
+}
+function validateInvocation(value, budget, fromCli) {
+  const input = record(value, ["operation", "inputs", "options", ...fromCli ? ["sources"] : []]);
+  if (typeof input.operation !== "string") usage("Operation is required.");
+  const operation = input.operation;
+  const schema = schemaFor(operation);
+  if (schema.transport === "typed-batch") usage("Advanced operations require a typed batch.");
+  if (!Array.isArray(input.inputs) || Object.getPrototypeOf(input.inputs) !== Array.prototype || !validateDocxValue("ReadonlyArray<string>", input.inputs)) usage("Expected input paths.");
+  const inputs = input.inputs.map((value2) => {
+    path(value2);
+    return value2;
+  });
+  if (operation === "capabilities" ? inputs.length > 1 : inputs.length !== schema.inputArity) usage("Invalid input arity.");
+  const options = record(input.options);
+  if (operation === "properties.set") Object.assign(options, normalizeDocxPropertyOptions(options, false));
+  const sources = input.sources ?? [];
+  const fields = optionFields(schema, false);
+  const deferred = new Set(sources.filter((source) => source.format === "json").map((source) => source.argument));
+  const validatedFields = Object.fromEntries(Object.entries(fields).map(([key, field]) => [key, deferred.has(key) ? { ...field, required: false } : field]));
+  if (operation === "batch") {
+    if (deferred.has("operations")) validatedFields.version = { type: "literal 1", required: false };
+    else {
+      const checked = validateDocxBatch({ version: options.version, operations: options.operations }, budget, { author: options.author, timestamp: options.timestamp });
+      options.operations = checked.operations;
+    }
+  }
+  assertDocxFields(validatedFields, options, (type) => {
+    if (type === "ReadonlyArray<OperationV1>") return true;
+    return void 0;
+  });
+  budget = lowerLimits(options.limit, budget);
+  for (const field of ["content", "data", "valueJson"]) if (options[field] !== void 0) structuredBudget(options[field], budget);
+  if (operation === "batch" && options.operations !== void 0) structuredBudget({ version: options.version, operations: options.operations }, budget);
+  if ((operation === "tables.add" || operation === "tables.split") && typeof options.rows === "number" && typeof options.cols === "number") budget.table(options.rows, options.cols);
+  validateSelections(operation, options);
+  validateDocxSelection(operation, options);
+  validateEffects(operation, options, schema);
+  validateDocxOptionRules(operation, options);
+  const consumers = inputs.filter((input2) => input2 === "-").length + sources.filter((source) => source.path === "-").length;
+  if (consumers > 1) usage("Only one stdin consumer is permitted.");
+  if (options.output !== void 0 && options.inPlace === true) usage("Output and in-place conflict.");
+  if (options.inPlace === true && (inputs.includes("-") || operation === "create" || operation === "pack")) usage("In-place requires a document path.");
+  if (options.force === true && (options.output === void 0 && options.outputDir === void 0 || options.output === "-")) usage("Force requires a file destination.");
+  if (options.output === "-" && options.json === true && options.dryRun !== true) usage("Binary stdout conflicts with JSON.");
+  if (options.raw === true && (options.json === true || options.pretty === true)) usage("Raw XML conflicts with JSON or pretty output.");
+  for (const key of ["output", "outputDir"]) if (options[key] !== void 0) path(options[key]);
+  const mutable = ["edit", "selectedEdit", "create"].includes(schema.profile) || operation === "batch" && docxBatchMutates(options);
+  if (operation === "batch" && !deferred.has("operations") && !mutable && ["output", "inPlace", "force"].some((key) => options[key] !== void 0)) usage("Read-only batch rejects publication options.");
+  if (mutable && options.dryRun !== true && options.output === void 0 && options.inPlace !== true) usage("Mutation requires a destination.");
+  if (schema.profile === "extract" && options.outputDir === void 0) usage("Extraction requires an output directory.");
+  if (operation === "extract" && (selectors.some((key) => options[key] !== void 0) || options.scope !== void 0 || options.select !== void 0)) usage("Package extraction rejects selection.");
+  if (operation === "pack" && (options.author !== void 0 || options.timestamp !== void 0)) usage("Pack rejects author and timestamp.");
+  const invocation = Object.freeze({ operation, inputs: Object.freeze(inputs), options: owned(options, budget), ...sources.length ? { sources: Object.freeze(sources.map((source) => Object.freeze({ ...source }))) } : {} });
+  docxInvocationBudgets.set(invocation, budget);
+  return invocation;
+}
+function validateDocxInvocation(value, budget = new DocumentBudget()) {
+  return validateInvocation(value, budget, false);
+}
+function docxBatchMutates(value) {
+  if (!value || typeof value !== "object" || !Object.hasOwn(value, "operations")) return false;
+  const handles = /* @__PURE__ */ new Map([["document", "DocumentModel"]]);
+  return value.operations.some((item) => {
+    const schema = schemaFor(item.operation);
+    if (schema.mutates) return true;
+    if (partProviderReceivers.has(schema.receiver ?? "") && item.receiver) {
+      const type = item.receiver.resultHandle === void 0 ? item.receiver.type : handleType(item.receiver, handles);
+      if (splitDocxType(type).some((type2) => type2 === "_Header" || type2 === "_Footer")) return true;
+    }
+    if (item.resultHandle) handles.set(item.resultHandle, schema.resultHandle.type);
+    return false;
+  });
+}
+function handleType(receiver, handles) {
+  if (!validateDocxValue("Receiver", receiver) || Object.keys(receiver).some((key) => !["resultHandle", "index", "key"].includes(key))) usage("Invalid batch handle reference.");
+  let type = handles.get(receiver.resultHandle);
+  if (!type) usage("Unknown or forward result handle.");
+  if (type.startsWith("Promise<") && type.endsWith(">")) type = type.slice(8, -1);
+  if (receiver.index === void 0 && receiver.key === void 0) return type;
+  if (receiver.index !== void 0 && receiver.key !== void 0) usage("Choose index or key lookup.");
+  if (type.startsWith("readonly [") && type.endsWith("]")) {
+    const items = splitDocxType(type.slice(10, -1), ",");
+    if (receiver.key !== void 0 || typeof receiver.index !== "number") usage("Tuple handles require an index.");
+    if (receiver.index >= items.length) throw new BoundsError("Tuple handle index is out of bounds.");
+    return items[receiver.index];
+  }
+  if ((type.startsWith("ReadonlyArray<") || type.startsWith("IterableIterator<")) && type.endsWith(">")) {
+    if (receiver.key !== void 0) usage("Sequences require an index.");
+    return type.slice(type.indexOf("<") + 1, -1);
+  }
+  if (type.startsWith("ReadonlyMap<string, ") && type.endsWith(">")) {
+    if (receiver.index !== void 0 || typeof receiver.key !== "string") usage("Maps require a string key.");
+    return type.slice("ReadonlyMap<string, ".length, -1);
+  }
+  const lookups = Object.entries(docxOperationSchemas).filter(([id, schema]) => schema.receiver === type && id.includes(".__getitem__.") && !id.endsWith(".slice"));
+  const lookup = lookups.find(([, schema]) => receiver.index !== void 0 ? Object.hasOwn(schema.fields, "index") : Object.hasOwn(schema.fields, "key") || Object.hasOwn(schema.fields, "rId"));
+  if (!lookup) usage("The handle does not expose that collection lookup.");
+  return lookup[1].valueType;
+}
+function checkArgumentHandles(value, handles) {
+  if (!value || typeof value !== "object" || value instanceof Uint8Array || value instanceof Date) return;
+  if (!Array.isArray(value) && Object.hasOwn(value, "resultHandle")) handleType(value, handles);
+  else for (const item of Object.values(value)) checkArgumentHandles(item, handles);
+}
+function validateDocxBatch(value, budget = new DocumentBudget(), defaults = {}) {
+  const context = record(defaults, ["author", "timestamp"]);
+  assertDocxFields({ author: docxCommonOptions.author, timestamp: docxCommonOptions.timestamp }, context);
+  const batch = record(value, ["version", "operations"]);
+  if (batch.version !== 1 || !Array.isArray(batch.operations) || Object.getPrototypeOf(batch.operations) !== Array.prototype || !validateDocxValue("ReadonlyArray<unknown>", batch.operations)) usage("Expected a version 1 batch.");
+  structuredBudget(batch, budget);
+  budget.check("batchOperations", batch.operations.length);
+  const handles = /* @__PURE__ */ new Map([["document", "DocumentModel"]]);
+  const ids = /* @__PURE__ */ new Set();
+  const operations = batch.operations.map((value2, index) => {
+    try {
+      const item = record(value2, ["id", "operation", "arguments", "receiver", "resultHandle"]);
+      const id = item.id === void 0 ? `step${index + 1}` : item.id;
+      if (typeof id !== "string" || !id || id.length > 64 || !"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz".includes(id[0]) || [...id].some((c) => !"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_-".includes(c)) || ids.has(id)) usage("Invalid or duplicate batch operation ID.");
+      ids.add(id);
+      if (typeof item.operation !== "string") usage("Batch operation is required.");
+      const schema = schemaFor(item.operation);
+      if (schema.transport === "direct") usage("Operation is not available in batch.");
+      const fields = { ...schema.batchFields ?? schema.sdkFields };
+      for (const name of schema.commonOptions) if (!publication.includes(name)) fields[name] = docxCommonOptions[name];
+      const arguments_ = record(item.arguments);
+      if (item.operation === "text.replace" && arguments_.trackChanges === true) {
+        for (const key of ["author", "timestamp"]) if (context[key] !== void 0) {
+          if (arguments_[key] !== void 0 && arguments_[key] !== context[key]) usage("Conflicting batch context metadata.");
+          arguments_[key] = context[key];
+        }
+      }
+      if (item.operation === "properties.set") Object.assign(arguments_, normalizeDocxPropertyOptions(arguments_, false));
+      assertDocxFields(fields, arguments_, (type, value3) => {
+        if (schema.transport !== "typed-batch" || type === "unknown" || !value3 || typeof value3 !== "object" || !Object.hasOwn(value3, "resultHandle")) return void 0;
+        const source = handleType(value3, handles);
+        if (validateDocxValue(type, value3)) return true;
+        const targets = splitDocxType(type);
+        return splitDocxType(source).every((candidate) => targets.includes(candidate));
+      });
+      for (const [name, value3] of Object.entries(arguments_)) if (fields[name]?.type !== "unknown") checkArgumentHandles(value3, handles);
+      validateSelections(item.operation, arguments_);
+      if (schema.transport !== "typed-batch") {
+        validateDocxSelection(item.operation, arguments_);
+        validateEffects(item.operation, arguments_, schema);
+      }
+      validateDocxOptionRules(item.operation, arguments_);
+      let receiver;
+      if (schema.receiver && item.receiver === void 0) usage("This operation requires a typed receiver.");
+      if (!schema.receiver && item.receiver !== void 0) usage("This operation does not accept a receiver.");
+      if (item.receiver !== void 0) {
+        receiver = record(item.receiver, ["id", "type", "owner", "revision", "resultHandle", "index", "key"]);
+        if (!validateDocxValue("Receiver", receiver)) usage("Invalid model receiver.");
+        if (receiver.resultHandle !== void 0) {
+          if (typeof receiver.resultHandle !== "string" || !handles.has(receiver.resultHandle) || receiver.index !== void 0 && receiver.key !== void 0 || ["id", "type", "owner", "revision"].some((key) => receiver[key] !== void 0)) usage("Invalid batch handle reference.");
+          if (receiver.index !== void 0 && (typeof receiver.index !== "number" || !Number.isSafeInteger(receiver.index) || receiver.index < 0)) usage("Invalid handle index.");
+          if (receiver.key !== void 0 && typeof receiver.key !== "string") usage("Invalid handle key.");
+          const type = handleType(receiver, handles);
+          const styleReceivers = { BaseStyle: ["CharacterStyle", "ParagraphStyle", "_TableStyle", "_NumberingStyle"], CharacterStyle: ["BaseStyle", "ParagraphStyle", "_TableStyle"], ParagraphStyle: ["BaseStyle", "CharacterStyle", "_TableStyle"], _TableStyle: ["BaseStyle", "CharacterStyle", "ParagraphStyle"], _NumberingStyle: ["BaseStyle"] };
+          const packageReceivers = { _Text: ["XmlElementView"], XmlPartView: ["XmlPart", "Part", "PartView", "StylesPart", "StoryPart", "HeaderPart", "FooterPart", "CommentsPart", "SettingsPart", "NumberingPart", "DocumentPart", "CorePropertiesPart"], PartView: ["Part", "XmlPart", "XmlPartView", "StylesPart", "StoryPart", "HeaderPart", "FooterPart", "CommentsPart", "SettingsPart", "NumberingPart", "DocumentPart", "CorePropertiesPart", "ImagePart"], PackageView: ["Package", "OpcPackage"], RelationshipView: ["_Relationship"], DocumentPart: ["Part", "XmlPart", "PartView", "XmlPartView", "StoryPart"], StoryPart: ["Part", "XmlPart", "PartView", "XmlPartView"], HeaderPart: ["Part", "XmlPart", "PartView", "XmlPartView", "StoryPart"], FooterPart: ["Part", "XmlPart", "PartView", "XmlPartView", "StoryPart"], CommentsPart: ["Part", "XmlPart", "PartView", "XmlPartView", "StoryPart"], SettingsPart: ["Part", "XmlPart", "PartView", "XmlPartView"], NumberingPart: ["Part", "XmlPart", "PartView", "XmlPartView"], StylesPart: ["Part", "XmlPart", "PartView", "XmlPartView"], CorePropertiesPart: ["Part", "XmlPart", "PartView", "XmlPartView"], ImagePart: ["Part", "PartView"] };
+          if (!type.split(" | ").some((candidate) => (docxEnumCanonicalNames[candidate] ?? candidate) === (docxEnumCanonicalNames[schema.receiver] ?? schema.receiver) || partProviderReceivers.get(schema.receiver)?.has(candidate) || styleReceivers[candidate]?.includes(schema.receiver) || packageReceivers[candidate]?.includes(schema.receiver))) usage("Handle type does not match receiver.");
+        } else if (typeof receiver.id !== "string" || !receiver.id || typeof receiver.type !== "string" || !receiver.type || typeof receiver.owner !== "string" || !receiver.owner || typeof receiver.revision !== "number" || !Number.isSafeInteger(receiver.revision) || receiver.revision < 0) usage("Invalid model receiver.");
+        else if (receiver.type !== schema.receiver) usage("Receiver type does not match operation.");
+      }
+      if (item.resultHandle !== void 0) {
+        if (!schema.resultHandle?.allowed) usage("This operation cannot bind a result handle.");
+        const name = item.resultHandle;
+        if (typeof name !== "string" || !validateDocxValue("BatchHandleName", name) || handles.has(name)) usage("Invalid or duplicate result handle.");
+        handles.set(name, schema.resultHandle.type);
+      }
+      return Object.freeze({ ...typeof item.id === "string" ? { id: item.id } : {}, operation: item.operation, arguments: Object.freeze(arguments_), ...receiver ? { receiver: Object.freeze(receiver) } : {}, ...typeof item.resultHandle === "string" ? { resultHandle: item.resultHandle } : {} });
+    } catch (error) {
+      if (error instanceof Error) Object.assign(error, { operationIndex: index });
+      throw error;
+    }
+  });
+  return owned({ version: 1, operations }, budget);
+}
+
+export {
+  SourceError,
+  selectors,
+  publication,
+  docxInvocationBudgets,
+  usage,
+  schemaFor,
+  record,
+  path,
+  owned,
+  structuredBudget,
+  lowerLimits,
+  optionFields,
+  validateSelections,
+  validateEffects,
+  validateInvocation,
+  validateDocxInvocation,
+  docxBatchMutates,
+  handleType,
+  checkArgumentHandles,
+  validateDocxBatch
+};