@poe-platform/safe-bash 0.1.806 → 0.1.807

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

@@ -0,0 +1,207 @@
+import {
+  assertSettingsXmlReplacement
+} from "./chunk-OIPATOZW.js";
+import {
+  assertEquationXmlReplacement
+} from "./chunk-L4XEXXVQ.js";
+import {
+  assertDiagramGraphReplacement,
+  assertDiagramXmlReplacement
+} from "./chunk-OGWJD5QP.js";
+import {
+  readDocumentBindingOwnership
+} from "./chunk-YDRWQZNB.js";
+import {
+  UnsupportedEmbeddedFontMutationError,
+  embeddedFontState
+} from "./chunk-WOZCIRJ5.js";
+import {
+  assertDocumentEditable,
+  publishDocumentArchive
+} from "./chunk-HPKUFWHW.js";
+import {
+  DocumentPackage,
+  readDocumentArchive
+} from "./chunk-GLPIFP7N.js";
+import {
+  UnsupportedEditError,
+  displayXml,
+  opaqueXmlContent
+} from "./chunk-YPVBU7QF.js";
+import {
+  documentDialects
+} from "./chunk-MG7AJD5E.js";
+import {
+  compatibilityProfileForPart
+} from "./chunk-GZ2N24A2.js";
+import {
+  SelectionError,
+  closedRecord,
+  encodeGeneratedLocation
+} from "./chunk-LQOKYG3O.js";
+import {
+  asciiKey,
+  normalizePartName
+} from "./chunk-WAKYUXVQ.js";
+import {
+  isXmlContentType,
+  parseDocumentXml,
+  parseMediaType
+} from "./chunk-MWAAMNAM.js";
+import {
+  InputTypeError,
+  archiveSettings
+} from "./chunk-IQFRPIXH.js";
+
+// packages/safe-bash-docx-engine/src/xml-parts.ts
+function selector(part) {
+  if (typeof part !== "string" || !part.startsWith("/") || part.includes("*") || part.includes("?"))
+    throw new InputTypeError("Select one absolute XML part name.");
+  if (asciiKey(part) === "/[content_types].xml") return "/[Content_Types].xml";
+  return normalizePartName(part);
+}
+function selected(archive, name) {
+  const matches = archive.members.filter((member2) => !member2.directory && asciiKey(
+    asciiKey(member2.name) === "[content_types].xml" ? "/[Content_Types].xml" : normalizePartName("/" + member2.name)
+  ) === asciiKey(name));
+  if (!matches.length) throw new SelectionError("missing-selection");
+  if (matches.length !== 1) throw new SelectionError("ambiguous-selection");
+  const member = matches[0];
+  const type = asciiKey(name) === "/[content_types].xml" ? "application/xml" : archive.package.getPart(name).content_type.toLowerCase();
+  if (!isXmlContentType(type))
+    throw new UnsupportedEditError("The selected part is not XML.");
+  return member;
+}
+async function digest(bytes, budget) {
+  budget.charge("work", bytes.length);
+  budget.charge("retainedBytes", bytes.length);
+  const value = await crypto.subtle.digest("SHA-256", new Uint8Array(bytes));
+  budget.check("work", 0);
+  return [...new Uint8Array(value)].map((n) => n.toString(16).padStart(2, "0")).join("");
+}
+async function getDocumentXml(input, context, options) {
+  closedRecord(options, ["part", "raw", "pretty"]);
+  options = { ...options };
+  const name = selector(options.part);
+  for (const value of [options.raw, options.pretty]) if (value !== void 0 && typeof value !== "boolean") throw new InputTypeError("XML display flags require booleans.");
+  if (options.raw && options.pretty) throw new InputTypeError("Raw and pretty output conflict.");
+  const settings = archiveSettings(context);
+  const { budget } = settings;
+  const archive = await readDocumentArchive(input, { ...context, budget });
+  const member = selected(archive, name);
+  const xml = parseDocumentXml(member.bytes, { maxBytes: Math.min(settings.limits.maxEntryBytes, budget.limits.xmlPartBytes) }, budget);
+  if (options.raw) {
+    budget.check("serializedOutput", xml.bytes.length);
+    return xml.bytes;
+  }
+  let content;
+  if (options.pretty) content = displayXml(xml.root, budget, true);
+  else {
+    budget.check("serializedOutput", 4 * Math.ceil(xml.bytes.length / 3));
+    budget.charge("retainedBytes", xml.bytes.length * 4);
+    const chunks = [];
+    for (let offset = 0; offset < xml.bytes.length; offset += 8192) chunks.push(String.fromCharCode(...xml.bytes.subarray(offset, offset + 8192)));
+    content = btoa(chunks.join(""));
+  }
+  const partname = asciiKey(member.name) === "[content_types].xml" ? "/[Content_Types].xml" : archive.package.getPart(name).partname;
+  const data = { part: partname, encoding: options.pretty ? "utf-8" : "base64", content, pretty: options.pretty ?? false, bytes: xml.bytes.length, sha256: await digest(xml.bytes, budget) };
+  budget.check("serializedOutput", new TextEncoder().encode(JSON.stringify(data)).length);
+  return data;
+}
+async function replaceDocumentXmlPart(input, replacement, options, context) {
+  closedRecord(options, ["part", "allowEmpty", "input", "output", "inPlace", "force", "dryRun", "json"]);
+  const name = selector(options.part);
+  const { part: ignoredPart, allowEmpty, ...publication } = options;
+  if (allowEmpty !== void 0 && typeof allowEmpty !== "boolean") throw new InputTypeError("allowEmpty requires a boolean.");
+  if (publication.input) publication.input = { path: publication.input.path, stat: { ...publication.input.stat } };
+  const settings = archiveSettings(context);
+  const { budget } = settings;
+  const beforeNodes = budget.usage.xmlNodes;
+  const xml = parseDocumentXml(replacement, { maxBytes: Math.min(settings.limits.maxEntryBytes, budget.limits.xmlPartBytes) }, budget);
+  const replacementNodes = budget.usage.xmlNodes - beforeNodes;
+  if (!(input instanceof Uint8Array)) throw new InputTypeError("Expected archive bytes.");
+  budget.charge("retainedBytes", input.length);
+  const owned = new Uint8Array(input);
+  const archive = await readDocumentArchive(owned, { ...context, budget });
+  let member;
+  try {
+    member = selected(archive, name);
+  } catch (error) {
+    if (!allowEmpty || !(error instanceof SelectionError) || error.code !== "missing-selection") throw error;
+  }
+  const partname = member === void 0 ? name : asciiKey(member.name) === "[content_types].xml" ? "/[Content_Types].xml" : archive.package.getPart(name).partname;
+  assertDocumentEditable(archive, settings);
+  const changed = member !== void 0 && (member.bytes.length !== xml.bytes.length || member.bytes.some((byte, index) => byte !== xml.bytes[index]));
+  const ownership = readDocumentBindingOwnership(archive.package, budget);
+  const bindingIds = new Set(ownership.declarations.flatMap((declaration) => declaration.storeItemId === null ? [] : [declaration.storeItemId.toLowerCase()]));
+  const bindingParts = new Set(ownership.declarations.map((declaration) => declaration.part));
+  for (const store of ownership.stores) if (store.storeItemId !== null && bindingIds.has(store.storeItemId.toLowerCase())) {
+    bindingParts.add(store.item);
+    bindingParts.add(store.properties);
+  }
+  if (changed && bindingParts.has(partname)) throw new UnsupportedEditError("Raw replacement of binding declarations or referenced stores is unsupported; use controls bind.");
+  const unboundCustomItem = member !== void 0 && ["/", ...archive.package.parts.filter((part) => part.content_type.toLowerCase() !== "application/vnd.openxmlformats-package.relationships+xml").map((part) => part.partname)].some((owner) => archive.package.relationships(owner).some((edge) => !edge.is_external && ["http://schemas.openxmlformats.org/officeDocument/2006/relationships/customXml", "http://purl.oclc.org/ooxml/officeDocument/relationships/customXml"].includes(edge.reltype) && edge.target_part.partname === partname));
+  const candidate = { ...archive, members: archive.members.map((entry) => entry === member ? { ...entry, bytes: xml.bytes } : entry) };
+  const graph = new DocumentPackage(candidate, settings.limits, budget);
+  if (member) {
+    const original = parseDocumentXml(member.bytes, {}, budget);
+    if (changed) await assertDiagramXmlReplacement(archive, original.root, xml.root, owned, partname, budget);
+    if (changed) await assertEquationXmlReplacement(archive, original.root, xml.root, owned, partname, budget, xml.bytes);
+    const originalPart = archive.package.parts.find((part) => part.partname === partname);
+    if (changed && originalPart) assertSettingsXmlReplacement(originalPart.content_type, member.bytes, xml.bytes, budget);
+    if (changed) await assertDiagramGraphReplacement(archive, graph, owned, name, budget);
+    if (original.root.namespace !== xml.root.namespace || original.root.localName !== xml.root.localName)
+      throw new UnsupportedEditError("Replacement must retain the part root expanded name.");
+    if (changed) budget.charge("insertedNodes", replacementNodes);
+    if (changed && !unboundCustomItem && opaqueXmlContent(original.root, budget, compatibilityProfileForPart(partname)) !== opaqueXmlContent(xml.root, budget, compatibilityProfileForPart(partname)))
+      throw new UnsupportedEditError("Replacement changes opaque XML content or its namespace context.");
+  }
+  for (const part of archive.package.parts) {
+    if (parseMediaType(graph.getPart(part.partname).content_type, "identity") !== parseMediaType(part.content_type, "identity"))
+      throw new UnsupportedEditError("XML replacement cannot change existing part content types or document kind.");
+  }
+  if (changed && embeddedFontState(archive.package, budget) !== embeddedFontState(graph, budget))
+    throw new UnsupportedEmbeddedFontMutationError();
+  const originalMain = archive.package.relationships("/").find((edge) => edge.reltype === `${documentDialects[archive.dialect].r}/officeDocument`);
+  const mainEdges = graph.relationships("/").filter((edge) => edge.reltype === originalMain.reltype);
+  if (mainEdges.length !== 1 || mainEdges[0].is_external || mainEdges[0].target_part.partname !== originalMain.target_part.partname)
+    throw new UnsupportedEditError("XML replacement cannot rebind the main document part.");
+  const sourceSha256 = await digest(owned, budget);
+  const location = (generation) => {
+    const value = { version: 1, sourceSha256, generation, part: partname, story: partname, path: [], range: null };
+    return { kind: "part", token: encodeGeneratedLocation(value), value, positions: {} };
+  };
+  const changes = changed ? [{ kind: "replace", before: location(0), after: location(1) }] : [];
+  const path = publication.inPlace ? publication.input?.path : publication.output;
+  if (typeof path === "string") budget.check("serializedOutput", path.length);
+  const prospective = {
+    changed,
+    changes,
+    dryRun: publication.dryRun ?? false,
+    output: publication.dryRun ? null : { path: path ?? null, bytes: Math.min(settings.limits.maxArchiveBytes, Number.MAX_SAFE_INTEGER), sha256: "0".repeat(64) }
+  };
+  const summary = JSON.stringify({
+    version: 1,
+    operation: "xml.set",
+    ok: true,
+    data: prospective,
+    warnings: [],
+    errors: [],
+    affected: changed ? 1 : 0,
+    locations: changes.map((change) => change.after)
+  }) + "\n";
+  budget.check("serializedOutput", new TextEncoder().encode(summary).length);
+  budget.charge("retainedBytes", summary.length * 2);
+  const result = await publishDocumentArchive(candidate, publication, { ...context, budget });
+  return {
+    changed,
+    changes,
+    dryRun: publication.dryRun ?? false,
+    output: result.published.length ? { path: result.published[0].path, bytes: result.published[0].bytes, sha256: result.archiveSha256 } : null
+  };
+}
+
+export {
+  getDocumentXml,
+  replaceDocumentXmlPart
+};

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

@@ -0,0 +1,185 @@
+import {
+  validateArchiveNamespace
+} from "./chunk-BDYKJTBQ.js";
+import {
+  SourceError,
+  validateDocxInvocation
+} from "./chunk-DE66JRWJ.js";
+import {
+  publishDocumentArchive
+} from "./chunk-HPKUFWHW.js";
+import {
+  PublicationError,
+  asPermissionError
+} from "./chunk-JGGRMERW.js";
+import {
+  admitDocumentArchive
+} from "./chunk-GLPIFP7N.js";
+import {
+  admitPackageInventory,
+  inventoryPath
+} from "./chunk-2EUH5B6A.js";
+import {
+  InvalidPackageError
+} from "./chunk-MWAAMNAM.js";
+import {
+  CancellationError,
+  InvalidContainerError,
+  ResourceLimitError,
+  archiveSettings
+} from "./chunk-IQFRPIXH.js";
+
+// packages/safe-bash-docx-engine/src/packing-vfs-admission.ts
+async function admitPackingFiles(files, context) {
+  const { filesystem: fs, signal, budget } = context;
+  const directories = /* @__PURE__ */ new Set();
+  for (const { path, bytes } of files) {
+    try {
+      if (signal.aborted) throw new CancellationError("Archive packing cancelled.", { cause: signal.reason });
+      await budget.checkpoint(1);
+      let parent = "";
+      for (const segment of path.split("/").slice(1, -1)) {
+        parent += "/" + segment;
+        if (directories.has(parent)) continue;
+        const stat2 = await fs.lstat(parent, { signal });
+        if (stat2.type !== "directory" || await fs.realpath(parent, { signal }) !== parent) throw new InvalidContainerError("Inventory VFS ancestors must be canonical directories.");
+        directories.add(parent);
+      }
+      const stat = await fs.lstat(path, { signal });
+      if (stat.type !== "file" || await fs.realpath(path, { signal }) !== path) throw new InvalidContainerError("Inventory payloads must be canonical regular files.");
+      signal.throwIfAborted();
+      if (stat.size !== bytes) throw new InvalidContainerError("Inventory payload byte length mismatch.");
+    } catch (error) {
+      if (signal.aborted) throw new CancellationError("Archive packing cancelled.", { cause: signal.reason });
+      throw error;
+    }
+  }
+}
+
+// packages/safe-bash-docx-engine/src/pack.ts
+import { dirname } from "@poe-platform/safe-fs/core";
+async function packDocumentArchive(input, options, context) {
+  const host = archiveSettings(context);
+  if (host.signal.aborted) throw new CancellationError("Archive packing cancelled.", { cause: host.signal.reason });
+  const admitted = validateDocxInvocation({ operation: "pack", inputs: ["-"], options }, host.budget).options;
+  const settings = archiveSettings({ ...context, budget: host.budget.lower(Object.fromEntries((admitted.limit ?? []).map((limit) => [limit.name, limit.value]))) });
+  const { budget, signal, limits } = settings;
+  const directory = context.inventoryDirectory;
+  if (directory !== void 0 && directory !== "/") inventoryPath(directory, true);
+  const inventory = admitPackageInventory(input, budget, directory === void 0);
+  if (inventory.entries.length + (inventory.directories?.length ?? 0) > limits.maxMembers) throw new ResourceLimitError("Packing member limit exceeded.");
+  const files = inventory.entries.map((entry) => ({ entry, path: directory === void 0 ? entry.path : (directory === "/" ? "" : directory) + "/" + entry.path }));
+  const namespace = [...inventory.entries.map((e) => ({ name: e.part === "[Content_Types].xml" ? e.part : e.part.slice(1), directory: false })), ...(inventory.directories ?? []).map((name) => ({ name: name + "/", directory: true }))];
+  for (const member of namespace) {
+    const name = member.directory ? member.name.slice(0, -1) : member.name;
+    if (new TextEncoder().encode(member.name).length > limits.maxPathBytes || name.split("/").length > limits.maxDepth) throw new ResourceLimitError("Packing path limit exceeded.");
+  }
+  for (const { path } of files) {
+    if (new TextEncoder().encode(path).length > limits.maxPathBytes || path.split("/").length - 1 > limits.maxDepth) throw new ResourceLimitError("Packing VFS path limit exceeded.");
+  }
+  validateArchiveNamespace(namespace, budget);
+  validateArchiveNamespace(files.map((f) => ({ name: f.path.slice(1), directory: false })), budget);
+  const common = files.map((f) => dirname(f.path).split("/"));
+  let shared = common[0].length;
+  for (const parts of common.slice(1)) {
+    let i = 0;
+    while (i < shared && parts[i] === common[0][i]) i++;
+    shared = i;
+  }
+  const inputTree = directory ?? (common[0].slice(0, shared).join("/") || "/");
+  const output = admitted.output;
+  if (output !== void 0 && output !== "-") {
+    inventoryPath(output, true);
+    const key = output.normalize("NFC").toUpperCase().toLowerCase(), treeKey = inputTree.normalize("NFC").toUpperCase().toLowerCase();
+    if (inputTree === "/" || key === treeKey || key.startsWith(treeKey + "/")) throw new PublicationError("conflict", "Packed output must be outside the input tree.");
+  }
+  const fs = context.filesystem;
+  const directories = /* @__PURE__ */ new Set();
+  const checkParents = async (path) => {
+    const parents = path.split("/").slice(1, -1);
+    let parent = "";
+    for (const segment of parents) {
+      parent += "/" + segment;
+      if (directories.has(parent)) continue;
+      const stat = await fs.lstat(parent, { signal });
+      if (stat.type !== "directory" || await fs.realpath(parent, { signal }) !== parent) throw new InvalidContainerError("Inventory VFS ancestors must be canonical directories.");
+      directories.add(parent);
+    }
+  };
+  try {
+    if (output !== void 0 && output !== "-") await checkParents(output);
+    await admitPackingFiles(files.map(({ entry, path }) => ({ path, bytes: entry.bytes })), { filesystem: fs, signal, budget });
+  } catch (error) {
+    if (signal.aborted) throw new CancellationError("Archive packing cancelled.", { cause: signal.reason });
+    if (error instanceof InvalidContainerError || error instanceof ResourceLimitError || error instanceof CancellationError) throw error;
+    throw asPermissionError(error) ?? new SourceError(error);
+  }
+  const members = [];
+  let total = 0;
+  for (const { entry, path } of files) {
+    await budget.checkpoint(1);
+    try {
+      await checkParents(path);
+      const stat = await fs.lstat(path, { signal });
+      if (stat.type !== "file" || await fs.realpath(path, { signal }) !== path) throw new InvalidContainerError("Inventory payloads must be canonical regular files.");
+      if (stat.size !== entry.bytes) throw new InvalidContainerError("Inventory payload byte length mismatch.");
+      if (entry.bytes > limits.maxEntryBytes || entry.bytes > limits.maxTotalBytes - total) throw new ResourceLimitError("Packing payload limit exceeded.");
+      total += entry.bytes;
+      budget.charge("retainedBytes", entry.bytes * 2 + 128);
+      const bytes = new Uint8Array(entry.bytes);
+      let offset = 0;
+      const source = fs.readStream ? fs.readStream(path, { signal }) : { async *[Symbol.asyncIterator]() {
+        yield await fs.readFile(path, { signal });
+      } };
+      for await (const chunk of source) {
+        if (!(chunk instanceof Uint8Array) || chunk.length > bytes.length - offset) throw new InvalidContainerError("Inventory payload byte length mismatch.");
+        await budget.checkpoint(chunk.length + 1);
+        bytes.set(chunk, offset);
+        offset += chunk.length;
+      }
+      if (offset !== bytes.length) throw new InvalidContainerError("Inventory payload byte length mismatch.");
+      const digest = [...new Uint8Array(await crypto.subtle.digest("SHA-256", bytes))].map((b) => b.toString(16).padStart(2, "0")).join("");
+      if (digest !== entry.sha256) throw new InvalidContainerError("Inventory payload hash mismatch.");
+      members.push({ name: entry.part === "[Content_Types].xml" ? entry.part : entry.part.slice(1), bytes, directory: false, modified: /* @__PURE__ */ new Date("1980-01-01T00:00:00Z") });
+    } catch (error) {
+      if (signal.aborted) throw new CancellationError("Archive packing cancelled.", { cause: signal.reason });
+      if (error instanceof InvalidContainerError || error instanceof ResourceLimitError || error instanceof CancellationError) throw error;
+      throw asPermissionError(error) ?? new SourceError(error);
+    }
+  }
+  for (const name of inventory.directories ?? []) members.push({ name: name + "/", bytes: new Uint8Array(), directory: true, modified: /* @__PURE__ */ new Date("1980-01-01T00:00:00Z") });
+  const archive = await admitDocumentArchive({ members, comment: new Uint8Array() }, settings);
+  if (archive.kind !== inventory.kind || archive.dialect !== inventory.dialect || admitted.kind !== void 0 && admitted.kind !== archive.kind) throw new InvalidPackageError("Inventory kind or dialect conflicts with its package.");
+  for (const { entry } of files) {
+    const type = entry.part === "[Content_Types].xml" ? "application/xml" : archive.package.getPart(entry.part).content_type;
+    if (type !== entry.contentType) throw new InvalidPackageError("Inventory content type conflicts with its package.");
+  }
+  if (output !== void 0 && output !== "-" && admitted.force === true) {
+    try {
+      let existing = false;
+      try {
+        await fs.lstat(output, { signal });
+        existing = true;
+      } catch (error) {
+        if (!error || typeof error !== "object" || !("code" in error) || error.code !== "ENOENT") throw asPermissionError(error) ?? new SourceError(error);
+      }
+      if (existing) for (const { path } of files) {
+        const comparison = await fs.compareEntry?.(output, fs, path, { signal }) ?? "unknown";
+        if (comparison === "same") throw new PublicationError("conflict", "Packed output aliases an input payload.");
+        if (comparison !== "distinct") throw new PublicationError("unsupported-publication", "Packed output alias identity is unknown.");
+      }
+    } catch (error) {
+      if (signal.aborted) throw new CancellationError("Archive packing cancelled.", { cause: signal.reason });
+      throw asPermissionError(error) ?? error;
+    }
+  }
+  const dryRun = admitted.dryRun === true;
+  const prospective = { version: 1, operation: "pack", ok: true, data: { changed: true, changes: [], dryRun, output: dryRun ? null : { path: output, bytes: Math.min(limits.maxArchiveBytes, Number.MAX_SAFE_INTEGER), sha256: "0".repeat(64) } }, warnings: [], errors: [], affected: 1, locations: [] };
+  if (output !== "-" || dryRun) budget.check("serializedOutput", new TextEncoder().encode(JSON.stringify(prospective) + "\n").length);
+  const result = await publishDocumentArchive(archive, { creation: true, ...output === void 0 ? {} : { output }, force: admitted.force === true, dryRun, json: admitted.json === true }, { ...settings, filesystem: fs, ...context.stdout ? { stdout: context.stdout } : {}, encoding: { order: "name", compression: "store" } });
+  return { changed: true, changes: [], dryRun, output: result.published.length ? { path: result.published[0].path, bytes: result.published[0].bytes, sha256: result.archiveSha256 } : null };
+}
+
+export {
+  packDocumentArchive
+};

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

@@ -0,0 +1,213 @@
+import {
+  readDocumentBindingOwnership
+} from "./chunk-YDRWQZNB.js";
+import {
+  inspectControlSnapshot,
+  inspectDocumentControls,
+  prepareControlValue
+} from "./chunk-2B6XWO6A.js";
+import {
+  assertOutsideFields,
+  parseFields
+} from "./chunk-6EHVFKM7.js";
+import {
+  openDocumentLocations
+} from "./chunk-LHDB4QO5.js";
+import {
+  DocumentArchiveEditor
+} from "./chunk-MAHX3IW3.js";
+import {
+  customXmlDataNamespaces,
+  customXmlRelationshipNamespaces
+} from "./chunk-2A6TBB4F.js";
+import {
+  validateDocxInvocation
+} from "./chunk-DE66JRWJ.js";
+import {
+  pathContains
+} from "./chunk-IR6ZKAUH.js";
+import {
+  assertDocumentEditable,
+  publishDocumentArchive
+} from "./chunk-HPKUFWHW.js";
+import {
+  DocumentPackage
+} from "./chunk-GLPIFP7N.js";
+import {
+  UnsupportedEditError,
+  assertOutsideRevisionRanges,
+  containsRevision
+} from "./chunk-YPVBU7QF.js";
+import {
+  SelectionError,
+  closedRecord,
+  encodeGeneratedLocation
+} from "./chunk-LQOKYG3O.js";
+import {
+  parseDocumentXml
+} from "./chunk-MWAAMNAM.js";
+import {
+  CancellationError,
+  ResourceLimitError,
+  archiveSettings
+} from "./chunk-IQFRPIXH.js";
+
+// packages/safe-bash-docx-engine/src/control-bindings.ts
+var schema = "http://www.w3.org/2001/XMLSchema";
+var instance = "http://www.w3.org/2001/XMLSchema-instance";
+function reject() {
+  throw new UnsupportedEditError("Binding requires a singleton admitted store, selector and complete unlocked recipient set.");
+}
+function chain(root, path) {
+  const result = [root];
+  for (const index of path) result.push(result.at(-1).children[index]);
+  return result;
+}
+function expanded(name, namespaces, budget) {
+  const pieces = name.split(":");
+  if (pieces.length > 2 || pieces.some((piece) => !piece)) reject();
+  try {
+    parseDocumentXml(new TextEncoder().encode(`<${name}${pieces.length === 2 ? ` xmlns:${pieces[0]}="urn:validation"` : ""}/>`), {}, budget);
+  } catch (error) {
+    if (error instanceof ResourceLimitError || error instanceof CancellationError) throw error;
+    reject();
+  }
+  if (pieces.length === 1) return ["", name];
+  const namespace = namespaces.get(pieces[0]);
+  if (!namespace) reject();
+  return [namespace, pieces[1]];
+}
+async function editDocumentControlBindings(input, options, context) {
+  const settings = archiveSettings(context);
+  const { input: identity, ...args } = options;
+  closedRecord(options, [...Object.keys(args), "input"]);
+  const opts = validateDocxInvocation({ operation: "controls.bind", 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 = { ...settings, budget };
+  const document = await openDocumentLocations(input, bounded);
+  const archive = document.snapshot();
+  const editor = new DocumentArchiveEditor(archive, {}, void 0, budget);
+  const pkg = new DocumentPackage(archive, settings.limits, budget);
+  const owners = pkg.parts.filter((part) => part.content_type.toLowerCase() !== "application/vnd.openxmlformats-package.relationships+xml" && part.partname !== "/[Content_Types].xml");
+  const { binding, valueJson, output, inPlace, force, dryRun, json, all, allowEmpty, limit: ignoredLimit, ...selectors } = opts;
+  const selected = (await inspectDocumentControls(input, selectors, bounded)).items;
+  const chosen = document.select(selected.map((item) => item.location), { ...all === void 0 ? {} : { all }, ...allowEmpty === void 0 ? {} : { allowEmpty } }, "mutation");
+  const admitted = new Set(chosen.map((location) => location.token));
+  const allItems = (await inspectDocumentControls(input, { scope: "all-stories" }, bounded)).items;
+  const targets = /* @__PURE__ */ new Map();
+  const resolve = (item) => {
+    const descriptor = item.binding;
+    if (!descriptor?.storeItemId || !descriptor.xpath) reject();
+    let mappings;
+    try {
+      mappings = parseDocumentXml(new TextEncoder().encode(`<mapping ${descriptor.prefixMappings ?? ""}/>`), {}, budget).root;
+    } catch (error) {
+      if (error instanceof ResourceLimitError || error instanceof CancellationError) throw error;
+      reject();
+    }
+    if (mappings.attributes.some((attribute) => attribute.namespace !== "http://www.w3.org/2000/xmlns/")) reject();
+    if (!descriptor.xpath.startsWith("/")) reject();
+    const steps = descriptor.xpath.slice(1).split("/").map((name) => expanded(name, mappings.namespaces, budget));
+    const stores = owners.filter((part2) => pkg.relationships(part2.partname).some((edge) => {
+      if (!customXmlRelationshipNamespaces.some((namespace) => edge.reltype === namespace + "customXmlProps")) return false;
+      if (edge.is_external) return false;
+      const root = editor.xml(edge.target_part.partname.slice(1)).root;
+      return customXmlDataNamespaces.includes(root.namespace) && root.localName === "datastoreItem" && root.attributes.some((attribute) => attribute.namespace === root.namespace && attribute.localName === "itemID" && attribute.value.toLowerCase() === descriptor.storeItemId.toLowerCase());
+    }));
+    if (stores.length !== 1) reject();
+    const part = stores[0];
+    const edges = ["/", ...owners.map((owner) => owner.partname)].flatMap((owner) => pkg.relationships(owner)).filter((edge) => customXmlRelationshipNamespaces.some((namespace) => edge.reltype === namespace + "customXml") && !edge.is_external && edge.target_part.partname === part.partname);
+    if (!edges.length || pkg.relationships(part.partname).filter((edge) => customXmlRelationshipNamespaces.some((namespace) => edge.reltype === namespace + "customXmlProps")).length !== 1) reject();
+    const xml = editor.xml(part.partname.slice(1));
+    let leaf = xml.root;
+    for (let index = 0; index < steps.length; index++) {
+      const [namespace, localName] = steps[index];
+      const nodes = (index ? leaf.children : [leaf]).filter((node) => node.namespace === namespace && node.localName === localName);
+      if (nodes.length !== 1) reject();
+      leaf = nodes[0];
+    }
+    if (leaf.content.some((node) => node.kind !== "text" && node.kind !== "cdata")) reject();
+    const type = leaf.attributes.find((attribute) => attribute.namespace === instance && attribute.localName === "type");
+    let scalar = item.kind === "checkbox" ? "boolean" : "string";
+    if (type) {
+      const [namespace, localName] = expanded(type.value, leaf.namespaces, budget);
+      if (namespace !== schema || !["string", "boolean", "integer", "double"].includes(localName)) reject();
+      scalar = localName;
+    }
+    if (scalar === "boolean" ? item.kind !== "checkbox" : scalar === "integer" || scalar === "double" ? !["plain-text", "rich-text"].includes(item.kind) : !["plain-text", "rich-text", "dropdown", "combo-box", "date"].includes(item.kind)) scalar = "unsupported";
+    return { part: part.partname, xml, leaf, key: JSON.stringify([part.partname, steps]), scalar };
+  };
+  const declarations = selected.filter((item) => admitted.has(item.location.token) && item.tag === binding);
+  if (!declarations.length) throw new SelectionError("missing-selection");
+  for (const item of allItems.filter((item2) => item2.tag === binding)) {
+    const target2 = resolve(item);
+    targets.set(target2.key + target2.scalar, target2);
+  }
+  if (targets.size !== 1) throw new SelectionError("ambiguous-selection");
+  const target = [...targets.values()][0];
+  const ownership = readDocumentBindingOwnership(pkg, budget), storeId = allItems.find((item) => item.tag === binding).binding.storeItemId.toLowerCase();
+  const targetSteps = JSON.parse(target.key)[1];
+  for (const declaration of ownership.declarations) {
+    if (declaration.storeItemId?.toLowerCase() !== storeId) continue;
+    const sdtPath = declaration.controlPath;
+    if (allItems.some((item) => item.location.value.part === declaration.part && JSON.stringify(item.location.value.path) === JSON.stringify(sdtPath))) continue;
+    let steps;
+    try {
+      const mapping = parseDocumentXml(new TextEncoder().encode(`<mapping ${declaration.prefixMappings ?? ""}/>`), {}, budget).root;
+      if (!declaration.xpath?.startsWith("/") || mapping.attributes.some((attribute) => attribute.namespace !== "http://www.w3.org/2000/xmlns/")) reject();
+      steps = declaration.xpath.slice(1).split("/").map((name) => expanded(name, mapping.namespaces, budget));
+    } catch (error) {
+      if (error instanceof ResourceLimitError || error instanceof CancellationError) throw error;
+      reject();
+    }
+    if (JSON.stringify(steps) === JSON.stringify(targetSteps)) reject();
+  }
+  const recipients = [];
+  for (const item of allItems) if (item.binding) {
+    let candidate;
+    try {
+      candidate = resolve(item);
+    } catch (error) {
+      if (!(error instanceof UnsupportedEditError)) throw error;
+      if (item.binding.storeItemId?.toLowerCase() === declarations[0].binding.storeItemId?.toLowerCase()) reject();
+      continue;
+    }
+    if (candidate.key === target.key) {
+      if (candidate.scalar !== target.scalar || !admitted.has(item.location.token)) reject();
+      recipients.push(item);
+    }
+  }
+  if (target.scalar === "string" ? typeof valueJson !== "string" : target.scalar === "boolean" ? typeof valueJson !== "boolean" : typeof valueJson !== "number" || !Number.isFinite(valueJson) || target.scalar === "integer" && !Number.isSafeInteger(valueJson)) reject();
+  const lexical = String(valueJson);
+  const stages = [];
+  assertDocumentEditable(archive, bounded, archive);
+  for (const item of recipients) {
+    const location = item.location, xml = editor.xml(location.value.part.slice(1));
+    const ancestors = chain(xml.root, location.value.path), node = ancestors.at(-1);
+    if (item.support !== "supported" || item.lock !== "unlocked" || document.references(location.token).length > 1 || containsRevision(node) || ancestors.slice(0, -1).some((owner) => owner.namespace === node.namespace && ["ins", "del", "moveFrom", "moveTo"].includes(owner.localName))) reject();
+    for (const owner of ancestors.slice(0, -1)) if (owner.namespace === node.namespace && owner.localName === "sdt") {
+      const snapshot = inspectControlSnapshot(owner, location, archive, bounded, xml);
+      if (snapshot.support !== "supported" || snapshot.lock !== "unlocked" || snapshot.binding) reject();
+    }
+    const story = document.list("story", { scope: "all-stories" }).filter((owner) => owner.value.story === location.value.story && pathContains(owner.value.path, location.value.path)).sort((a, b) => b.value.path.length - a.value.path.length)[0];
+    if (!story) reject();
+    assertOutsideFields(parseFields(ancestors[story.value.path.length], story.value.path, budget, xml.compatibility.content), location.value.path);
+    assertOutsideRevisionRanges(xml.root, node, budget, xml.compatibility.branches);
+    const values = item.kind === "checkbox" ? { checked: valueJson } : item.kind === "date" ? { date: lexical } : ["dropdown", "combo-box"].includes(item.kind) ? { choice: lexical } : { text: lexical };
+    stages.push(prepareControlValue(xml, node, item, values, bounded));
+  }
+  const changes = recipients.map((item) => {
+    const before = item.location, value = { ...before.value, generation: 1 };
+    return { kind: "replace", before, after: { ...before, value, token: encodeGeneratedLocation(value) } };
+  });
+  const prospective = { changed: true, changes, output: dryRun ? null : { path: inPlace ? identity?.path ?? null : output ?? null, bytes: Math.min(settings.limits.maxArchiveBytes, Number.MAX_SAFE_INTEGER), sha256: "0".repeat(64) }, dryRun: dryRun ?? false };
+  budget.check("serializedOutput", new TextEncoder().encode(JSON.stringify({ version: 1, operation: "controls.bind", ok: true, data: prospective, affected: changes.length, locations: changes.map((change) => change.after), warnings: [], errors: [] }) + "\n").length);
+  target.xml.replaceScalarText(target.leaf, lexical);
+  for (const stage of stages) stage();
+  const published = await publishDocumentArchive(editor.snapshot(), { ...identity ? { input: identity } : {}, ...output === void 0 ? {} : { output }, ...inPlace === void 0 ? {} : { inPlace }, ...force === void 0 ? {} : { force }, ...dryRun === void 0 ? {} : { dryRun }, ...json === void 0 ? {} : { json } }, { ...context, budget }, archive);
+  return { ...prospective, output: published.published.length ? { path: published.published[0].path, bytes: published.published[0].bytes, sha256: published.archiveSha256 } : null };
+}
+
+export {
+  editDocumentControlBindings
+};

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

@@ -0,0 +1,23 @@
+import {
+  docxOperationSchemas,
+  splitDocxType
+} from "./chunk-R4TYL2G6.js";
+
+// packages/safe-bash-docx-engine/src/part-provider.ts
+var nativeStoryTypes = ["DocumentPart", "StoryPart", "HeaderPart", "FooterPart", "CommentsPart"];
+var xmlPartTypes = [...nativeStoryTypes, "XmlPart", "XmlPartView", "PartView", "Part", "SettingsPart", "StylesPart", "NumberingPart", "CorePropertiesPart"];
+var partProviderReceivers = /* @__PURE__ */ new Map();
+for (const [protocol, types] of [["ProvidesStoryPart", nativeStoryTypes], ["ProvidesXmlPart", xmlPartTypes]]) {
+  const receivers = new Set(types);
+  for (const id of Object.keys(docxOperationSchemas)) {
+    if (!id.endsWith(".part.get")) continue;
+    const schema = docxOperationSchemas[id];
+    if (schema.receiver && splitDocxType(schema.valueType).every((type) => types.includes(type))) receivers.add(schema.receiver);
+  }
+  if (protocol === "ProvidesStoryPart") for (const type of ["Part", "PartView", "XmlPart", "XmlPartView"]) receivers.add(type);
+  partProviderReceivers.set(protocol, receivers);
+}
+
+export {
+  partProviderReceivers
+};