@poe-platform/safe-bash 0.1.814 → 0.1.815

package/dist/safe-bash/command-chunks/{chunk-VT7UBPAE.js → chunk-YW2VYN4V.js}

@@ -1,3 +1,7 @@
+import {
+  materializeText,
+  textSize
+} from "./chunk-KHUT7BB5.js";
 import {
   decodeHeaderPath,
   isEpochHeader
@@ -40,11 +44,17 @@ async function parseUnifiedSection(cursor, budget) {
 }
 function bufferedLines() {
   const lines = [];
-  return { lines, append(line) {
-    lines.push(line);
+  return { lines, async append(line) {
+    lines.push({ kind: line.kind, text: await materializeText(line.text) });
+  } };
+}
+function bufferedHunks() {
+  const hunks = [];
+  return { hunks, append(hunk) {
+    hunks.push(hunk);
   } };
 }
-async function parseUnifiedReader(cursor, budget, single, createLines) {
+async function parseUnifiedReader(cursor, budget, single, createLines, createHunks = bufferedHunks) {
   const physical = cursor.input;
   const patches = [];
   let index = cursor.index;
@@ -73,7 +83,8 @@ async function parseUnifiedReader(cursor, budget, single, createLines) {
     const newEpoch = isEpochHeader(await physical.read(index));
     index++;
     budget.file();
-    const hunks = [];
+    const hunkBuilder = createHunks();
+    const hunks = hunkBuilder.hunks;
     let oldEnded = false;
     let newEnded = false;
     while (index < physical.length && (await physical.read(index)).startsWith("@@")) {
@@ -99,27 +110,28 @@ async function parseUnifiedReader(cursor, budget, single, createLines) {
           const c = budget.checkpoint();
           if (c) await c;
         }
-        const body = await physical.read(index++);
+        const bodyIndex = index++;
+        const body = await physical.read(bodyIndex, physical.body ? 1 : void 0);
         const kind = body === "" ? " " : body?.[0];
         if (body === void 0 || kind !== " " && kind !== "+" && kind !== "-") throw new ToolError("truncated or malformed hunk body");
         if (kind !== "+" && oldEnded || kind !== "-" && newEnded) throw new ToolError("content follows an incomplete final line");
         if (kind !== "+") oldRead++;
         if (kind !== "-") newRead++;
         if (oldRead > oldCount || newRead > newCount) throw new ToolError("hunk line counts do not match header");
-        const entry = { kind, text: `${body.slice(1)}
-` };
+        const incomplete = physical.matches ? await physical.matches(index, "\") : await physical.read(index) === "\";
+        const text = physical.body ? await physical.body(bodyIndex, 1, incomplete) : `${body.slice(1)}${incomplete ? "" : "\n"}`;
+        const entry = { kind, text };
         changed ||= kind !== " ";
-        if (await physical.read(index) === "\") {
-          if (entry.text === "\n") throw new ToolError("empty incomplete line is not a valid text line");
+        if (incomplete) {
+          if (textSize(text) === 0) throw new ToolError("empty incomplete line is not a valid text line");
           index++;
-          entry.text = entry.text.slice(0, -1);
           if (kind !== "+") oldEnded = true;
           if (kind !== "-") newEnded = true;
         }
         await bodyLines.append(entry);
       }
       if (!changed) throw new ToolError("hunk has no changes");
-      hunks.push({ oldStart, oldCount, newStart, newCount, lines: bodyLines.lines, section: match[5] ?? "" });
+      await hunkBuilder.append({ oldStart, oldCount, newStart, newCount, lines: bodyLines.lines, section: match[5] ?? "" });
     }
     if (!hunks.length) throw new ToolError("file patch has no hunks");
     patches.push({ oldPath, newPath, oldEpoch, newEpoch, oldHeader, newHeader, hunks });

package/dist/safe-bash/command-chunks/{chunk-GQGMQMIM.js → chunk-ZIGENXGC.js}

@@ -1,3 +1,8 @@
+import {
+  openRetainedPresentationIndex,
+  stageRetainedOutput,
+  streamJson
+} from "./chunk-4EHY6J2Z.js";
 import {
   attr,
   child,
@@ -11,6 +16,12 @@ import {
 import {
   SelectionError
 } from "./chunk-W3ZSWK76.js";
+import {
+  openRetainedPresentationValidation
+} from "./chunk-3GRMU7TM.js";
+import {
+  dialects
+} from "./chunk-AWPI4DZR.js";
 import {
   parseXmlPart
 } from "./chunk-DBLQUZGN.js";
@@ -18,11 +29,240 @@ import {
   relativePartReference
 } from "./chunk-WTVJLHMG.js";
 import {
-  OfficeError
+  OfficeError,
+  RetainedValues,
+  equal,
+  folded,
+  literal,
+  openRetainedXmlDocument,
+  resolveOfficeResources
 } from "./chunk-CXME4YHU.js";
 
 // packages/safe-bash-presentation-engine/src/notes.ts
 import { SaxesParser } from "saxes";
+
+// packages/safe-bash-presentation-engine/src/retained-notes.ts
+import { PagedStorage } from "@poe-platform/safe-fs/storage";
+async function openRetainedNotes(archive, fingerprint, options, settings, selectBeforeValidation = false) {
+  if (!options || typeof options !== "object" || ![Object.prototype, null].includes(Object.getPrototypeOf(options)) || Object.keys(options).some((key) => key !== "selection"))
+    throw new OfficeError("invalid-value", "Invalid notes query.", "usage");
+  if (options.selection !== void 0 && (!options.selection || typeof options.selection !== "object" || ![Object.prototype, null].includes(Object.getPrototypeOf(options.selection))))
+    throw new SelectionError("invalid-selection");
+  const selection = options.selection === void 0 ? void 0 : { ...options.selection, kind: options.selection.kind ?? "slide", ...options.selection.position ? { position: { ...options.selection.position } } : {} };
+  const context = resolveOfficeResources(settings), working = { ...settings.workingStorage }, signal = context.signal ?? new AbortController().signal;
+  const index = await openRetainedPresentationIndex(archive, fingerprint, { ...context, workingStorage: working });
+  const pages = new PagedStorage({ fs: working.fs, cwd: working.directory, env: {}, signal }, (working.cacheBytes ?? 1024 * 1024) / 16384);
+  let closed = false, closing, first = 0, last = 0, count = 0;
+  const check = () => {
+    if (closed) throw new OfficeError("invalid-handle", "Notes are closed.", "select");
+    if (signal.aborted) throw new OfficeError("cancelled", "Operation cancelled.", "select");
+  };
+  const failure = (error) => error instanceof OfficeError ? error : new OfficeError(signal.aborted ? "cancelled" : "io-failure", "Notes storage operation failed.", "select");
+  const close = () => {
+    closed = true;
+    return closing ??= (async () => {
+      const outcomes = await Promise.allSettled([index.close(), pages.close()]);
+      for (const outcome of outcomes) if (outcome.status === "rejected") throw outcome.reason;
+    })();
+  };
+  const values = new RetainedValues(pages, check, signal);
+  const range = (row2, field) => ({ start: row2[field], length: row2[field + 1] });
+  async function row(pointer) {
+    check();
+    const bytes = await pages.read(pointer, 11 /* Count */ * 8), view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    return Array.from({ length: 11 /* Count */ }, (_, n) => view.getFloat64(n * 8, true));
+  }
+  async function write(pointer, numbers) {
+    check();
+    const bytes = new Uint8Array(numbers.length * 8), view = new DataView(bytes.buffer);
+    numbers.forEach((number, n) => view.setFloat64(n * 8, number, true));
+    await pages.write(pointer, bytes);
+  }
+  async function metadata(value) {
+    const decoder = new TextDecoder();
+    let result = "";
+    for await (const bytes of values.read(value)) result += decoder.decode(bytes, { stream: true });
+    return result + decoder.decode();
+  }
+  try {
+    if (selectBeforeValidation && selection) for await (const record of index.records.select(selection)) {
+      void record;
+      check();
+    }
+    const validation = await openRetainedPresentationValidation(archive, { ...context, workingStorage: working }, {
+      ...context.xmlLimits,
+      ...context.relationshipLimits,
+      maxBytes: Math.min(context.xmlLimits.maxBytes, context.relationshipLimits.maxBytes),
+      maxEntries: context.archiveLimits.maxMembers
+    });
+    const valid = validation.valid;
+    try {
+      await validation.close();
+    } catch (error) {
+      if (valid) await Promise.reject(error);
+    }
+    if (!valid) throw new OfficeError("invalid-opc", "Invalid presentation graph.", "validate-intent");
+    for await (const part of archive.parts()) {
+      const key = await values.store(folded(literal(part))), value = await values.store(literal(part));
+      await values.insert("parts", key, value);
+    }
+    const main = await openRetainedXmlDocument(archive.read(index.records.main), { ...context, workingStorage: working });
+    let dialect = dialects[0], mainFailed = false;
+    try {
+      for (const candidate of dialects) if (await equal(main.namespace(main.root), literal(candidate.p))) dialect = candidate;
+    } catch (error) {
+      mainFailed = true;
+      throw error;
+    } finally {
+      try {
+        await main.close();
+      } catch (error) {
+        if (!mainFailed) await Promise.reject(error);
+      }
+    }
+    async function target(owner, kind, internal) {
+      for await (const edge of index.graph.outgoing(owner)) if ((!internal || !edge.external) && await equal(edge.type(), literal(`${dialect.r}/${kind}`))) {
+        if (!edge.targetPart) return void 0;
+        const original = await values.find("parts", () => folded(edge.targetPart()));
+        if (!original) throw new OfficeError("missing-binding", "Package member is absent.", "index");
+        return { name: await metadata(original), reference: await values.store(edge.targetPart()) };
+      }
+      return void 0;
+    }
+    if (selection) {
+      for await (const slide of index.records.select(selection)) if (slide.kind !== "slide") throw new SelectionError("invalid-selection");
+    }
+    for await (const slide of selection ? index.records.select(selection) : index.records.records("slide")) {
+      const part = await target(slide.part, "notesSlide", true);
+      if (!part) continue;
+      const document = await openRetainedXmlDocument(archive.read(part.name), { ...context, workingStorage: working });
+      let failed = false;
+      try {
+        async function is(node, local, namespace) {
+          return node.kind === "element" && await equal(document.raw(node.localName), literal(local)) && await equal(document.namespace(node), namespace);
+        }
+        async function child2(node, local) {
+          if (!node) return void 0;
+          let found;
+          for await (const candidate of document.children(node)) if (await is(candidate, local, document.namespace(node))) {
+            if (found) throw new OfficeError("invalid-value", "Ambiguous shared structure.", "usage");
+            found = candidate;
+          }
+          return found;
+        }
+        async function required2(node, local) {
+          const found = await child2(node, local);
+          if (!found) throw new OfficeError("unsupported-edit", "Unsupported shared structure.", "validate-intent");
+          return found;
+        }
+        async function attribute(node, local) {
+          if (node) {
+            for await (const candidate of document.attributes(node)) if (await equal(document.raw(candidate.localName), literal(local)) && await equal(document.namespace(candidate), literal(""))) return candidate;
+          }
+          return void 0;
+        }
+        const tree = await required2(await required2(document.root, "cSld"), "spTree");
+        let body2;
+        for await (const node of document.children(tree)) if (await is(node, "sp", document.namespace(document.root))) {
+          const placeholder2 = await child2(await child2(await child2(node, "nvSpPr"), "nvPr"), "ph"), type = await attribute(placeholder2, "type");
+          if (type && await equal(document.text(type), literal("body"))) {
+            if (body2) throw new OfficeError("ambiguous-selection", "Notes have multiple speaker bodies.", "select");
+            body2 = node;
+          }
+        }
+        const id = await attribute(await child2(await child2(body2, "nvSpPr"), "cNvPr"), "id"), textBody = await child2(body2, "txBody");
+        const idRange = id ? await values.store(document.text(id)) : { start: -1, length: 0 };
+        let drawing = dialects[0].a;
+        for (const candidate of dialects) if (await equal(document.namespace(document.root), literal(candidate.p))) drawing = candidate.a;
+        async function* speakerText2() {
+          let separator = false;
+          if (textBody) {
+            for await (const paragraph of document.children(textBody)) if (await is(paragraph, "p", literal(drawing))) {
+              if (separator) yield* literal("\n");
+              separator = true;
+              for await (const inline of document.children(paragraph)) {
+                if (await is(inline, "br", literal(drawing))) yield* literal("\v");
+                else if (await is(inline, "r", literal(drawing)) || await is(inline, "fld", literal(drawing))) {
+                  for await (const text2 of document.children(inline)) if (await is(text2, "t", literal(drawing))) yield* document.text(text2);
+                }
+              }
+            }
+          }
+        }
+        const text = textBody ? await values.store(speakerText2()) : { start: -1, length: 0 }, master = await target(part.name, "notesMaster", false);
+        if (!master) throw new OfficeError("invalid-opc", "Missing notes master.", "index");
+        const descriptor = await values.store(literal(JSON.stringify({ selector: slide.token, location: slide.location, slide: slide.position })));
+        const pointer = pages.allocate(11 /* Count */ * 8);
+        await write(pointer, [0, descriptor.start, descriptor.length, part.reference.start, part.reference.length, master.reference.start, master.reference.length, text.start, text.length, idRange.start, idRange.length]);
+        if (last) await write(last, [pointer]);
+        else first = pointer;
+        last = pointer;
+        count++;
+      } catch (error) {
+        failed = true;
+        throw error;
+      } finally {
+        try {
+          await document.close();
+        } catch (error) {
+          if (!failed) await Promise.reject(error);
+        }
+      }
+    }
+    await index.close();
+    check();
+    async function* records() {
+      try {
+        for (let pointer = first; pointer; ) {
+          const entry = await row(pointer), descriptor = JSON.parse(await metadata(range(entry, 1 /* Metadata */)));
+          yield {
+            ...descriptor,
+            part: () => values.read(range(entry, 3 /* Part */)),
+            master: () => values.read(range(entry, 5 /* Master */)),
+            text: entry[7 /* Text */] === -1 ? null : () => values.read(range(entry, 7 /* Text */)),
+            bodyShapeId: entry[9 /* Id */] === -1 ? null : () => values.read(range(entry, 9 /* Id */))
+          };
+          pointer = entry[0 /* Next */];
+        }
+        check();
+      } catch (error) {
+        throw failure(error);
+      }
+    }
+    return Object.freeze({ records, close, count });
+  } catch (error) {
+    await close().catch(() => {
+    });
+    throw failure(error);
+  }
+}
+async function stageRetainedNotes(archive, fingerprint, options, settings, output) {
+  const format = { ...output }, notes = await openRetainedNotes(archive, fingerprint, options, settings, format.operation === "notes.get");
+  let staged;
+  async function* locations() {
+    for await (const note of notes.records()) yield note.location;
+  }
+  async function* render() {
+    if (format.json) {
+      yield* streamJson({ version: 1, operation: format.operation, ok: true, data: format.operation === "notes.get" && !notes.count ? null : { notes: notes.records() }, affected: 0, warnings: [], errors: [], locations: locations() });
+      yield* literal("\n");
+    } else for await (const note of notes.records()) {
+      yield* literal(`${note.slide}: `);
+      if (note.text) yield* note.text();
+      yield* literal("\n");
+    }
+  }
+  try {
+    staged = await stageRetainedOutput(render(), settings, format.maxOutputBytes);
+    await notes.close();
+    return staged;
+  } catch (error) {
+    await Promise.allSettled([notes.close(), staged?.close()]);
+    throw error;
+  }
+}
+
+// packages/safe-bash-presentation-engine/src/notes.ts
 var relns = "http://schemas.openxmlformats.org/package/2006/relationships";
 function notesPart(s, slide) {
   return s.index.inventory.relationships.find(
@@ -366,6 +606,8 @@ async function mutateNotes(input, action, options, context) {
 }
 
 export {
+  openRetainedNotes,
+  stageRetainedNotes,
   readNotes,
   validateNotesOptions,
   mutateNotes

package/dist/safe-bash/command-chunks/{command-engine-7V6PZR7G.js → command-engine-M7S4QIXV.js}

@@ -11,6 +11,9 @@ import {
 } from "./chunk-NUGQQDGE.js";
 import "./chunk-65DS4IOB.js";
 
+// packages/safe-bash-command-pptx/src/command-engine.ts
+import { stageRetainedNotes } from "../../safe-bash-presentation-engine/notes.js";
+
 // packages/safe-bash-command-pptx/src/retained-pack-manifest.ts
 import { PagedStorage } from "@poe-platform/safe-fs/storage";
 import { resourceContext } from "../../safe-bash-presentation-engine/resource-limits.js";
@@ -12078,8 +12081,8 @@ async function executeRequest(request, options2, owned) {
         publication = { inputPath: args.input, outputPath: destination, bytes: staged.bytes(), originalBytes: input, inPlace: args.inPlace ?? false, force: args.force ?? false, dryRun };
       }
       result = success(operation2, null);
-    } else if ((args.operation === "inspect" || args.operation === "text.get" || args.operation === "fields.list" || args.operation === "fields.get" || args.operation === "text.frames.list" || args.operation === "text.frames.get" || args.operation === "xml.get") && request.streaming) {
-      if (args.token) decodeSelectionToken2(args.token);
+    } else if ((args.operation === "inspect" || args.operation === "text.get" || args.operation === "fields.list" || args.operation === "fields.get" || args.operation === "text.frames.list" || args.operation === "text.frames.get" || args.operation === "notes.list" || args.operation === "notes.get" || args.operation === "xml.get") && request.streaming) {
+      if (args.token && args.operation !== "notes.list" && args.operation !== "notes.get") decodeSelectionToken2(args.token);
       const input = await request.streaming.openInput(args.input, Math.min(options2.context.limits.maxBytes, options2.context.archiveLimits.maxArchiveBytes));
       const hash = sha2564.create();
       for await (const bytes of input.stream()) {
@@ -12091,8 +12094,13 @@ async function executeRequest(request, options2, owned) {
       const archive = await openPackageArchive(input, context);
       let failed = false;
       try {
-        const scope = args.token ? decodeSelectionToken2(args.token).scope : args.scope;
-        stagedOutput = args.operation === "xml.get" ? await stageRetainedXmlPart(archive, fingerprint, {
+        const scope = args.operation === "notes.list" || args.operation === "notes.get" ? void 0 : args.token ? decodeSelectionToken2(args.token).scope : args.scope;
+        stagedOutput = args.operation === "notes.list" || args.operation === "notes.get" ? await stageRetainedNotes(archive, fingerprint, { selection: {
+          kind: "slide",
+          ...args.token ? { token: args.token } : {},
+          ...args.slide === void 0 ? {} : { position: { coordinateSystem: "one-based", value: args.slide } },
+          ...!args.token && (args.all || args.operation === "notes.list") ? { all: true } : {}
+        } }, context, { json: args.json, operation: args.operation, maxOutputBytes: options2.maxOutputBytes }) : args.operation === "xml.get" ? await stageRetainedXmlPart(archive, fingerprint, {
           ...args.token === void 0 ? {} : { token: args.token },
           ...args.slide === void 0 ? {} : { slide: args.slide },
           ...args.shape === void 0 ? {} : { shape: args.shape },

package/dist/safe-bash/command-chunks/{engine-UYJENSWK-VSCGKSQV.js → engine-YUYZJIB4-NZUDFEHL.js}

@@ -1,7 +1,7 @@
 import {
   Si,
   gi
-} from "./chunk-2ETEJOYX.js";
+} from "./chunk-HQ2UN2L2.js";
 import "./chunk-Z7ESJVFP.js";
 import "./chunk-WHWIZ2B7.js";
 import "./chunk-65DS4IOB.js";

package/dist/safe-bash-command-ffmpeg/index.js

@@ -20,7 +20,7 @@ import {
   sliceMp4,
   srtAst,
   webvttAst
-} from "../safe-bash/command-chunks/chunk-LAPOMHGY.js";
+} from "../safe-bash/command-chunks/chunk-NEYITAAO.js";
 import "../safe-bash/command-chunks/chunk-65DS4IOB.js";
 
 // packages/safe-bash-command-ffmpeg/src/index.ts

package/dist/safe-bash-command-ffprobe/index.js

@@ -1,8 +1,8 @@
 import {
   createFfprobeCommand
-} from "../safe-bash/command-chunks/chunk-K4XNUJVJ.js";
+} from "../safe-bash/command-chunks/chunk-6EINUY5G.js";
 import "../safe-bash/command-chunks/chunk-MGBHGZEX.js";
-import "../safe-bash/command-chunks/chunk-LAPOMHGY.js";
+import "../safe-bash/command-chunks/chunk-NEYITAAO.js";
 import "../safe-bash/command-chunks/chunk-65DS4IOB.js";
 
 // packages/safe-bash-command-ffprobe/src/index.ts

package/dist/safe-bash-command-ffprobe/media.d.ts

@@ -1,6 +1,6 @@
 import { type AudioAst } from "../audio-ast/index.js";
 import { type CommandContext, type CommandDefinition } from "../safe-bash-contracts/command.js";
-import { createMediaAstRegistry, MediaBudgetTracker, type MediaAstPlugin, type MediaFeatureOptions, type MediaProbeResult, type MediaProbeRecords, type MediaResourceLimits } from "../mp4-ast/index.js";
+import { createMediaAstRegistry, MediaBudgetTracker, type MediaAstPlugin, type MediaFeatureOptions, type MediaProbeResult, type MediaProbeRecords, type MediaProbeSourceRecords, type MediaProbeStream, type MediaResourceLimits } from "../mp4-ast/index.js";
 export interface MediaCommandsOptions {
     /**
      * Pluggable AST engines that determine which container formats, extensions,
@@ -60,7 +60,13 @@ export type FfprobeFormatOptions = {
 };
 /** Explicit buffering convenience for synchronous callers. */
 export declare function formatFfprobeResult(probe: MediaProbeResult, opts: FfprobeFormatOptions, audioInput?: AudioProbeInput): string;
-export declare function formatFfprobeResultChunks(probe: MediaProbeRecords, opts: FfprobeFormatOptions, audioInput?: AudioProbeInput): Generator<string>;
+type SyncProbeRows = Omit<MediaProbeRecords, "streams" | "chapters"> & {
+    readonly streams: Iterable<MediaProbeStream>;
+    readonly chapters: Iterable<MediaProbeResult["chapters"][number]>;
+};
+export declare function formatFfprobeResultChunks(probe: SyncProbeRows, opts: FfprobeFormatOptions, audioInput?: AudioProbeInput): Generator<string>;
+/** Consume one-shot caller-backed records with backpressure and iterator cleanup. */
+export declare function formatFfprobeSourceChunks(probe: MediaProbeSourceRecords, opts: FfprobeFormatOptions, audioInput?: AudioProbeInput, signal?: AbortSignal): AsyncGenerator<string>;
 export declare function getDefaultMediaRegistry(): {
     astPlugins: readonly MediaAstPlugin[];
     registry: ReturnType<typeof createMediaAstRegistry>;

package/dist/safe-bash-command-ffprobe/media.js

@@ -4,15 +4,16 @@ import {
   evalSyncFfprobe,
   formatFfprobeResult,
   formatFfprobeResultChunks,
+  formatFfprobeSourceChunks,
   formatIntrospectionOutput,
   getDefaultMediaRegistry,
   isStdin,
   loadManifestResources,
   resolvePath,
   rethrowRuntimeError
-} from "../safe-bash/command-chunks/chunk-K4XNUJVJ.js";
+} from "../safe-bash/command-chunks/chunk-6EINUY5G.js";
 import "../safe-bash/command-chunks/chunk-MGBHGZEX.js";
-import "../safe-bash/command-chunks/chunk-LAPOMHGY.js";
+import "../safe-bash/command-chunks/chunk-NEYITAAO.js";
 import "../safe-bash/command-chunks/chunk-65DS4IOB.js";
 export {
   createFfprobeCommand,
@@ -20,6 +21,7 @@ export {
   evalSyncFfprobe,
   formatFfprobeResult,
   formatFfprobeResultChunks,
+  formatFfprobeSourceChunks,
   formatIntrospectionOutput,
   getDefaultMediaRegistry,
   isStdin,

package/dist/safe-bash-command-pandoc/command.js

@@ -1,8 +1,8 @@
 import {
-  Ju,
+  Vu,
   gR,
   wR
-} from "../safe-bash/command-chunks/chunk-G3TAX3CV.js";
+} from "../safe-bash/command-chunks/chunk-WAT2562G.js";
 import "../safe-bash/command-chunks/chunk-7QRIAJEQ.js";
 import "../safe-bash/command-chunks/chunk-IOEUZ4EA.js";
 import "../safe-bash/command-chunks/chunk-E6SK3OU2.js";
@@ -14,7 +14,7 @@ import "../safe-bash/command-chunks/chunk-5NKZJEUI.js";
 import "../safe-bash/command-chunks/chunk-QIFS4QHZ.js";
 import "../safe-bash/command-chunks/chunk-65DS4IOB.js";
 export {
-  Ju as createPandocCommand,
+  Vu as createPandocCommand,
   wR as createPandocCommands,
   gR as pandocCommands
 };

package/dist/safe-bash-command-pandoc/index.js

@@ -5,26 +5,26 @@ import {
   El,
   IE,
   Ie,
-  Ju,
   OE,
   Oa,
   Qi,
-  Qo,
   UP,
   Uu,
+  Vu,
+  Zo,
   Zs,
   _P,
   _u,
   cn,
   dd,
+  el,
   gR,
   ir,
   pT,
   pu,
   su,
-  tl,
   wR
-} from "../safe-bash/command-chunks/chunk-G3TAX3CV.js";
+} from "../safe-bash/command-chunks/chunk-WAT2562G.js";
 import "../safe-bash/command-chunks/chunk-7QRIAJEQ.js";
 import "../safe-bash/command-chunks/chunk-IOEUZ4EA.js";
 import "../safe-bash/command-chunks/chunk-E6SK3OU2.js";
@@ -52,7 +52,7 @@ function K(u = {}) {
     e2.signal.throwIfAborted();
     let a = new TextEncoder(), f, C;
     try {
-      let o = tl(e2.args, i);
+      let o = el(e2.args, i);
       if (o !== void 0) f = a.encode(o);
       else {
         let s = e2.fs ? { ...e2.cwd === void 0 ? {} : { cwd: e2.cwd }, stdin: e2.stdin, ...e2.createOutput ? { createOutput: e2.createOutput.bind(e2) } : {}, ...e2.fs.readStream ? { readStream: async function* (t2, r, n) {
@@ -116,7 +116,7 @@ export {
   El as convert,
   UP as convertSync,
   Du as convertToOutput,
-  Qo as coreFormats,
+  Zo as coreFormats,
   yr as createCiteprocFilterCapability,
   OE as createExecutionContext,
   Al as createFileOutput,
@@ -124,13 +124,13 @@ export {
   Ie as createFormatRegistry,
   pu as createJsonFilterCapability,
   _r as createLuaFilterCapability,
-  Ju as createPandocCommand,
+  Vu as createPandocCommand,
   wR as createPandocCommands,
   K as createStandalonePandocCommand,
   Oa as defaultLimits,
   _u as evalSyncPandoc,
   pT as formatCapabilities,
-  tl as inspectCommand,
+  el as inspectCommand,
   Zs as inspectFormats,
   IE as normalizeDocument,
   su as normalizeDocumentCooperatively,

package/dist/safe-bash-command-patch/index.js

@@ -1,14 +1,15 @@
 import {
   patchCommand
-} from "../safe-bash/command-chunks/chunk-AVGXFWEB.js";
-import "../safe-bash/command-chunks/chunk-3JM7E42I.js";
-import "../safe-bash/command-chunks/chunk-5BIQWWLB.js";
-import "../safe-bash/command-chunks/chunk-CK2WFJZN.js";
+} from "../safe-bash/command-chunks/chunk-44F5TOHZ.js";
+import "../safe-bash/command-chunks/chunk-GPGLTWNR.js";
+import "../safe-bash/command-chunks/chunk-CFMJXJS5.js";
+import "../safe-bash/command-chunks/chunk-KASXIRKD.js";
 import {
   evalSyncPatch
 } from "../safe-bash/command-chunks/chunk-KSY3QHLY.js";
-import "../safe-bash/command-chunks/chunk-SW37YCBW.js";
-import "../safe-bash/command-chunks/chunk-VT7UBPAE.js";
+import "../safe-bash/command-chunks/chunk-U3C6IT2C.js";
+import "../safe-bash/command-chunks/chunk-YW2VYN4V.js";
+import "../safe-bash/command-chunks/chunk-KHUT7BB5.js";
 import "../safe-bash/command-chunks/chunk-OQNX2OOS.js";
 import "../safe-bash/command-chunks/chunk-AJEQUVDN.js";
 import "../safe-bash/command-chunks/chunk-65DS4IOB.js";

package/dist/safe-bash-command-patch/patch-formats.d.ts

@@ -1,12 +1,13 @@
-import { type FilePatch, type PatchInput, type IndexedUnifiedCursor } from "./unified.js";
+import { type FilePatch, type Hunk, type PatchInput, type IndexedUnifiedCursor } from "./unified.js";
 import { Budget } from "../safe-bash-diff-engine/shared.js";
+import { type PatchText } from "./patch-text.js";
 export type PatchFormat = "unified" | "normal" | "context";
 export interface ParseProgress {
     error?: unknown;
 }
 export declare function parsePatch(text: string | PatchInput, budget: Budget, format: PatchFormat | undefined, target: string | undefined, progress?: ParseProgress, convert?: (source: AsyncIterable<string>) => Promise<FilePatch[]>): Promise<FilePatch[]>;
-export interface PatchParsers<Lines> {
-    unified(cursor: IndexedUnifiedCursor): Promise<FilePatch<Lines>[]>;
-    converted(source: AsyncIterable<string>): Promise<FilePatch<Lines>[]>;
+export interface PatchParsers<Lines, Hunks = Hunk<Lines>[]> {
+    unified(cursor: IndexedUnifiedCursor): Promise<FilePatch<Lines, Hunks>[]>;
+    converted(source: AsyncIterable<PatchText>): Promise<FilePatch<Lines, Hunks>[]>;
 }
-export declare function parsePatchWith<Lines>(text: string | PatchInput, budget: Budget, format: PatchFormat | undefined, target: string | undefined, parsers: PatchParsers<Lines>, progress?: ParseProgress): Promise<FilePatch<Lines>[]>;
+export declare function parsePatchWith<Lines, Hunks = Hunk<Lines>[]>(text: string | PatchInput, budget: Budget, format: PatchFormat | undefined, target: string | undefined, parsers: PatchParsers<Lines, Hunks>, progress?: ParseProgress): Promise<FilePatch<Lines, Hunks>[]>;

package/dist/safe-bash-command-patch/patch-formats.js

@@ -1,8 +1,9 @@
 import {
   parsePatch,
   parsePatchWith
-} from "../safe-bash/command-chunks/chunk-SW37YCBW.js";
-import "../safe-bash/command-chunks/chunk-VT7UBPAE.js";
+} from "../safe-bash/command-chunks/chunk-U3C6IT2C.js";
+import "../safe-bash/command-chunks/chunk-YW2VYN4V.js";
+import "../safe-bash/command-chunks/chunk-KHUT7BB5.js";
 import "../safe-bash/command-chunks/chunk-AJEQUVDN.js";
 import "../safe-bash/command-chunks/chunk-65DS4IOB.js";
 export {

package/dist/safe-bash-command-patch/patch-gnu-paths.d.ts

@@ -1,4 +1,4 @@
-import type { FilePatch, PatchLine } from "./unified.js";
+import type { FilePatch, Hunk, PatchLine } from "./unified.js";
 import { type FileStat } from "../safe-bash-contracts/index.js";
 import { Budget } from "../safe-bash-diff-engine/shared.js";
 export interface PathOptions {
@@ -8,8 +8,8 @@ export interface PathOptions {
     readonly reject: string | undefined;
     readonly input: string | undefined;
 }
-export interface AuthorizedPatch<Lines = PatchLine[]> {
-    readonly patch: FilePatch<Lines>;
+export interface AuthorizedPatch<Lines = PatchLine[], Hunks = Hunk<Lines>[]> {
+    readonly patch: FilePatch<Lines, Hunks>;
     readonly oldName: string | undefined;
     readonly newName: string | undefined;
     readonly indexName: string | undefined;
@@ -17,15 +17,15 @@ export interface AuthorizedPatch<Lines = PatchLine[]> {
     readonly selected?: string;
     readonly posix?: boolean;
 }
-interface SelectionState<Lines> {
+interface SelectionState<Lines, Hunks> {
     readonly reverse: boolean;
     readonly exists: (path: string) => Promise<boolean>;
-    readonly advance: (patch: AuthorizedPatch<Lines>) => Promise<void>;
+    readonly advance: (patch: AuthorizedPatch<Lines, Hunks>) => Promise<void>;
 }
 export declare function regular(stat: FileStat | undefined, path: string): void;
 export declare function rejectName(target: string, options: PathOptions): string | undefined;
 export declare function pruneParents(target: string, cwd: string): string[];
-export declare function authorizePaths<Lines>(patches: readonly FilePatch<Lines>[], options: PathOptions, budget: Budget, state?: SelectionState<Lines>): Promise<AuthorizedPatch<Lines>[]>;
+export declare function authorizePaths<Lines, Hunks>(patches: readonly FilePatch<Lines, Hunks>[], options: PathOptions, budget: Budget, state?: SelectionState<Lines, Hunks>): Promise<AuthorizedPatch<Lines, Hunks>[]>;
 export interface BackupOptions {
     suffix?: string;
     prefix?: string;
@@ -35,7 +35,7 @@ export interface BackupOptions {
 export declare function backupName(path: string, budget: Budget, options?: BackupOptions): Promise<string>;
 export declare function authorizeOutputs(paths: readonly (string | undefined)[], targets: ReadonlySet<string>, input: string | undefined, budget: Budget): Promise<void>;
 export declare function candidateStat(path: string, budget: Budget): Promise<FileStat | undefined>;
-export declare function selectTarget(authorized: AuthorizedPatch<unknown>, exists: (path: string) => Promise<boolean>, budget: Budget): Promise<string>;
+export declare function selectTarget(authorized: AuthorizedPatch<unknown, unknown>, exists: (path: string) => Promise<boolean>, budget: Budget): Promise<string>;
 export declare function ensureParents(path: string, budget: Budget): Promise<void>;
 export declare function pruneDirectories(parents: ReadonlySet<string>, budget: Budget): Promise<void>;
 export {};