pi-outpost 0.45.0 → 0.47.0

package/dist/pi-outpost-tools.mjs

@@ -493,9 +493,9 @@ function lookupRect(arr, fallback) {
 function lookupNormalRect(arr, fallback) {
   return isNumberArray(arr, 4) ? Util.normalizeRect(arr) : fallback;
 }
-function parseXFAPath(path21) {
+function parseXFAPath(path22) {
   const positionPattern = /^(.+)\[(\d+)\]$/;
-  return path21.split(".").map((component) => {
+  return path22.split(".").map((component) => {
     const m = component.match(positionPattern);
     return m ? {
       name: m[1],
@@ -3494,8 +3494,8 @@ function compilePatternInfo(ir2) {
   }
   return buffer;
 }
-function compileFontPathInfo(path21) {
-  return path21.slice().buffer;
+function compileFontPathInfo(path22) {
+  return path22.slice().buffer;
 }
 function getFloat214(view, offset) {
   return view.getInt16(offset) / 16384;
@@ -4730,11 +4730,11 @@ function createCmapTable(charCodeToGlyphId, toUnicodeExtraMap, numGlyphs) {
   }
   return table.data;
 }
-function validateOS2Table(os2, file) {
-  file.pos = (file.start || 0) + os2.offset;
+function validateOS2Table(os22, file) {
+  file.pos = (file.start || 0) + os22.offset;
   const version2 = file.getUint16();
   const minLength = [78, 86, 96, 96, 96, 100][version2];
-  if (minLength === void 0 || os2.length < minLength) {
+  if (minLength === void 0 || os22.length < minLength) {
     return false;
   }
   file.skip(60);
@@ -4752,7 +4752,7 @@ function validateOS2Table(os2, file) {
   if (usWinAscent === 0) {
     return false;
   }
-  os2.data[8] = os2.data[9] = 0;
+  os22.data[8] = os22.data[9] = 0;
   return true;
 }
 function createOS2Table(properties, charCodeToGlyphId, override2) {
@@ -4808,46 +4808,46 @@ function createOS2Table(properties, charCodeToGlyphId, override2) {
   }
   const winAscent = override2.yMax || typoAscent;
   const winDescent = -override2.yMin || -typoDescent;
-  const os2 = new DataBuilder({
+  const os22 = new DataBuilder({
     exactLength: 96
   });
-  os2.setArray([0, 3]);
-  os2.setArray([2, 36]);
-  os2.setArray([1, 244]);
-  os2.setArray([0, 5]);
-  os2.skip(2);
-  os2.setArray([2, 138]);
-  os2.setArray([2, 187]);
-  os2.skip(2);
-  os2.setArray([0, 140]);
-  os2.setArray([2, 138]);
-  os2.setArray([2, 187]);
-  os2.skip(2);
-  os2.setArray([1, 223]);
-  os2.setArray([0, 49]);
-  os2.setArray([1, 2]);
-  os2.skip(2);
-  os2.setArray([0, 0, 6, properties.fixedPitch ? 9 : 0, 0, 0, 0, 0, 0, 0]);
-  os2.setInt32(ulUnicodeRange1);
-  os2.setInt32(ulUnicodeRange2);
-  os2.setInt32(ulUnicodeRange3);
-  os2.setInt32(ulUnicodeRange4);
-  os2.setArray([42, 50, 49, 42]);
-  os2.setInt16(properties.italicAngle ? 1 : 0);
-  os2.setInt16(firstCharIndex || properties.firstChar);
-  os2.setInt16(lastCharIndex || properties.lastChar);
-  os2.setInt16(typoAscent);
-  os2.setInt16(typoDescent);
-  os2.setArray([0, 100]);
-  os2.setInt16(winAscent);
-  os2.setInt16(winDescent);
-  os2.skip(4 + 4);
-  os2.setInt16(properties.xHeight);
-  os2.setInt16(properties.capHeight);
-  os2.skip(2);
-  os2.setInt16(firstCharIndex || properties.firstChar);
-  os2.setArray([0, 3]);
-  return os2.data;
+  os22.setArray([0, 3]);
+  os22.setArray([2, 36]);
+  os22.setArray([1, 244]);
+  os22.setArray([0, 5]);
+  os22.skip(2);
+  os22.setArray([2, 138]);
+  os22.setArray([2, 187]);
+  os22.skip(2);
+  os22.setArray([0, 140]);
+  os22.setArray([2, 138]);
+  os22.setArray([2, 187]);
+  os22.skip(2);
+  os22.setArray([1, 223]);
+  os22.setArray([0, 49]);
+  os22.setArray([1, 2]);
+  os22.skip(2);
+  os22.setArray([0, 0, 6, properties.fixedPitch ? 9 : 0, 0, 0, 0, 0, 0, 0]);
+  os22.setInt32(ulUnicodeRange1);
+  os22.setInt32(ulUnicodeRange2);
+  os22.setInt32(ulUnicodeRange3);
+  os22.setInt32(ulUnicodeRange4);
+  os22.setArray([42, 50, 49, 42]);
+  os22.setInt16(properties.italicAngle ? 1 : 0);
+  os22.setInt16(firstCharIndex || properties.firstChar);
+  os22.setInt16(lastCharIndex || properties.lastChar);
+  os22.setInt16(typoAscent);
+  os22.setInt16(typoDescent);
+  os22.setArray([0, 100]);
+  os22.setInt16(winAscent);
+  os22.setInt16(winDescent);
+  os22.skip(4 + 4);
+  os22.setInt16(properties.xHeight);
+  os22.setInt16(properties.capHeight);
+  os22.skip(2);
+  os22.setInt16(firstCharIndex || properties.firstChar);
+  os22.setArray([0, 3]);
+  return os22.data;
 }
 function createPostTable(properties) {
   const post = new DataBuilder({
@@ -5634,7 +5634,7 @@ function getFamilyName(str2) {
 function generateFont({
   alias,
   local,
-  path: path21,
+  path: path22,
   fallback,
   style,
   ultimate
@@ -5652,7 +5652,7 @@ function generateFont({
   if (alias) {
     const substitution = substitutionMap.get(alias);
     const aliasAppend = append || getStyleToAppend(style);
-    Object.assign(result, generateFont(substitution, src, localFontPath, useFallback && !fallback, usePath && !path21, aliasAppend));
+    Object.assign(result, generateFont(substitution, src, localFontPath, useFallback && !fallback, usePath && !path22, aliasAppend));
   }
   if (style) {
     result.style = style;
@@ -5664,11 +5664,11 @@ function generateFont({
     const fallbackInfo = substitutionMap.get(fallback);
     const {
       ultimate: fallbackUltimate
-    } = generateFont(fallbackInfo, src, localFontPath, useFallback, usePath && !path21, append);
+    } = generateFont(fallbackInfo, src, localFontPath, useFallback, usePath && !path22, append);
     result.ultimate ||= fallbackUltimate;
   }
-  if (usePath && path21 && localFontPath) {
-    src.push(`url(${localFontPath}${path21})`);
+  if (usePath && path22 && localFontPath) {
+    src.push(`url(${localFontPath}${path22})`);
   }
   return result;
 }
@@ -8089,13 +8089,13 @@ function writeXFADataForAcroform(str2, changes) {
       continue;
     }
     const {
-      path: path21,
+      path: path22,
       value
     } = xfa;
-    if (!path21 || value === null) {
+    if (!path22 || value === null) {
       continue;
     }
-    const nodePath = parseXFAPath(path21);
+    const nodePath = parseXFAPath(path22);
     let node2 = xml.documentElement.searchNode(nodePath, 0);
     if (!node2 && nodePath.length > 1) {
       node2 = xml.documentElement.searchNode([nodePath.at(-1)], 0);
@@ -8103,7 +8103,7 @@ function writeXFADataForAcroform(str2, changes) {
     if (node2) {
       node2.childNodes = Array.isArray(value) ? value.map((val) => new SimpleDOMNode("value", val)) : [new SimpleDOMNode("#text", value)];
     } else {
-      warn(`Node not found for path: ${path21}`);
+      warn(`Node not found for path: ${path22}`);
     }
   }
   const buffer = [];
@@ -29428,7 +29428,7 @@ var init_pdf_worker = __esm({
         if (this.#compiledGlyphs.has(glyphId) && this.#compiledCharCodes.has(charCode)) {
           return null;
         }
-        const path21 = this.#compiledGlyphs.getOrInsertComputed(glyphId, () => {
+        const path22 = this.#compiledGlyphs.getOrInsertComputed(glyphId, () => {
           try {
             return this.compileGlyph(this.glyphs[glyphId], glyphId);
           } catch (ex) {
@@ -29436,10 +29436,10 @@ var init_pdf_worker = __esm({
           }
         });
         this.#compiledCharCodes.add(charCode);
-        if (path21 instanceof Error) {
-          throw path21;
+        if (path22 instanceof Error) {
+          throw path22;
         }
-        return compileFontPathInfo(path21);
+        return compileFontPathInfo(path22);
       }
       compileGlyph(code3, glyphId) {
         if (!code3?.length || code3[0] === 14) {
@@ -47755,12 +47755,12 @@ var init_pdf_worker = __esm({
       get isXFAObjectArray() {
         return false;
       }
-      createNodes(path21) {
+      createNodes(path22) {
         let root2 = this, node2 = null;
         for (const {
           name,
           index: index4
-        } of path21) {
+        } of path22) {
           for (let i2 = 0, ii = isFinite(index4) ? index4 : 0; i2 <= ii; i2++) {
             const nsId = root2[$namespaceId] === NS_DATASETS ? -1 : root2[$namespaceId];
             node2 = new XmlObject(nsId, name);
@@ -57420,10 +57420,10 @@ var init_pdf_worker = __esm({
         });
         data.defaultFieldValue = this._decodeFormValue(defaultFieldValue);
         if (fieldValue === void 0 && annotationGlobals.xfaDatasets) {
-          const path21 = this._title.str;
-          if (path21) {
+          const path22 = this._title.str;
+          if (path22) {
             this._hasValueFromXFA = true;
-            data.fieldValue = fieldValue = annotationGlobals.xfaDatasets.getValue(path21);
+            data.fieldValue = fieldValue = annotationGlobals.xfaDatasets.getValue(path22);
           }
         }
         if (fieldValue === void 0 && data.defaultFieldValue !== null) {
@@ -60209,11 +60209,11 @@ var init_pdf_worker = __esm({
           this.node = parser2.node;
         }
       }
-      getValue(path21) {
-        if (!this.node || !path21) {
+      getValue(path22) {
+        if (!this.node || !path22) {
           return "";
         }
-        const node2 = this.node.searchNode(parseXFAPath(path21), 0);
+        const node2 = this.node.searchNode(parseXFAPath(path22), 0);
         if (!node2) {
           return "";
         }
@@ -67974,33 +67974,33 @@ function renderRichText({
   container.append(fragment);
 }
 function makePathFromDrawOPS(data) {
-  const path21 = new Path2D();
+  const path22 = new Path2D();
   if (!data) {
-    return path21;
+    return path22;
   }
   for (let i2 = 0, ii = data.length; i2 < ii; ) {
     switch (data[i2++]) {
       case DrawOPS2.moveTo:
-        path21.moveTo(data[i2++], data[i2++]);
+        path22.moveTo(data[i2++], data[i2++]);
         break;
       case DrawOPS2.lineTo:
-        path21.lineTo(data[i2++], data[i2++]);
+        path22.lineTo(data[i2++], data[i2++]);
         break;
       case DrawOPS2.curveTo:
-        path21.bezierCurveTo(data[i2++], data[i2++], data[i2++], data[i2++], data[i2++], data[i2++]);
+        path22.bezierCurveTo(data[i2++], data[i2++], data[i2++], data[i2++], data[i2++], data[i2++]);
         break;
       case DrawOPS2.quadraticCurveTo:
-        path21.quadraticCurveTo(data[i2++], data[i2++], data[i2++], data[i2++]);
+        path22.quadraticCurveTo(data[i2++], data[i2++], data[i2++], data[i2++]);
         break;
       case DrawOPS2.closePath:
-        path21.closePath();
+        path22.closePath();
         break;
       default:
         warn2(`Unrecognized drawing path operator: ${data[i2 - 1]}`);
         break;
     }
   }
-  return path21;
+  return path22;
 }
 function bindEvents(obj, element, names2) {
   for (const name of names2) {
@@ -68155,8 +68155,8 @@ function blend(fg, bg, alpha) {
   return Math.round(alpha * fg + (1 - alpha) * bg);
 }
 async function node_utils_fetchData(url) {
-  const fs19 = process.getBuiltinModule("fs/promises");
-  const data = await fs19.readFile(url);
+  const fs20 = process.getBuiltinModule("fs/promises");
+  const data = await fs20.readFile(url);
   return new Uint8Array(data);
 }
 function convertBlackAndWhiteToRGBA2({
@@ -68796,11 +68796,11 @@ function network_getArrayBuffer(val) {
   return typeof val !== "string" ? val : stringToBytes2(val).buffer;
 }
 function getReadableStream(url, opts = null) {
-  const fs19 = process.getBuiltinModule("fs");
+  const fs20 = process.getBuiltinModule("fs");
   const {
     Readable
   } = process.getBuiltinModule("stream");
-  const readStream = fs19.createReadStream(url, opts);
+  const readStream = fs20.createReadStream(url, opts);
   return Readable.toWeb(readStream);
 }
 function getNetworkStream(url) {
@@ -80614,9 +80614,9 @@ var init_pdf = __esm({
         return rule;
       }
       getPathGenerator(objs, character) {
-        let path21 = this.#compiledPaths.get(character);
-        if (path21) {
-          return path21;
+        let path22 = this.#compiledPaths.get(character);
+        if (path22) {
+          return path22;
         }
         const objId = `${this.loadedName}_path_${character}`;
         let cmds;
@@ -80625,12 +80625,12 @@ var init_pdf = __esm({
         } catch (ex) {
           warn2(`getPathGenerator - ignoring character: "${ex}".`);
         }
-        path21 = makePathFromDrawOPS(cmds?.path);
+        path22 = makePathFromDrawOPS(cmds?.path);
         if (!this.fontExtraProperties) {
           objs.delete(objId);
         }
-        this.#compiledPaths.set(character, path21);
-        return path21;
+        this.#compiledPaths.set(character, path22);
+        return path22;
       }
       get black() {
         return this.#fontData.black;
@@ -82453,7 +82453,7 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
         Util2.singularValueDecompose2dScale(this.baseTransform, scale);
         return [matrixScaleX * scale[0], matrixScaleY * scale[1]];
       }
-      drawPattern(owner, path21, useEOFill = false, [n, m], opIdx) {
+      drawPattern(owner, path22, useEOFill = false, [n, m], opIdx) {
         const [x0, y0, x1, y1] = this.bbox;
         const dependencyTracker = owner.dependencyTracker;
         if (dependencyTracker) {
@@ -82461,9 +82461,9 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
         }
         owner.save();
         if (useEOFill) {
-          owner.ctx.clip(path21, "evenodd");
+          owner.ctx.clip(path22, "evenodd");
         } else {
-          owner.ctx.clip(path21);
+          owner.ctx.clip(path22);
         }
         owner.ctx.setTransform(...this.patternBaseMatrix);
         owner.ctx.translate(n * this.xstep, m * this.ystep);
@@ -83622,15 +83622,15 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
         if (hasInnerCutout && maskX0 === layerOffsetX && maskY0 === layerOffsetY && maskX1 === layerOffsetX + layerWidth && maskY1 === layerOffsetY + layerHeight) {
           return;
         }
-        const path21 = new Path2D();
-        path21.rect(layerOffsetX, layerOffsetY, layerWidth, layerHeight);
+        const path22 = new Path2D();
+        path22.rect(layerOffsetX, layerOffsetY, layerWidth, layerHeight);
         if (hasInnerCutout) {
-          path21.rect(maskX0, maskY0, maskX1 - maskX0, maskY1 - maskY0);
+          path22.rect(maskX0, maskY0, maskX1 - maskX0, maskY1 - maskY0);
         }
         layerCtx.save();
         layerCtx.globalAlpha = alpha / 255;
         layerCtx.setTransform(1, 0, 0, 1, 0, 0);
-        layerCtx.clip(path21, "evenodd");
+        layerCtx.clip(path22, "evenodd");
         layerCtx.globalCompositeOperation = "destination-in";
         layerCtx.fillStyle = "#000000";
         layerCtx.fillRect(layerOffsetX, layerOffsetY, layerWidth, layerHeight);
@@ -83686,21 +83686,21 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
         this._cachedScaleForStroking[0] = -1;
       }
       constructPath(opIdx, op2, data, minMax) {
-        let [path21] = data;
+        let [path22] = data;
         if (!minMax) {
-          path21 ||= data[0] = new Path2D();
+          path22 ||= data[0] = new Path2D();
           if (op2 !== OPS2.stroke && op2 !== OPS2.closeStroke) {
             this.current.tilingPatternDims = null;
           }
-          this[op2](opIdx, path21);
+          this[op2](opIdx, path22);
           return;
         }
         if (this.dependencyTracker !== null) {
           const outerExtraSize = op2 === OPS2.stroke ? this.current.lineWidth / 2 : 0;
           this.dependencyTracker.resetBBox(opIdx).recordBBox(opIdx, this.ctx, minMax[0] - outerExtraSize, minMax[2] + outerExtraSize, minMax[1] - outerExtraSize, minMax[3] + outerExtraSize).recordDependencies(opIdx, ["transform"]);
         }
-        if (!(path21 instanceof Path2D)) {
-          path21 = data[0] = makePathFromDrawOPS(path21);
+        if (!(path22 instanceof Path2D)) {
+          path22 = data[0] = makePathFromDrawOPS(path22);
         }
         Util2.axialAlignedBoundingBox(minMax, getCurrentTransform(this.ctx), this.current.minMax);
         const tilingDims = this.current.tilingPatternDims;
@@ -83712,13 +83712,13 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
             this.current.fillColor.updatePatternDims(clippedBBox, tilingDims);
           }
         }
-        this[op2](opIdx, path21);
+        this[op2](opIdx, path22);
         this._pathStartIdx = opIdx;
       }
       closePath(opIdx) {
         this.ctx.closePath();
       }
-      stroke(opIdx, path21, consumePath = true) {
+      stroke(opIdx, path22, consumePath = true) {
         const started = consumePath && this.#beginKnockoutElement(this.current.strokeAlpha);
         const ctx = this.ctx;
         const strokeColor = this.current.strokeColor;
@@ -83730,26 +83730,26 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
             ctx.strokeStyle = strokeColor.getPattern(ctx, this, getCurrentTransformInverse(ctx), PathType.STROKE, opIdx);
             if (baseTransform) {
               const newPath = new Path2D();
-              newPath.addPath(path21, ctx.getTransform().invertSelf().multiplySelf(baseTransform));
-              path21 = newPath;
+              newPath.addPath(path22, ctx.getTransform().invertSelf().multiplySelf(baseTransform));
+              path22 = newPath;
             }
-            this.rescaleAndStroke(path21, false);
+            this.rescaleAndStroke(path22, false);
             ctx.restore();
           } else {
-            this.rescaleAndStroke(path21, true);
+            this.rescaleAndStroke(path22, true);
           }
         }
         this.dependencyTracker?.recordDependencies(opIdx, Dependencies.stroke);
         if (consumePath) {
-          this.consumePath(opIdx, path21, this.current.getClippedPathBoundingBox(PathType.STROKE, getCurrentTransform(this.ctx)));
+          this.consumePath(opIdx, path22, this.current.getClippedPathBoundingBox(PathType.STROKE, getCurrentTransform(this.ctx)));
         }
         ctx.globalAlpha = this.current.fillAlpha;
         this.#endKnockoutElement(started);
       }
-      closeStroke(opIdx, path21) {
-        this.stroke(opIdx, path21);
+      closeStroke(opIdx, path22) {
+        this.stroke(opIdx, path22);
       }
-      fill(opIdx, path21, consumePath = true) {
+      fill(opIdx, path22, consumePath = true) {
         const started = consumePath && this.#beginKnockoutElement(this.current.fillAlpha);
         const ctx = this.ctx;
         const fillColor = this.current.fillColor;
@@ -83761,10 +83761,10 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
           const dims = this.current.tilingPatternDims;
           const tileIdx = dims && fillColor.canSkipPatternCanvas(dims);
           if (tileIdx) {
-            fillColor.drawPattern(this, path21, this.pendingEOFill, tileIdx, opIdx);
+            fillColor.drawPattern(this, path22, this.pendingEOFill, tileIdx, opIdx);
             this.pendingEOFill = false;
             if (consumePath) {
-              this.consumePath(opIdx, path21, intersect);
+              this.consumePath(opIdx, path22, intersect);
             }
             this.current.tilingPatternDims = null;
             this.#endKnockoutElement(started);
@@ -83776,17 +83776,17 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
           ctx.fillStyle = fillColor.getPattern(ctx, this, getCurrentTransformInverse(ctx), PathType.FILL, opIdx);
           if (baseTransform) {
             const newPath = new Path2D();
-            newPath.addPath(path21, ctx.getTransform().invertSelf().multiplySelf(baseTransform));
-            path21 = newPath;
+            newPath.addPath(path22, ctx.getTransform().invertSelf().multiplySelf(baseTransform));
+            path22 = newPath;
           }
           needRestore = true;
         }
         if (this.contentVisible && intersect !== null) {
           if (this.pendingEOFill) {
-            ctx.fill(path21, "evenodd");
+            ctx.fill(path22, "evenodd");
             this.pendingEOFill = false;
           } else {
-            ctx.fill(path21);
+            ctx.fill(path22);
           }
         }
         if (needRestore) {
@@ -83794,38 +83794,38 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
           this.dependencyTracker?.restore(opIdx);
         }
         if (consumePath) {
-          this.consumePath(opIdx, path21, intersect);
+          this.consumePath(opIdx, path22, intersect);
         }
         this.#endKnockoutElement(started);
       }
-      eoFill(opIdx, path21) {
+      eoFill(opIdx, path22) {
         this.pendingEOFill = true;
-        this.fill(opIdx, path21);
+        this.fill(opIdx, path22);
       }
-      fillStroke(opIdx, path21) {
+      fillStroke(opIdx, path22) {
         const started = this.#beginKnockoutElement(Math.min(this.current.fillAlpha, this.current.strokeAlpha));
-        this.fill(opIdx, path21, false);
-        this.stroke(opIdx, path21, false);
-        this.consumePath(opIdx, path21);
+        this.fill(opIdx, path22, false);
+        this.stroke(opIdx, path22, false);
+        this.consumePath(opIdx, path22);
         this.#endKnockoutElement(started);
       }
-      eoFillStroke(opIdx, path21) {
+      eoFillStroke(opIdx, path22) {
         this.pendingEOFill = true;
-        this.fillStroke(opIdx, path21);
+        this.fillStroke(opIdx, path22);
       }
-      closeFillStroke(opIdx, path21) {
-        this.fillStroke(opIdx, path21);
+      closeFillStroke(opIdx, path22) {
+        this.fillStroke(opIdx, path22);
       }
-      closeEOFillStroke(opIdx, path21) {
+      closeEOFillStroke(opIdx, path22) {
         this.pendingEOFill = true;
-        this.fillStroke(opIdx, path21);
+        this.fillStroke(opIdx, path22);
       }
-      endPath(opIdx, path21) {
-        this.consumePath(opIdx, path21);
+      endPath(opIdx, path22) {
+        this.consumePath(opIdx, path22);
       }
-      rawFillPath(opIdx, path21) {
+      rawFillPath(opIdx, path22) {
         const started = this.#beginKnockoutElement(this.current.fillAlpha);
-        this.ctx.fill(path21);
+        this.ctx.fill(path22);
         this.dependencyTracker?.recordDependencies(opIdx, Dependencies.rawFillPath).recordOperation(opIdx);
         this.#endKnockoutElement(started);
       }
@@ -83864,12 +83864,12 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
             x,
             y,
             fontSize,
-            path: path21
+            path: path22
           } of paths) {
-            if (!path21) {
+            if (!path22) {
               continue;
             }
-            newPath.addPath(path21, new DOMMatrix(transform).preMultiplySelf(invTransf).translate(x, y).scale(fontSize, -fontSize));
+            newPath.addPath(path22, new DOMMatrix(transform).preMultiplySelf(invTransf).translate(x, y).scale(fontSize, -fontSize));
           }
           ctx.clip(newPath);
         }
@@ -83957,9 +83957,9 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
         this.moveText(opIdx, 0, this.current.leading);
         this.dependencyTracker?.recordIncrementalData("moveText", this.dependencyTracker.getSimpleIndex("leading") ?? opIdx);
       }
-      #getScaledPath(path21, currentTransform, transform) {
+      #getScaledPath(path22, currentTransform, transform) {
         const newPath = new Path2D();
-        newPath.addPath(path21, new DOMMatrix(transform).invertSelf().multiplySelf(currentTransform));
+        newPath.addPath(path22, new DOMMatrix(transform).invertSelf().multiplySelf(currentTransform));
         return newPath;
       }
       paintChar(opIdx, character, x, y, patternFillTransform, patternStrokeTransform) {
@@ -83972,11 +83972,11 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
         const isAddToPathSet = !!(textRenderingMode & TextRenderingMode2.ADD_TO_PATH_FLAG);
         const patternFill = current.patternFill && !font.missingFile;
         const patternStroke = current.patternStroke && !font.missingFile;
-        let path21;
+        let path22;
         if ((font.disableFontFace || isAddToPathSet || patternFill || patternStroke) && !font.missingFile) {
-          path21 = font.getPathGenerator(this.commonObjs, character);
+          path22 = font.getPathGenerator(this.commonObjs, character);
         }
-        if (path21 && (font.disableFontFace || patternFill || patternStroke)) {
+        if (path22 && (font.disableFontFace || patternFill || patternStroke)) {
           ctx.save();
           ctx.translate(x, y);
           ctx.scale(fontSize, -fontSize);
@@ -83986,10 +83986,10 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
             if (patternFillTransform) {
               currentTransform = ctx.getTransform();
               ctx.setTransform(...patternFillTransform);
-              const scaledPath = this.#getScaledPath(path21, currentTransform, patternFillTransform);
+              const scaledPath = this.#getScaledPath(path22, currentTransform, patternFillTransform);
               ctx.fill(scaledPath);
             } else {
-              ctx.fill(path21);
+              ctx.fill(path22);
             }
           }
           if (fillStrokeMode === TextRenderingMode2.STROKE || fillStrokeMode === TextRenderingMode2.FILL_STROKE) {
@@ -84006,10 +84006,10 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
               const transf = Util2.transform([a, b, c, d, 0, 0], invPatternTransform);
               Util2.singularValueDecompose2dScale(transf, XY);
               ctx.lineWidth *= Math.max(XY[0], XY[1]) / fontSize;
-              ctx.stroke(this.#getScaledPath(path21, currentTransform, patternStrokeTransform));
+              ctx.stroke(this.#getScaledPath(path22, currentTransform, patternStrokeTransform));
             } else {
               ctx.lineWidth /= fontSize;
-              ctx.stroke(path21);
+              ctx.stroke(path22);
             }
           }
           ctx.restore();
@@ -84032,7 +84032,7 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
             x,
             y,
             fontSize,
-            path: path21
+            path: path22
           });
           this.dependencyTracker?.recordCharacterBBox(opIdx, ctx, font, fontSize, x, y);
         }
@@ -84425,9 +84425,9 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
             const [x0, y0, x1, y1] = group.bbox;
             clip.rect(x0, y0, x1 - x0, y1 - y0);
             if (group.matrix) {
-              const path21 = new Path2D();
-              path21.addPath(clip, new DOMMatrix(group.matrix));
-              clip = path21;
+              const path22 = new Path2D();
+              path22.addPath(clip, new DOMMatrix(group.matrix));
+              clip = path22;
             }
             currentCtx.clip(clip);
           }
@@ -84486,9 +84486,9 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
           const [x0, y0, x1, y1] = group.bbox;
           clip.rect(x0, y0, x1 - x0, y1 - y0);
           if (group.matrix) {
-            const path21 = new Path2D();
-            path21.addPath(clip, new DOMMatrix(group.matrix));
-            clip = path21;
+            const path22 = new Path2D();
+            path22.addPath(clip, new DOMMatrix(group.matrix));
+            clip = path22;
           }
           groupCtx.clip(clip);
         }
@@ -85023,7 +85023,7 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
       }
       endCompat(opIdx) {
       }
-      consumePath(opIdx, path21, clipBox) {
+      consumePath(opIdx, path22, clipBox) {
         const isEmpty = this.current.isEmptyClip();
         if (this.pendingClip) {
           this.current.updateClipFromPath();
@@ -85035,9 +85035,9 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
         if (this.pendingClip) {
           if (!isEmpty) {
             if (this.pendingClip === EO_CLIP) {
-              ctx.clip(path21, "evenodd");
+              ctx.clip(path22, "evenodd");
             } else {
-              ctx.clip(path21);
+              ctx.clip(path22);
             }
           }
           this.pendingClip = null;
@@ -85106,7 +85106,7 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
         }
         return this._cachedScaleForStroking;
       }
-      rescaleAndStroke(path21, saveRestore) {
+      rescaleAndStroke(path22, saveRestore) {
         const {
           ctx,
           current: {
@@ -85116,7 +85116,7 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
         const [scaleX, scaleY] = this.getScaleForStroking();
         if (scaleX === scaleY) {
           ctx.lineWidth = (lineWidth || 1) * scaleX;
-          ctx.stroke(path21);
+          ctx.stroke(path22);
           return;
         }
         const SCALE_MATRIX = _CanvasGraphics.#SCALE_MATRIX ??= new DOMMatrix();
@@ -85128,7 +85128,7 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
         SCALE_MATRIX.a = 1 / scaleX;
         SCALE_MATRIX.d = 1 / scaleY;
         const newPath = new Path2D();
-        newPath.addPath(path21, SCALE_MATRIX);
+        newPath.addPath(path22, SCALE_MATRIX);
         if (dashes.length > 0) {
           const scale = Math.max(scaleX, scaleY);
           ctx.setLineDash(dashes.map((x) => x / scale));
@@ -85852,8 +85852,8 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
           url
         } = stream._source;
         this._isStreamingSupported = !disableStream;
-        const fs19 = process.getBuiltinModule("fs/promises");
-        fs19.lstat(url).then((stat) => {
+        const fs20 = process.getBuiltinModule("fs/promises");
+        fs20.lstat(url).then((stat) => {
           const readableStream = getReadableStream(url);
           this._reader = readableStream.getReader();
           const {
@@ -96324,11 +96324,11 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
     };
     ContourDrawOutline = class extends InkDrawOutline {
       toSVGPath() {
-        let path21 = super.toSVGPath();
-        if (!path21.endsWith("Z")) {
-          path21 += "Z";
+        let path22 = super.toSVGPath();
+        if (!path22.endsWith("Z")) {
+          path22 += "Z";
         }
-        return path21;
+        return path22;
       }
     };
     es_uint8_array_from_base64_namespaceFn2();
@@ -99010,7 +99010,7 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
           }
           const drawLayer = textLayerData.drawLayer;
           let div = textLayerData.selectionDiv;
-          let path21 = textLayerData.path;
+          let path22 = textLayerData.path;
           if (!div) {
             const clipPathId = `clip_selection_${_DrawLayer.#selectionId++}`;
             div = document.createElement("div");
@@ -99029,18 +99029,18 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
             const clipPath = _DrawLayer._svgFactory.createElement("clipPath");
             clipPath.setAttribute("id", clipPathId);
             clipPath.setAttribute("clipPathUnits", "objectBoundingBox");
-            path21 = _DrawLayer._svgFactory.createElement("path");
-            clipPath.append(path21);
+            path22 = _DrawLayer._svgFactory.createElement("path");
+            clipPath.append(path22);
             svg.append(clipPath);
             div.append(svg);
-            textLayerData.path = path21;
+            textLayerData.path = path22;
             textLayerData.selectionDiv = div;
           }
           if (drawLayer.#parent && div.parentNode !== drawLayer.#parent) {
             drawLayer.#parent.append(div);
             this.#selections.add(div);
           }
-          path21.setAttribute("d", boxes.join(" "));
+          path22.setAttribute("d", boxes.join(" "));
         }
       }
       static get _svgFactory() {
@@ -99087,13 +99087,13 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
         const root2 = this.#createSVG();
         const defs = _DrawLayer._svgFactory.createElement("defs");
         root2.append(defs);
-        const path21 = _DrawLayer._svgFactory.createElement("path");
-        defs.append(path21);
+        const path22 = _DrawLayer._svgFactory.createElement("path");
+        defs.append(path22);
         const pathId = `path_${id}`;
-        path21.setAttribute("id", pathId);
-        path21.setAttribute("vector-effect", "non-scaling-stroke");
+        path22.setAttribute("id", pathId);
+        path22.setAttribute("vector-effect", "non-scaling-stroke");
         if (isPathUpdatable) {
-          this.#toUpdate.set(id, path21);
+          this.#toUpdate.set(id, path22);
         }
         const clipPathId = hasClip ? this.#createClipPath(defs, pathId) : null;
         const use = _DrawLayer._svgFactory.createElement("use");
@@ -99111,11 +99111,11 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
         const root2 = this.#createSVG();
         const defs = _DrawLayer._svgFactory.createElement("defs");
         root2.append(defs);
-        const path21 = _DrawLayer._svgFactory.createElement("path");
-        defs.append(path21);
+        const path22 = _DrawLayer._svgFactory.createElement("path");
+        defs.append(path22);
         const pathId = `path_${id}`;
-        path21.setAttribute("id", pathId);
-        path21.setAttribute("vector-effect", "non-scaling-stroke");
+        path22.setAttribute("id", pathId);
+        path22.setAttribute("vector-effect", "non-scaling-stroke");
         let maskId;
         if (mustRemoveSelfIntersections) {
           const mask = _DrawLayer._svgFactory.createElement("mask");
@@ -99162,7 +99162,7 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
           root: root2,
           bbox,
           rootClass,
-          path: path21
+          path: path22
         } = properties;
         const element = typeof elementOrId === "number" ? this.#mapping.get(elementOrId) : elementOrId;
         if (!element) {
@@ -99182,10 +99182,10 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
             classList.toggle(className, value);
           }
         }
-        if (path21) {
+        if (path22) {
           const defs = element.firstElementChild;
           const pathElement = defs.firstElementChild;
-          this.#updateProperties(pathElement, path21);
+          this.#updateProperties(pathElement, path22);
         }
       }
       updateParent(id, layer) {
@@ -99492,11 +99492,11 @@ var require_extend = __commonJS({
 });
 
 // ../server/src/piOutpostTools.ts
-import fs18 from "node:fs/promises";
+import fs19 from "node:fs/promises";
 
 // ../server/src/docxTool.ts
-import fs16 from "node:fs/promises";
-import path19 from "node:path";
+import fs17 from "node:fs/promises";
+import path20 from "node:path";
 
 // ../node_modules/typebox/build/system/memory/memory.mjs
 var memory_exports = {};
@@ -104621,16 +104621,21 @@ function renderSpans(spans) {
   for (const span of spans) {
     if (span.text === "") continue;
     const last = merged[merged.length - 1];
-    if (last !== void 0 && last.format === span.format) last.text += span.text;
-    else merged.push({ text: span.text, format: span.format });
+    if (last !== void 0 && mergeable(last, span)) last.text += span.text;
+    else merged.push({ ...span });
   }
   return merged.map((span) => {
-    if (span.format === 0) return span.text;
+    if (span.raw === true || span.format === 0 && span.revision === void 0) return span.text;
     const match = /^(\s*)([\s\S]*?)(\s*)$/.exec(span.text);
     if (match === null || match[2] === "") return span.text;
-    return match[1] + wrapSpan(match[2], span.format) + match[3];
+    const formatted = wrapSpan(match[2], span.format);
+    const wrapped = span.revision === void 0 ? formatted : span.revision.open + formatted + span.revision.close;
+    return match[1] + wrapped + match[3];
   }).join("");
 }
+function mergeable(a, b) {
+  return a.raw !== true && b.raw !== true && a.format === b.format && a.revision?.open === b.revision?.open && a.revision?.close === b.revision?.close;
+}
 function countStruckSpans(markdown) {
   return Math.floor((markdown.match(/~~/g)?.length ?? 0) / 2);
 }
@@ -104978,6 +104983,8 @@ var MAX_ZIP_ENTRIES = 512;
 var MAX_PART_BYTES = 64 * 1024 * 1024;
 var MAX_PARSED_BLOCKS = 5e4;
 var DOCUMENT_PART = "word/document.xml";
+var COMMENTS_PART = "word/comments.xml";
+var COMMENTS_EXTENDED_PART = "word/commentsExtended.xml";
 var CONTENT_TYPES = "[Content_Types].xml";
 var OLE_MAGIC = Buffer.from([208, 207, 17, 224]);
 function toggleOn(value) {
@@ -104996,20 +105003,44 @@ function headingLevel(styleId, outlineLevel) {
   }
   return void 0;
 }
-function parseBody(xml, deadline, pictureMarkerFor) {
+var sentinel = (payload) => `
${payload}`;
+var INSERT_OPEN = sentinel("I");
+var INSERT_CLOSE = sentinel("i");
+var DELETE_OPEN = sentinel("D");
+var DELETE_CLOSE = sentinel("d");
+var ANCHOR_OPEN = sentinel("H");
+var ANCHOR_CLOSE = sentinel("h");
+var referenceSentinel = (id) => sentinel(`R${id}`);
+var CHANGE_RECORD = /^w:\w+(?:Pr|PrEx|Grid)Change$/;
+var REVISION_PRECEDENCE = ["del", "moveFrom", "moveTo", "ins"];
+function parseBody(xml, deadline, pictureMarkerFor, review) {
   const blocks = [];
+  const show = review?.show === true;
   let paragraph2 = [];
   let paragraphHeading;
   let styleId;
   let outlineLevel;
+  let paragraphDepth = 0;
   let tableDepth = 0;
   let rows = [];
   let row = [];
   let cell = [];
   let inCell = false;
-  let deletionDepth = 0;
+  let rowPropertiesDepth = 0;
+  let rowDeleted = false;
+  let rowRevision;
   let textTarget = null;
+  let textRevision;
   let events = 0;
+  let changeRecordDepth = 0;
+  const revisions = [];
+  let revisionSerial = 0;
+  let moveFromName;
+  let moveToName;
+  let group;
+  let groupSerial = 0;
+  const openComments = /* @__PURE__ */ new Set();
+  const rangedComments = /* @__PURE__ */ new Set();
   let runFormat = 0;
   let runPropertiesDepth = 0;
   let paragraphPropertiesDepth = 0;
@@ -105022,24 +105053,185 @@ function parseBody(xml, deadline, pictureMarkerFor) {
     if (toggleOn(value)) runFormat |= flag;
     else runFormat &= ~flag;
   };
+  const target = () => inCell ? cell : paragraph2;
+  const blockNumber = () => blocks.length + 1;
+  const effectiveRevision = () => {
+    if (rowRevision?.kind === "del") return rowRevision;
+    let found;
+    search: for (const kind of REVISION_PRECEDENCE) {
+      for (let index4 = revisions.length - 1; index4 >= 0; index4--) {
+        if (revisions[index4].kind === kind) {
+          found = revisions[index4];
+          break search;
+        }
+      }
+    }
+    return found?.kind === "ins" && rowRevision !== void 0 ? rowRevision : found;
+  };
+  const removes = (revision) => revision?.kind === "del" || revision?.kind === "moveFrom";
+  const referenceFor = (layer, revision) => {
+    let id;
+    if (revision.row !== void 0) {
+      revision.row.id ??= `r:${++groupSerial}`;
+      id = revision.row.id;
+      group = void 0;
+    } else if (revision.kind === "moveFrom" || revision.kind === "moveTo") {
+      id = revision.name !== void 0 ? `m:${revision.name}` : `m:#${revision.serial}`;
+      group = void 0;
+    } else {
+      const key = `${revision.kind}\0${revision.author ?? ""}\0${revision.date ?? ""}`;
+      if (group === void 0 || group.key !== key) group = { key, id: `r:${++groupSerial}` };
+      id = group.id;
+    }
+    if (!layer.entries.has(id)) {
+      layer.entries.set(id, {
+        kind: revision.kind === "ins" ? "insertion" : revision.kind === "del" ? "deletion" : "move",
+        ...revision.author !== void 0 ? { author: revision.author } : {},
+        ...revision.date !== void 0 ? { date: revision.date } : {},
+        visible: false,
+        ...revision.row !== void 0 ? { row: true } : {}
+      });
+    }
+    return id;
+  };
+  const note = (text7, revision) => {
+    if (review === void 0) return void 0;
+    if (revision === void 0) {
+      if (text7 !== "") group = void 0;
+      return void 0;
+    }
+    const id = referenceFor(review, revision);
+    const entry = review.entries.get(id);
+    if (/\S/.test(text7)) {
+      entry.visible = true;
+      if (revision.kind === "moveTo") entry.toBlock ??= blockNumber();
+      else entry.block ??= blockNumber();
+    }
+    return removes(revision) ? { open: DELETE_OPEN, close: DELETE_CLOSE + referenceSentinel(id) } : { open: INSERT_OPEN, close: INSERT_CLOSE + referenceSentinel(id) };
+  };
+  const emit = (raw, revision) => {
+    const text7 = show ? raw.replace(/[\u0001\u0002]/g, "") : raw;
+    const markers = note(text7, revision);
+    target().push(show && markers !== void 0 ? { text: text7, format: runFormat, revision: markers } : { text: text7, format: runFormat });
+  };
+  const pushRaw = (text7) => target().push({ text: text7, format: 0, raw: true });
+  const noteComment = (layer, id) => {
+    const key = `c:${id}`;
+    const entry = layer.entries.get(key);
+    if (entry === void 0) layer.entries.set(key, { kind: "comment", visible: true, block: blockNumber() });
+  };
+  const appendToLastBlock = (text7) => {
+    const last = blocks[blocks.length - 1];
+    if (last === void 0) return;
+    if (last.kind === "paragraph") last.text += text7;
+    else {
+      const lastRow = last.rows[last.rows.length - 1];
+      if (lastRow !== void 0 && lastRow.length > 0) lastRow[lastRow.length - 1] += text7;
+    }
+  };
   const flushParagraph = () => {
     const text7 = renderSpans(paragraph2).replace(/\s+/g, " ").trim();
-    paragraph2 = [];
     const heading3 = paragraphHeading;
+    const plain = show && heading3 !== void 0 ? acceptedText(paragraph2) : void 0;
+    paragraph2 = [];
     paragraphHeading = void 0;
     styleId = void 0;
     outlineLevel = void 0;
     if (text7 === "") return;
-    blocks.push(heading3 === void 0 ? { kind: "paragraph", text: text7 } : { kind: "paragraph", text: text7, heading: heading3 });
+    blocks.push({
+      kind: "paragraph",
+      text: text7,
+      ...heading3 !== void 0 ? { heading: heading3 } : {},
+      ...plain !== void 0 ? { plain } : {}
+    });
   };
   scanXml(xml, (event) => {
     if (++events % 2e3 === 0) deadline?.();
     if (blocks.length > MAX_PARSED_BLOCKS) return false;
+    if (changeRecordDepth > 0) {
+      if (event.kind === "open" && !event.selfClosing && CHANGE_RECORD.test(event.name)) changeRecordDepth++;
+      else if (event.kind === "close" && CHANGE_RECORD.test(event.name)) changeRecordDepth--;
+      return;
+    }
     if (event.kind === "open") {
+      if (CHANGE_RECORD.test(event.name)) {
+        if (!event.selfClosing) changeRecordDepth = 1;
+        return;
+      }
       switch (event.name) {
+        case "w:ins":
         case "w:del":
-          deletionDepth++;
+        case "w:moveFrom":
+        case "w:moveTo": {
+          if (event.selfClosing) {
+            if (rowPropertiesDepth > 0 && (event.name === "w:del" || event.name === "w:ins")) {
+              if (event.name === "w:del") rowDeleted = true;
+              const author2 = event.attributes["w:author"];
+              const date2 = event.attributes["w:date"];
+              rowRevision = {
+                kind: event.name === "w:del" ? "del" : "ins",
+                ...author2 !== void 0 ? { author: author2 } : {},
+                ...date2 !== void 0 ? { date: date2 } : {},
+                row: {},
+                serial: ++revisionSerial
+              };
+              revisions.push(rowRevision);
+            }
+            return;
+          }
+          const kind = event.name.slice(2);
+          const author = event.attributes["w:author"];
+          const date = event.attributes["w:date"];
+          const name = kind === "moveFrom" ? moveFromName : kind === "moveTo" ? moveToName : void 0;
+          revisions.push({
+            kind,
+            ...author !== void 0 ? { author } : {},
+            ...date !== void 0 ? { date } : {},
+            ...name !== void 0 ? { name } : {},
+            serial: ++revisionSerial
+          });
           break;
+        }
+        case "w:moveFromRangeStart":
+          moveFromName = event.attributes["w:name"];
+          break;
+        case "w:moveToRangeStart":
+          moveToName = event.attributes["w:name"];
+          break;
+        case "w:moveFromRangeEnd":
+          moveFromName = void 0;
+          break;
+        case "w:moveToRangeEnd":
+          moveToName = void 0;
+          break;
+        case "w:commentRangeStart": {
+          const id = event.attributes["w:id"];
+          if (review === void 0 || id === void 0 || review.replies.has(id)) break;
+          rangedComments.add(id);
+          noteComment(review, id);
+          if (show && openComments.size === 0 && paragraphDepth > 0) pushRaw(ANCHOR_OPEN);
+          openComments.add(id);
+          break;
+        }
+        case "w:commentRangeEnd": {
+          const id = event.attributes["w:id"];
+          if (id === void 0 || !openComments.delete(id)) break;
+          if (!show) break;
+          if (paragraphDepth > 0) {
+            if (openComments.size === 0) pushRaw(ANCHOR_CLOSE);
+            pushRaw(referenceSentinel(`c:${id}`));
+          } else {
+            appendToLastBlock(referenceSentinel(`c:${id}`));
+          }
+          break;
+        }
+        case "w:commentReference": {
+          const id = event.attributes["w:id"];
+          if (review === void 0 || id === void 0 || review.replies.has(id) || rangedComments.has(id)) break;
+          noteComment(review, id);
+          if (show) pushRaw(referenceSentinel(`c:${id}`));
+          break;
+        }
         case "w:tbl":
           if (tableDepth === 0) {
             flushParagraph();
@@ -105048,7 +105240,13 @@ function parseBody(xml, deadline, pictureMarkerFor) {
           tableDepth++;
           break;
         case "w:tr":
-          if (tableDepth === 1) row = [];
+          if (tableDepth === 1) {
+            row = [];
+            rowDeleted = false;
+          }
+          break;
+        case "w:trPr":
+          if (tableDepth === 1) rowPropertiesDepth++;
           break;
         case "w:tc":
           if (tableDepth === 1) {
@@ -105057,10 +105255,12 @@ function parseBody(xml, deadline, pictureMarkerFor) {
           }
           break;
         case "w:p":
+          paragraphDepth++;
           if (!inCell) {
             paragraph2 = [];
             paragraphHeading = void 0;
           }
+          if (show && openComments.size > 0) pushRaw(ANCHOR_OPEN);
           break;
         case "w:pStyle":
           styleId = event.attributes["w:val"];
@@ -105088,8 +105288,17 @@ function parseBody(xml, deadline, pictureMarkerFor) {
           applyToggle(ITALIC, event.attributes["w:val"]);
           break;
         case "w:t":
-          if (deletionDepth === 0) textTarget = inCell ? "cell" : "paragraph";
+        case "w:delText": {
+          const revision = effectiveRevision();
+          if (removes(revision) ? show : event.name === "w:t") {
+            textTarget = inCell ? "cell" : "paragraph";
+            textRevision = revision;
+          } else if (removes(revision)) {
+            textTarget = "count";
+            textRevision = revision;
+          }
           break;
+        }
         case "w:drawing":
         case "w:pict":
           drawingDepth++;
@@ -105110,12 +105319,12 @@ function parseBody(xml, deadline, pictureMarkerFor) {
           if (drawingDepth > 0) pictureRel ??= event.attributes["r:id"];
           break;
         case "w:tab":
-          (inCell ? cell : paragraph2).push({ text: " ", format: runFormat });
-          break;
         case "w:br":
-        case "w:cr":
-          (inCell ? cell : paragraph2).push({ text: " ", format: runFormat });
+        case "w:cr": {
+          const revision = effectiveRevision();
+          if (!removes(revision) || show) emit(" ", revision);
           break;
+        }
         default:
           break;
       }
@@ -105123,8 +105332,8 @@ function parseBody(xml, deadline, pictureMarkerFor) {
       return;
     }
     if (event.kind === "text") {
-      if (textTarget === "paragraph") paragraph2.push({ text: event.text, format: runFormat });
-      else if (textTarget === "cell") cell.push({ text: event.text, format: runFormat });
+      if (textTarget === "count") note(event.text, textRevision);
+      else if (textTarget !== null) emit(event.text, textRevision);
       return;
     }
     closeElement(event.name);
@@ -105132,17 +105341,32 @@ function parseBody(xml, deadline, pictureMarkerFor) {
   function closeElement(name) {
     switch (name) {
       case "w:t":
+      case "w:delText":
         textTarget = null;
+        textRevision = void 0;
         break;
+      case "w:ins":
       case "w:del":
-        if (deletionDepth > 0) deletionDepth--;
+      case "w:moveFrom":
+      case "w:moveTo": {
+        const kind = name.slice(2);
+        for (let index4 = revisions.length - 1; index4 >= 0; index4--) {
+          if (revisions[index4].kind === kind) {
+            revisions.splice(index4, 1);
+            break;
+          }
+        }
         break;
+      }
       case "w:pPr":
         if (paragraphPropertiesDepth > 0) paragraphPropertiesDepth--;
         break;
       case "w:rPr":
         if (paragraphPropertiesDepth === 0 && runPropertiesDepth > 0) runPropertiesDepth--;
         break;
+      case "w:trPr":
+        if (rowPropertiesDepth > 0) rowPropertiesDepth--;
+        break;
       case "w:drawing":
       case "w:pict":
         if (drawingDepth > 0) drawingDepth--;
@@ -105164,6 +105388,9 @@ function parseBody(xml, deadline, pictureMarkerFor) {
         runFormat = 0;
         break;
       case "w:p":
+        if (paragraphDepth > 0) paragraphDepth--;
+        if (show && openComments.size > 0) pushRaw(ANCHOR_CLOSE);
+        group = void 0;
         if (inCell) cell.push({ text: " ", format: 0 });
         else {
           paragraphHeading = headingLevel(styleId, outlineLevel);
@@ -105177,7 +105404,11 @@ function parseBody(xml, deadline, pictureMarkerFor) {
         }
         break;
       case "w:tr":
-        if (tableDepth === 1) rows.push(row);
+        if (tableDepth === 1 && !(rowDeleted && !show)) rows.push(row);
+        if (tableDepth === 1 && rowRevision !== void 0) {
+          revisions.splice(revisions.indexOf(rowRevision), 1);
+          rowRevision = void 0;
+        }
         break;
       case "w:tbl":
         tableDepth--;
@@ -105198,6 +105429,182 @@ function parseBody(xml, deadline, pictureMarkerFor) {
   flushParagraph();
   return blocks;
 }
+function acceptedText(spans) {
+  return spans.filter((span) => span.raw !== true && span.revision?.open !== DELETE_OPEN).map((span) => span.text).join("").replace(/\s+/g, " ").trim();
+}
+function parseComments(commentsXml, extendedXml) {
+  const comments = /* @__PURE__ */ new Map();
+  if (commentsXml === void 0) return comments;
+  const lastParagraphOf = /* @__PURE__ */ new Map();
+  let current;
+  let text7 = "";
+  let inText = false;
+  let deletionDepth = 0;
+  scanXml(commentsXml, (event) => {
+    if (event.kind === "text") {
+      if (inText) text7 += event.text;
+      return;
+    }
+    const opening = event.kind === "open";
+    switch (event.name) {
+      case "w:comment":
+        if (opening && !event.selfClosing) {
+          const { "w:id": id, "w:author": author, "w:date": date } = event.attributes;
+          current = id === void 0 ? void 0 : { id, ...author ? { author } : {}, ...date ? { date } : {}, paragraphs: [] };
+        } else if (current !== void 0) {
+          const { paragraphs, ...rest } = current;
+          comments.set(current.id, { ...rest, text: paragraphs.filter((piece) => piece !== "").join(" / ") });
+          current = void 0;
+        }
+        break;
+      case "w:p":
+        if (opening) {
+          text7 = "";
+          const paraId = event.attributes["w14:paraId"];
+          if (current !== void 0 && paraId !== void 0) lastParagraphOf.set(current.id, paraId);
+        }
+        if (!opening || event.selfClosing) current?.paragraphs.push(text7.replace(/\s+/g, " ").trim());
+        break;
+      case "w:del":
+        if (opening && !event.selfClosing) deletionDepth++;
+        else if (!opening && deletionDepth > 0) deletionDepth--;
+        break;
+      case "w:t":
+        inText = opening && !event.selfClosing && deletionDepth === 0;
+        break;
+      case "w:tab":
+      case "w:br":
+        if (opening) text7 += " ";
+        break;
+      default:
+        break;
+    }
+  });
+  if (extendedXml === void 0) return comments;
+  const extended = /* @__PURE__ */ new Map();
+  scanXml(extendedXml, (event) => {
+    if (event.kind !== "open" || event.name !== "w15:commentEx") return;
+    const paraId = event.attributes["w15:paraId"];
+    if (paraId === void 0) return;
+    const parent = event.attributes["w15:paraIdParent"];
+    extended.set(paraId, { ...parent !== void 0 ? { parent } : {}, done: event.attributes["w15:done"] === "1" });
+  });
+  const byParagraph = new Map([...lastParagraphOf].map(([id, paraId]) => [paraId, id]));
+  for (const comment of comments.values()) {
+    const paraId = lastParagraphOf.get(comment.id);
+    const record = paraId === void 0 ? void 0 : extended.get(paraId);
+    if (record === void 0) continue;
+    comment.done = record.done;
+    if (record.parent !== void 0) {
+      const parentId = byParagraph.get(record.parent);
+      if (parentId !== void 0 && parentId !== comment.id) comment.parentId = parentId;
+    }
+  }
+  for (const comment of comments.values()) {
+    const seen = /* @__PURE__ */ new Set([comment.id]);
+    let parent = comment.parentId === void 0 ? void 0 : comments.get(comment.parentId);
+    while (parent?.parentId !== void 0 && !seen.has(parent.parentId)) {
+      seen.add(parent.id);
+      parent = comments.get(parent.parentId);
+    }
+    if (parent !== void 0) comment.parentId = parent.id;
+  }
+  return comments;
+}
+var SENTINELS = /\u0001([^\u0002]*)\u0002/g;
+var SENTINEL_SYNTAX = { I: "{++", i: "++}", D: "{--", d: "--}", H: "{==", h: "==}" };
+function numberReferences(blocks) {
+  const labels = /* @__PURE__ */ new Map();
+  const counters = { r: 0, m: 0, c: 0 };
+  const visit2 = (text7) => {
+    for (const match of text7.matchAll(SENTINELS)) {
+      const payload = match[1];
+      if (!payload.startsWith("R")) continue;
+      const id = payload.slice(1);
+      if (labels.has(id)) continue;
+      const prefix = id[0];
+      counters[prefix] = (counters[prefix] ?? 0) + 1;
+      labels.set(id, `${prefix}${counters[prefix]}`);
+    }
+  };
+  for (const block of blocks) {
+    if (block.kind === "paragraph") visit2(block.text);
+    else for (const row of block.rows) for (const value of row) visit2(value);
+  }
+  return labels;
+}
+function escapeForgedMarkers(text7) {
+  return text7.replace(/\{(?=\+\+|--|==)/g, "\\{").replace(/(\+\+|--|==)\}/g, "$1\\}").replace(/\[(?=[rmc]\d+\])/g, "\\[");
+}
+function resolveSentinels(text7, labels) {
+  const references = [];
+  const tidied = text7.replace(/\u0001H\u0002(\s*)\u0001h\u0002/g, "$1");
+  const resolved = escapeForgedMarkers(tidied).replace(SENTINELS, (_, payload) => {
+    if (!payload.startsWith("R")) return SENTINEL_SYNTAX[payload] ?? "";
+    const id = payload.slice(1);
+    references.push(id);
+    return `[${labels.get(id) ?? "?"}]`;
+  });
+  return { text: resolved, references };
+}
+function headingPaths(blocks) {
+  const stack = [];
+  return blocks.map((block) => {
+    if (block.kind === "paragraph" && block.heading !== void 0) {
+      while (stack.length > 0 && stack[stack.length - 1].level >= block.heading) stack.pop();
+      stack.push({ level: block.heading, text: block.plain ?? block.text });
+    }
+    return stack.map((entry) => entry.text);
+  });
+}
+var plural = (count, word) => `${count} ${word}${count === 1 ? "" : "s"}`;
+function dayOf(date) {
+  if (date === void 0) return void 0;
+  return /^\d{4}-\d{2}-\d{2}/.test(date) ? date.slice(0, 10) : date;
+}
+function attribution(author, date) {
+  return `${author ?? "author not recorded"}, ${dayOf(date) ?? "date not recorded"}`;
+}
+var listed = (text7) => escapeForgedMarkers(text7.replace(/[\u0001\u0002]/g, ""));
+function reviewList(references, layer, labels, paths, comments) {
+  const where = (block) => {
+    const path22 = block === void 0 ? void 0 : paths[block - 1];
+    return path22 === void 0 || path22.length === 0 ? "before the first heading" : path22.map(listed).join(" > ");
+  };
+  const lines = ["---", "Review layer, in document order:"];
+  for (const id of references) {
+    const entry = layer.entries.get(id);
+    const label = labels.get(id);
+    if (entry === void 0 || label === void 0) continue;
+    if (entry.kind === "comment") {
+      const comment = comments.get(id.slice(2));
+      const state2 = comment?.done === true ? "resolved" : comment?.done === false ? "open" : "resolved state not recorded";
+      lines.push(
+        `- [${label}] comment, ${state2} \u2014 ${attribution(comment?.author, comment?.date)} \u2014 ${where(entry.block)}: \xAB ${listed(comment?.text ?? "")} \xBB`
+      );
+      for (const reply of comments.values()) {
+        if (reply.parentId !== id.slice(2)) continue;
+        lines.push(`    - reply \u2014 ${attribution(reply.author, reply.date)}: \xAB ${listed(reply.text)} \xBB`);
+      }
+    } else if (entry.kind === "move") {
+      lines.push(`- [${label}] moved \u2014 ${attribution(entry.author, entry.date)} \u2014 from ${where(entry.block)} to ${where(entry.toBlock)}`);
+    } else {
+      const kind = entry.row === true ? `table row ${entry.kind}` : entry.kind;
+      lines.push(`- [${label}] ${kind} \u2014 ${attribution(entry.author, entry.date)} \u2014 ${where(entry.block ?? entry.toBlock)}`);
+    }
+  }
+  return lines.join("\n");
+}
+function reviewCounts(layer) {
+  let revisions = 0;
+  let comments = 0;
+  for (const entry of layer.entries.values()) {
+    if (!entry.visible) continue;
+    if (entry.kind === "comment") comments++;
+    else revisions++;
+  }
+  return { revisions, comments };
+}
 function renderBlock(block, mode) {
   if (block.kind === "table") {
     if (mode === "text") {
@@ -105271,24 +105678,34 @@ async function extractDocx(bytes, options2 = {}) {
   if (documentXml === null) {
     throw new DocxError("unreadable", `This package has no ${DOCUMENT_PART}: it is not a Word document.`);
   }
+  const show = options2.review === true;
+  const comments = readComments(buffer, limits, show);
+  const layer = {
+    show,
+    replies: new Set([...comments.values()].filter((comment) => comment.parentId !== void 0).map((comment) => comment.id)),
+    entries: /* @__PURE__ */ new Map()
+  };
   const pictures = [];
   let blocks;
   try {
     const marker = pictureMarkerIn(buffer, limits, pictures, deadline);
-    blocks = parseBody(documentXml.toString("utf8"), deadline, marker);
+    blocks = parseBody(documentXml.toString("utf8"), deadline, marker, layer);
   } catch (error) {
     throw asDocxError(error);
   }
   const blockCount = blocks.length;
   if (blockCount === 0) {
     return {
-      markdown: "_This document has no extractable body content._\n\n> Headers, footers, footnotes, comments and text boxes are not read by this tool.",
+      markdown: "_This document has no extractable body content._\n\n" + (show ? "> Headers, footers, footnotes and text boxes are not read by this tool." : "> Headers, footers, footnotes, comments and text boxes are not read by this tool."),
       blocks: [],
       blockCount: 0,
-      pictures
+      pictures,
+      ...show ? { review: reviewCounts(layer) } : {}
     };
   }
   const requested = options2.blocks ? parseBlockRange(options2.blocks, blockCount) : rangeTo(blockCount);
+  const labels = show ? numberReferences(blocks) : /* @__PURE__ */ new Map();
+  const shown = [];
   const pieces = [];
   const covered = [];
   let characters = 0;
@@ -105305,7 +105722,12 @@ async function extractDocx(bytes, options2 = {}) {
       break;
     }
     deadline();
-    const rendered = renderBlock(blocks[number - 1], mode);
+    let rendered = renderBlock(blocks[number - 1], mode);
+    if (show) {
+      const resolved = resolveSentinels(rendered, labels);
+      rendered = resolved.text;
+      for (const id of resolved.references) if (!shown.includes(id)) shown.push(id);
+    }
     covered.push(number);
     if (rendered === "") continue;
     characters += rendered.length;
@@ -105322,15 +105744,52 @@ async function extractDocx(bytes, options2 = {}) {
       `> Truncated: blocks ${describeBlocks(covered)} of ${blockCount} shown. Call again with blocks="${nextBlock}-${blockCount}" for the rest.`
     );
   }
-  const lead = struckThroughNotice(pieces.join("\n\n"));
+  const leads = [struckThroughNotice(pieces.join("\n\n")), reviewNotice(layer, shown, labels)].filter((line) => line !== "");
+  const list3 = show && shown.length > 0 ? [reviewList(shown, layer, labels, headingPaths(blocks), comments)] : [];
+  const markdown = [...leads, ...pieces, ...list3, ...notes].join("\n\n");
+  if (full && markdown.length > ABSOLUTE_MAX_CHARS) {
+    throw new DocxError(
+      "too-large",
+      `This document is larger than the ${ABSOLUTE_MAX_CHARS} character ceiling for a single answer. Extract it to a file with output_path, or ask for a block range.`
+    );
+  }
   return {
-    markdown: [...lead ? [lead] : [], ...pieces, ...notes].join("\n\n"),
+    markdown,
     blocks: covered,
     ...nextBlock === void 0 ? {} : { nextBlock },
     blockCount,
-    pictures
+    pictures,
+    ...show ? { review: reviewCounts(layer) } : {}
   };
 }
+function readComments(buffer, limits, review) {
+  try {
+    return parseComments(
+      readZipEntry(buffer, COMMENTS_PART, limits)?.toString("utf8"),
+      readZipEntry(buffer, COMMENTS_EXTENDED_PART, limits)?.toString("utf8")
+    );
+  } catch (error) {
+    if (!review) return /* @__PURE__ */ new Map();
+    const reason = asDocxError(error);
+    throw new DocxError(reason.reason, `This document's comments could not be read: ${reason.message}`);
+  }
+}
+function reviewNotice(layer, shown, labels) {
+  const total = reviewCounts(layer);
+  if (!layer.show) {
+    if (total.revisions === 0 && total.comments === 0) return "";
+    return `> This document holds ${plural(total.revisions, "tracked change")} and ${plural(total.comments, "comment")} that this reading does not show: it is the text with every change accepted, deletions left out and insertions read as ordinary text. Pass review: true to see each change and comment where it sits, with its author, date and section.`;
+  }
+  if (total.revisions === 0 && total.comments === 0) {
+    return "> Review reading: this document holds no tracked change or comment; the text below is as written.";
+  }
+  const revisions = shown.filter((id) => !id.startsWith("c:") && labels.has(id)).length;
+  const commentCount = shown.filter((id) => id.startsWith("c:") && labels.has(id)).length;
+  if (revisions === 0 && commentCount === 0) {
+    return "> Review reading: the blocks shown hold no tracked change or comment; other blocks of this document do.";
+  }
+  return `> Review reading: ${plural(revisions, "tracked change")} and ${plural(commentCount, "comment")} are marked below. \`{++text++}\` was inserted and \`{--text--}\` deleted; a moved passage is deleted at its origin and inserted at its destination, both marked with the same \`[mN]\`; \`{==text==}\` is the text a comment is about. Each \`[rN]\`, \`[mN]\` and \`[cN]\` is listed at the end with its author, date and section. Formatting changes are not shown.`;
+}
 function pictureMarkerIn(buffer, limits, pictures, deadline) {
   let targets;
   return (reference) => {
@@ -105727,10 +106186,10 @@ function heading(comment) {
 function renderComments(pageNumber, page) {
   if (page.comments.length === 0) return "";
   const out = [`### Comments on page ${pageNumber}`, ""];
-  let listed = 0;
+  let listed2 = 0;
   const write = (comment, depth) => {
-    if (listed >= MAX_COMMENTS_PER_PAGE) return;
-    listed++;
+    if (listed2 >= MAX_COMMENTS_PER_PAGE) return;
+    listed2++;
     const indent2 = "  ".repeat(depth);
     out.push(`${indent2}- ${heading(comment)}`);
     if (comment.remark !== "") out.push(...quoted(comment.remark, `${indent2}  `));
@@ -105741,7 +106200,7 @@ function renderComments(pageNumber, page) {
     }
   };
   for (const comment of page.comments) write(comment, 0);
-  if (page.count > listed) out.push(`- _${page.count - listed} more comment${page.count - listed === 1 ? "" : "s"} on this page not listed._`);
+  if (page.count > listed2) out.push(`- _${page.count - listed2} more comment${page.count - listed2 === 1 ? "" : "s"} on this page not listed._`);
   return out.join("\n");
 }
 var UNREADABLE_COMMENTS = "_The comments on this page could not be read._";
@@ -106644,6 +107103,7 @@ var DEFAULT_RENDER_TIMEOUT_MS = 12e4;
 
 // ../server/src/presentationRender.ts
 var RENDERER_NAMES = ["word", "powerpoint", "libreoffice", "onlyoffice"];
+var HOLD_KILL_MS = 3e4;
 var RenderError = class extends Error {
   constructor(message) {
     super(message);
@@ -106651,28 +107111,55 @@ var RenderError = class extends Error {
   }
 };
 var defaultRunner = (file, args, options2) => new Promise((resolve) => {
-  execFile(
-    file,
-    args,
-    // The signal is the turn's: a user who stops the agent must not leave an office
-    // application converting in the background for minutes.
-    { env: options2.env, timeout: options2.timeoutMs, windowsHide: true, maxBuffer: 4 * 1024 * 1024, ...options2.signal ? { signal: options2.signal } : {} },
-    (error, stdout, stderr) => {
-      const failure = error;
-      resolve({
-        code: failure === null ? 0 : typeof failure.code === "number" ? failure.code : null,
-        stdout: String(stdout ?? ""),
-        stderr: String(stderr ?? "") || (failure !== null && typeof failure.code === "string" ? `${failure.code}: ${failure.message}` : ""),
-        timedOut: failure?.killed === true
-      });
+  const { signal, holdKillUntil } = options2;
+  let timedOut = false;
+  let seen = "";
+  let held = false;
+  let grace;
+  const child2 = execFile(file, args, { env: options2.env, windowsHide: true, maxBuffer: 4 * 1024 * 1024 }, (error, stdout, stderr) => {
+    clearTimeout(timer);
+    clearTimeout(grace);
+    signal?.removeEventListener("abort", stop);
+    const failure = error;
+    resolve({
+      code: failure === null ? 0 : typeof failure.code === "number" ? failure.code : null,
+      stdout: String(stdout ?? ""),
+      stderr: String(stderr ?? "") || (failure !== null && typeof failure.code === "string" ? `${failure.code}: ${failure.message}` : ""),
+      timedOut
+    });
+  });
+  child2.stdout?.on("data", (chunk) => {
+    seen += String(chunk);
+    if (held && holdKillUntil?.test(seen)) child2.kill();
+  });
+  const end = () => {
+    if (held) return;
+    if (holdKillUntil === void 0 || holdKillUntil.test(seen)) {
+      child2.kill();
+      return;
     }
-  );
+    held = true;
+    grace = setTimeout(() => child2.kill(), options2.holdKillMs ?? HOLD_KILL_MS);
+  };
+  const timer = setTimeout(() => {
+    timedOut = true;
+    end();
+  }, options2.timeoutMs);
+  const stop = () => end();
+  if (signal?.aborted) stop();
+  else signal?.addEventListener("abort", stop, { once: true });
 });
 function defaultEnvironment() {
   return {
     platform: process.platform,
     env: process.env,
     run: defaultRunner,
+    kill: (pid) => {
+      try {
+        process.kill(pid);
+      } catch {
+      }
+    },
     isFile: async (file) => {
       try {
         const stat = await fs.stat(file);
@@ -106753,7 +107240,7 @@ var WORD_SCRIPT = [
   "$ErrorActionPreference = 'Stop'",
   "$app = $null; $doc = $null",
   "try {",
-  "  $app = New-Object -ComObject Word.Application",
+  ...startWordLines(),
   "  $missing = [Type]::Missing",
   "  $doc = $app.Documents.Open($env:PI_OUTPOST_RENDER_INPUT, $false, $true, $false, $missing, $missing, $missing, $missing, $missing, 0, $missing, $false)",
   "  for ($i = 1; $i -le $doc.TablesOfContents.Count; $i++) { try { $doc.TablesOfContents.Item($i).Update() } catch { } }",
@@ -106763,12 +107250,27 @@ var WORD_SCRIPT = [
   "  if ($app -ne $null -and $app.Documents.Count -eq 0) { $app.Quit([ref]0) }",
   "}"
 ].join("\n");
+function startWordLines() {
+  return [
+    "  $running = @(Get-Process WINWORD -ErrorAction SilentlyContinue | ForEach-Object { $_.Id })",
+    "  $app = New-Object -ComObject Word.Application",
+    "  $started = @(Get-Process WINWORD -ErrorAction SilentlyContinue | Where-Object { $running -notcontains $_.Id })",
+    "  [Console]::Out.WriteLine('word-pid=' + $(if ($started.Count -eq 1) { $started[0].Id } else { 'unknown' }))"
+  ];
+}
+var WORD_STARTED_LINE = /^word-pid=/m;
+var STARTED_WORD = /^word-pid=(\d+)\s*$/m;
+function stopStartedWord(result, environment, signal) {
+  if (!result.timedOut && signal?.aborted !== true) return;
+  const pid = STARTED_WORD.exec(result.stdout)?.[1];
+  if (pid !== void 0) environment.kill?.(Number(pid));
+}
 function onlyOfficeScript(input, output) {
   return [`builder.OpenFile(${JSON.stringify(input)}, "");`, `builder.SaveFile("pdf", ${JSON.stringify(output)});`, "builder.CloseFile();", ""].join("\n");
 }
 function describeFailure(result, timeoutMs) {
   if (result.timedOut) return `did not finish within ${Math.round(timeoutMs / 1e3)} s`;
-  const detail = (result.stderr || result.stdout).trim().split(/\r?\n/).filter(Boolean).slice(-3).join(" ");
+  const detail = (result.stderr || result.stdout.replace(/^word-pid=\S*\s*$/gm, "")).trim().split(/\r?\n/).filter(Boolean).slice(-3).join(" ");
   return detail !== "" ? detail : `exited with code ${result.code ?? "unknown"}`;
 }
 async function hasOutput(file) {
@@ -106778,21 +107280,28 @@ async function hasOutput(file) {
     return false;
   }
 }
+function powershellPath(environment) {
+  return environment.env.SystemRoot ? path2.win32.join(environment.env.SystemRoot, "System32", "WindowsPowerShell", "v1.0", "powershell.exe") : "powershell.exe";
+}
+function powershellArgs(script2) {
+  return ["-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-Command", script2];
+}
 async function convertWith(renderer, input, workDir, settings2, environment, signal) {
   const output = path2.join(workDir, `${path2.basename(input, path2.extname(input))}.pdf`);
   if (renderer === "powerpoint" || renderer === "word") {
     const application = renderer === "word" ? "Word" : "PowerPoint";
     if (environment.platform !== "win32") return { failure: `${application} automation is only available on Windows` };
-    const powershell = environment.env.SystemRoot ? path2.win32.join(environment.env.SystemRoot, "System32", "WindowsPowerShell", "v1.0", "powershell.exe") : "powershell.exe";
     const result2 = await environment.run(
-      powershell,
-      ["-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-Command", renderer === "word" ? WORD_SCRIPT : POWERPOINT_SCRIPT],
+      powershellPath(environment),
+      powershellArgs(renderer === "word" ? WORD_SCRIPT : POWERPOINT_SCRIPT),
       {
         env: { ...environment.env, PI_OUTPOST_RENDER_INPUT: input, PI_OUTPOST_RENDER_OUTPUT: output },
         timeoutMs: settings2.timeoutMs,
-        signal
+        signal,
+        ...renderer === "word" ? { holdKillUntil: WORD_STARTED_LINE } : {}
       }
     );
+    if (renderer === "word") stopStartedWord(result2, environment, signal);
     if (result2.code === 0 && await hasOutput(output)) return { pdf: output };
     return { failure: describeFailure(result2, settings2.timeoutMs) };
   }
@@ -106851,7 +107360,7 @@ async function convertToPdf(kind, source, settings2, environment, signal) {
       ].join("\n")
     );
   } finally {
-    await fs.rm(workDir, { recursive: true, force: true }).catch(() => {
+    await fs.rm(workDir, { recursive: true, force: true, maxRetries: 5, retryDelay: 200 }).catch(() => {
     });
   }
 }
@@ -106984,12 +107493,12 @@ async function checkDocumentPdf(pdf, paragraphs) {
 }
 
 // ../server/src/extractionOutput.ts
-import fs15 from "node:fs/promises";
-import path18 from "node:path";
+import fs16 from "node:fs/promises";
+import path19 from "node:path";
 
 // ../server/src/sandbox.ts
-import fs14 from "node:fs/promises";
-import path17 from "node:path";
+import fs15 from "node:fs/promises";
+import path18 from "node:path";
 import {
   createBashToolDefinition,
   createPowerShellToolDefinition,
@@ -107976,8 +108485,8 @@ function parsePresentation(xml) {
 }
 function describeVisuals(visuals) {
   const parts = [];
-  const add = (count, singular, plural) => {
-    if (count > 0) parts.push(`${count} ${count === 1 ? singular : plural}`);
+  const add = (count, singular, plural2) => {
+    if (count > 0) parts.push(`${count} ${count === 1 ? singular : plural2}`);
   };
   add(visuals.images, "image", "images");
   add(visuals.charts, "chart", "charts");
@@ -124510,8 +125019,8 @@ var levelIn = (properties, paragraph2, styles2) => {
   const { entriesFromBookmark, headingStyleRange, stylesWithLevels = [], useAppliedParagraphOutlineLevel } = properties;
   if (paragraph2.text.trim() === "" || entriesFromBookmark && !paragraph2.bookmarks.has(entriesFromBookmark)) return;
   const names2 = [paragraph2.styleId, paragraph2.styleId === void 0 ? void 0 : (_styles$get2 = styles2.get(paragraph2.styleId)) === null || _styles$get2 === void 0 ? void 0 : _styles$get2.name].filter((name) => name !== void 0).map((name) => name.toLowerCase());
-  const listed = stylesWithLevels.find((style) => names2.includes(style.styleName.toLowerCase()));
-  if (listed) return listed.level;
+  const listed2 = stylesWithLevels.find((style) => names2.includes(style.styleName.toLowerCase()));
+  if (listed2) return listed2.level;
   const namesItsEntries = Boolean(headingStyleRange) || stylesWithLevels.length > 0 || Boolean(useAppliedParagraphOutlineLevel) || Boolean(properties.tcFieldIdentifier) || Boolean(properties.tcFieldLevelRange) || Boolean(properties.captionLabel) || Boolean(properties.captionLabelIncludingNumbers);
   const headingRange = headingStyleRange ? parseRange(headingStyleRange) : namesItsEntries ? void 0 : [1, 9];
   const heading3 = headingLevelOf(paragraph2.styleId, styles2);
@@ -128966,18 +129475,18 @@ var PackageParts = class {
     const taken = /* @__PURE__ */ new Set([...this.existingPaths, ...this.paths.values()]);
     let index4 = 1;
     while (taken.has(`${folder}/${name}${index4}.${extension2}`)) index4++;
-    const path21 = `${folder}/${name}${index4}.${extension2}`;
-    this.paths.set(part, path21);
-    this.contentTypes.addOverride(contentType, `/word/${path21}`);
-    return path21;
+    const path22 = `${folder}/${name}${index4}.${extension2}`;
+    this.paths.set(part, path22);
+    this.contentTypes.addOverride(contentType, `/word/${path22}`);
+    return path22;
   }
   /**
   * Each part added, with its path under word/, in the order they were added.
   */
   get Array() {
-    return [...this.paths].map(([part, path21]) => ({
+    return [...this.paths].map(([part, path22]) => ({
       part,
-      path: path21
+      path: path22
     }));
   }
   /**
@@ -128986,9 +129495,9 @@ var PackageParts = class {
   *
   * @param path - The part's path under word/
   */
-  createRelationships(path21) {
+  createRelationships(path22) {
     const relationships = new Relationships();
-    this.folders.set(relationships, path21.slice(0, path21.indexOf("/")));
+    this.folders.set(relationships, path22.slice(0, path22.indexOf("/")));
     return relationships;
   }
   /**
@@ -128997,10 +129506,10 @@ var PackageParts = class {
   *
   * @param path - The part's path under word/
   */
-  getTarget(relationships, path21) {
+  getTarget(relationships, path22) {
     const from = this.folders.get(relationships);
-    if (from === void 0) return path21;
-    return path21.startsWith(`${from}/`) ? path21.slice(from.length + 1) : `../${path21}`;
+    if (from === void 0) return path22;
+    return path22.startsWith(`${from}/`) ? path22.slice(from.length + 1) : `../${path22}`;
   }
 };
 var createCompatibilitySetting = (version2) => new BuilderElement({
@@ -133630,11 +134139,11 @@ var xmlifyPart = (file, content3, prettify, relationships, standalone = true) =>
     encoding: "UTF-8"
   } : { encoding: "UTF-8" }
 });
-var xmlifyPackagePart = (file, part, path21, prettify) => {
+var xmlifyPackagePart = (file, part, path22, prettify) => {
   const { content: content3 } = part.options;
   if (content3 instanceof Uint8Array) return [{
     data: content3,
-    path: `word/${path21}`
+    path: `word/${path22}`
   }];
   if ("files" in content3) {
     const embedded = new import_jszip_min.default();
@@ -133644,16 +134153,16 @@ var xmlifyPackagePart = (file, part, path21, prettify) => {
         type: "uint8array",
         compression: "DEFLATE"
       }),
-      path: `word/${path21}`
+      path: `word/${path22}`
     }];
   }
-  const relationships = file.PackageParts.createRelationships(path21);
+  const relationships = file.PackageParts.createRelationships(path22);
   const data = xmlifyPart(file, content3, prettify, relationships);
-  const folder = path21.slice(0, path21.lastIndexOf("/"));
-  const name = path21.slice(path21.lastIndexOf("/") + 1);
+  const folder = path22.slice(0, path22.lastIndexOf("/"));
+  const name = path22.slice(path22.lastIndexOf("/") + 1);
   return [{
     data,
-    path: `word/${path21}`
+    path: `word/${path22}`
   }, ...relationships.RelationshipCount > 0 ? [{
     data: xmlifyPart(file, relationships, prettify, relationships, false),
     path: `word/${folder}/_rels/${name}.rels`
@@ -133662,7 +134171,7 @@ var xmlifyPackagePart = (file, part, path21, prettify) => {
 var xmlifyPackageParts = (file, prettify, from = 0) => {
   const parts = file.PackageParts.Array.slice(from);
   if (parts.length === 0) return [];
-  return [...parts.flatMap(({ part, path: path21 }) => xmlifyPackagePart(file, part, path21, prettify)), ...xmlifyPackageParts(file, prettify, from + parts.length)];
+  return [...parts.flatMap(({ part, path: path22 }) => xmlifyPackagePart(file, part, path22, prettify)), ...xmlifyPackageParts(file, prettify, from + parts.length)];
 };
 var _excluded = ["PackageParts"];
 var Compiler = class {
@@ -133700,7 +134209,7 @@ var Compiler = class {
     const map3 = new Map(Object.entries(xmlifiedFileMapping));
     for (const [, obj] of map3) if (Array.isArray(obj)) for (const subFile of obj) zip.file(subFile.path, encodeUtf8(subFile.data));
     else zip.file(obj.path, encodeUtf8(obj.data));
-    for (const { path: path21, data } of packageParts) zip.file(path21, typeof data === "string" ? encodeUtf8(data) : data);
+    for (const { path: path22, data } of packageParts) zip.file(path22, typeof data === "string" ? encodeUtf8(data) : data);
     for (const subFile of overrides) zip.file(subFile.path, encodeUtf8(subFile.data));
     for (const data of file.Media.Array) if (data.type !== "svg") zip.file(`word/media/${data.fileName}`, data.data);
     else {
@@ -134484,12 +134993,12 @@ var altTextOf = (properties) => {
   var _properties$attribute, _properties$attribute2;
   return [(_properties$attribute = properties.attributes) === null || _properties$attribute === void 0 ? void 0 : _properties$attribute.descr, (_properties$attribute2 = properties.attributes) === null || _properties$attribute2 === void 0 ? void 0 : _properties$attribute2.title].flatMap((text7) => text7 === void 0 ? [] : [String(text7)]);
 };
-var relationshipsPathOf = (path21) => {
-  const slash = path21.lastIndexOf("/");
-  return `${path21.slice(0, slash + 1)}_rels/${path21.slice(slash + 1)}.rels`;
+var relationshipsPathOf = (path22) => {
+  const slash = path22.lastIndexOf("/");
+  return `${path22.slice(0, slash + 1)}_rels/${path22.slice(slash + 1)}.rels`;
 };
-var sourceOfRelationships = (path21) => path21.replace(/(^|\/)_rels\/([^/]*)\.rels$/, "$1$2");
-var folderOf = (path21) => path21.slice(0, path21.lastIndexOf("/") + 1);
+var sourceOfRelationships = (path22) => path22.replace(/(^|\/)_rels\/([^/]*)\.rels$/, "$1$2");
+var folderOf = (path22) => path22.slice(0, path22.lastIndexOf("/") + 1);
 var resolveTarget = (from, target) => {
   const normalized = target.replace(/\\/g, "/");
   return (normalized.startsWith("/") ? normalized : `${folderOf(from)}${normalized}`).split("/").reduce((segments, segment4) => {
@@ -134515,18 +135024,18 @@ var relationshipsIn = (relationships) => {
 };
 var createTemplatePackage = (parts, binaryParts, file, context) => {
   const formatter2 = new Formatter();
-  const has = (path21) => parts.has(path21) || binaryParts.has(path21);
-  const findPath = (path21) => {
-    if (has(path21)) return path21;
+  const has = (path22) => parts.has(path22) || binaryParts.has(path22);
+  const findPath = (path22) => {
+    if (has(path22)) return path22;
     const decoded = (() => {
       try {
-        return decodeURI(path21);
+        return decodeURI(path22);
       } catch (_unused) {
         return;
       }
     })();
     if (decoded !== void 0 && has(decoded)) return decoded;
-    const lower = path21.toLowerCase();
+    const lower = path22.toLowerCase();
     return [...parts.keys(), ...binaryParts.keys()].find((key) => key.toLowerCase() === lower);
   };
   const findRelationship = (from, id) => {
@@ -134541,27 +135050,27 @@ var createTemplatePackage = (parts, binaryParts, file, context) => {
     const target = (_relationship$attribu2 = relationship.attributes) === null || _relationship$attribu2 === void 0 ? void 0 : _relationship$attribu2.Target;
     return ((_relationship$attribu3 = relationship.attributes) === null || _relationship$attribu3 === void 0 ? void 0 : _relationship$attribu3.TargetMode) === "External" || target === void 0 ? void 0 : findPath(resolveTarget(from, String(target)));
   };
-  const isReferenced = (path21) => [...parts].some(([relationshipsPath, relationships]) => relationshipsPath.endsWith(".rels") && getFirstLevelElements(relationships, "Relationships").some((relationship) => pathOf(sourceOfRelationships(relationshipsPath), relationship) === path21));
-  const removePart = (path21) => {
-    parts.delete(path21);
-    binaryParts.delete(path21);
-    parts.delete(relationshipsPathOf(path21));
+  const isReferenced = (path22) => [...parts].some(([relationshipsPath, relationships]) => relationshipsPath.endsWith(".rels") && getFirstLevelElements(relationships, "Relationships").some((relationship) => pathOf(sourceOfRelationships(relationshipsPath), relationship) === path22));
+  const removePart = (path22) => {
+    parts.delete(path22);
+    binaryParts.delete(path22);
+    parts.delete(relationshipsPathOf(path22));
     const contentTypes = parts.get(CONTENT_TYPES6);
-    if (contentTypes !== void 0) removeContentTypeOverride(contentTypes, `/${path21}`);
+    if (contentTypes !== void 0) removeContentTypeOverride(contentTypes, `/${path22}`);
   };
   return {
     getRelatedPart: (from, relationshipId) => {
       const relationship = findRelationship(from.path, relationshipId);
-      const path21 = relationship === void 0 ? void 0 : pathOf(from.path, relationship);
-      return path21 === void 0 ? void 0 : {
-        path: path21,
-        xml: parts.get(path21)
+      const path22 = relationship === void 0 ? void 0 : pathOf(from.path, relationship);
+      return path22 === void 0 ? void 0 : {
+        path: path22,
+        xml: parts.get(path22)
       };
     },
     replaceRelatedPart: (from, relationshipId, part) => {
-      const path21 = `word/${file.PackageParts.add(part)}`;
+      const path22 = `word/${file.PackageParts.add(part)}`;
       const { relationshipType } = part.options;
-      const target = relativeTarget2(from.path, path21);
+      const target = relativeTarget2(from.path, path22);
       const relationship = relationshipId === void 0 ? void 0 : findRelationship(from.path, relationshipId);
       if (relationship === void 0) {
         var _parts$get;
@@ -134596,16 +135105,16 @@ var patchDrawings = ({ parts, binaryParts, file, patches, delimiters: delimiters
     placeholder: `${delimiters2.start}${key}${delimiters2.end}`,
     patch
   }));
-  const found = [...parts].filter(([path21]) => path21.startsWith("word/") && !path21.endsWith(".rels")).flatMap(([path21, xmlPart]) => findDrawings(xmlPart).flatMap((drawing) => {
+  const found = [...parts].filter(([path22]) => path22.startsWith("word/") && !path22.endsWith(".rels")).flatMap(([path22, xmlPart]) => findDrawings(xmlPart).flatMap((drawing) => {
     const altText = altTextOf(drawing.properties);
     const matches = placeholders.filter(({ placeholder }) => altText.some((text7) => text7.includes(placeholder)));
     if (matches.length > 1) {
       var _drawing$properties$a, _drawing$properties$a2;
-      throw new Error(`The drawing "${(_drawing$properties$a = (_drawing$properties$a2 = drawing.properties.attributes) === null || _drawing$properties$a2 === void 0 ? void 0 : _drawing$properties$a2.name) !== null && _drawing$properties$a !== void 0 ? _drawing$properties$a : ""}" in ${path21} has the placeholders ${matches.map(({ placeholder }) => placeholder).join(" and ")} in its alt text. A drawing can only be patched once`);
+      throw new Error(`The drawing "${(_drawing$properties$a = (_drawing$properties$a2 = drawing.properties.attributes) === null || _drawing$properties$a2 === void 0 ? void 0 : _drawing$properties$a2.name) !== null && _drawing$properties$a !== void 0 ? _drawing$properties$a : ""}" in ${path22} has the placeholders ${matches.map(({ placeholder }) => placeholder).join(" and ")} in its alt text. A drawing can only be patched once`);
     }
     return matches.map(({ placeholder, patch }) => ({
       drawing: _objectSpread2(_objectSpread2({ placeholder }, drawing), {}, { part: {
-        path: path21,
+        path: path22,
         xml: xmlPart
       } }),
       patch
@@ -134685,30 +135194,30 @@ var patchNotesOfKind = (kind, notes, parts, { createContext, addContentTypeOverr
       var _element$attributes3;
       return ((_element$attributes3 = element.attributes) === null || _element$attributes3 === void 0 ? void 0 : _element$attributes3.Type) === kind.relationshipType;
     });
-    const path21 = relationship ? resolveTarget(DOCUMENT_PATH$1, String(relationship.attributes.Target)) : kind.path;
-    if (!parts.has(path21)) {
-      parts.set(path21, {
+    const path22 = relationship ? resolveTarget(DOCUMENT_PATH$1, String(relationship.attributes.Target)) : kind.path;
+    if (!parts.has(path22)) {
+      parts.set(path22, {
         declaration: { attributes: {
           version: "1.0",
           encoding: "UTF-8",
           standalone: "yes"
         } },
-        elements: [formatElement$1(kind.create.part(), createContext(path21))]
+        elements: [formatElement$1(kind.create.part(), createContext(path22))]
       });
-      addContentTypeOverride(kind.contentType, `/${path21}`);
+      addContentTypeOverride(kind.contentType, `/${path22}`);
     }
-    if (!relationship) createContext(DOCUMENT_PATH$1).viewWrapper.Relationships.addRelationship(uniqueId(), kind.relationshipType, relativeTarget2(DOCUMENT_PATH$1, path21));
-    return path21;
+    if (!relationship) createContext(DOCUMENT_PATH$1).viewWrapper.Relationships.addRelationship(uniqueId(), kind.relationshipType, relativeTarget2(DOCUMENT_PATH$1, path22));
+    return path22;
   };
   const write = () => {
     if (noteOfId.size === 0) return;
-    const path21 = findOrAddPart();
-    const context = createContext(path21);
+    const path22 = findOrAddPart();
+    const context = createContext(path22);
     const contentOfNote = new Map([...new Set(noteOfId.values())].map((note) => {
       const mark = formatElement$1(kind.create.mark(), context);
       return [note, useStyles(renumberLists(renumberBookmarks(note.children.map((paragraph2) => formatElement$1(paragraph2, context)).map((paragraph2, index4) => index4 === 0 ? withMark(paragraph2, mark) : paragraph2))))];
     }));
-    getFirstLevelElements(parts.get(path21), kind.rootName).push(...[...noteOfId].map(([id, note]) => ({
+    getFirstLevelElements(parts.get(path22), kind.rootName).push(...[...noteOfId].map(([id, note]) => ({
       type: "element",
       name: kind.noteName,
       attributes: { "w:id": String(id) },
@@ -134803,9 +135312,9 @@ var patchNumbering = (numbering, parts, { createContext, addContentTypeOverride
   };
   const findOrAddPart = (written) => {
     const relationship = numberingRelationship();
-    const path21 = numberingPath(relationship);
-    if (!parts.has(path21)) {
-      parts.set(path21, {
+    const path22 = numberingPath(relationship);
+    if (!parts.has(path22)) {
+      parts.set(path22, {
         declaration: { attributes: {
           version: "1.0",
           encoding: "UTF-8",
@@ -134813,10 +135322,10 @@ var patchNumbering = (numbering, parts, { createContext, addContentTypeOverride
         } },
         elements: [_objectSpread2(_objectSpread2({}, written), {}, { elements: [] })]
       });
-      addContentTypeOverride(NUMBERING_CONTENT_TYPE, `/${path21}`);
+      addContentTypeOverride(NUMBERING_CONTENT_TYPE, `/${path22}`);
     }
-    if (!relationship) createContext(DOCUMENT_PATH).viewWrapper.Relationships.addRelationship(uniqueId(), NUMBERING_RELATIONSHIP, relativeTarget2(DOCUMENT_PATH, path21));
-    return path21;
+    if (!relationship) createContext(DOCUMENT_PATH).viewWrapper.Relationships.addRelationship(uniqueId(), NUMBERING_RELATIONSHIP, relativeTarget2(DOCUMENT_PATH, path22));
+    return path22;
   };
   const write = () => {
     var _root$attributes$mcI, _root$attributes;
@@ -134830,10 +135339,10 @@ var patchNumbering = (numbering, parts, { createContext, addContentTypeOverride
       const newId = element.name === "w:abstractNum" ? newAbstractNumIds.get(Number(element.attributes["w:abstractNumId"])) : void 0;
       return newId === void 0 ? [] : [_objectSpread2(_objectSpread2({}, element), {}, { attributes: _objectSpread2(_objectSpread2({}, element.attributes), {}, { "w:abstractNumId": String(newId) }) })];
     });
-    const path21 = findOrAddPart(written);
-    const root2 = parts.get(path21).elements.find((element) => element.name === "w:numbering");
+    const path22 = findOrAddPart(written);
+    const root2 = parts.get(path22).elements.find((element) => element.name === "w:numbering");
     root2.attributes = _objectSpread2(_objectSpread2(_objectSpread2({}, Object.fromEntries(Object.entries(written.attributes).filter(([name]) => name.startsWith("xmlns:")))), root2.attributes), {}, { "mc:Ignorable": [.../* @__PURE__ */ new Set([...String((_root$attributes$mcI = (_root$attributes = root2.attributes) === null || _root$attributes === void 0 ? void 0 : _root$attributes["mc:Ignorable"]) !== null && _root$attributes$mcI !== void 0 ? _root$attributes$mcI : "").split(" "), ...String(written.attributes["mc:Ignorable"]).split(" ")])].filter((prefix) => prefix !== "").join(" ") });
-    const elements = getFirstLevelElements(parts.get(path21), "w:numbering");
+    const elements = getFirstLevelElements(parts.get(path22), "w:numbering");
     const firstIndexOf = (names2) => {
       const index4 = elements.findIndex((element) => names2.includes(element.name));
       return index4 === -1 ? elements.length : index4;
@@ -134896,10 +135405,10 @@ var readPackage = (function() {
       const zip = yield import_jszip_min.default.loadAsync(data);
       const parts = /* @__PURE__ */ new Map();
       const binaryParts = /* @__PURE__ */ new Map();
-      for (const [path21, file] of Object.entries(zip.files)) {
+      for (const [path22, file] of Object.entries(zip.files)) {
         if (file.dir) continue;
-        if (/\.(xml|rels)$/.test(path21)) parts.set(path21, toJson(yield file.async("text")));
-        else binaryParts.set(path21, yield file.async("uint8array"));
+        if (/\.(xml|rels)$/.test(path22)) parts.set(path22, toJson(yield file.async("text")));
+        else binaryParts.set(path22, yield file.async("uint8array"));
       }
       const importedDocuments = yield readImportedDocuments(parts, binaryParts);
       return _objectSpread2({
@@ -134917,11 +135426,11 @@ var readPackage = (function() {
 var readImportedDocuments = (function() {
   var _ref2 = _asyncToGenerator(function* (parts, binaryParts) {
     const imported = /* @__PURE__ */ new Map();
-    for (const [path21, relationships] of parts) {
+    for (const [path22, relationships] of parts) {
       var _rootOf$elements, _rootOf;
-      if (!path21.endsWith(".rels")) continue;
+      if (!path22.endsWith(".rels")) continue;
       for (const { attributes: attributes2 = {} } of (_rootOf$elements = (_rootOf = rootOf(relationships)) === null || _rootOf === void 0 ? void 0 : _rootOf.elements) !== null && _rootOf$elements !== void 0 ? _rootOf$elements : []) {
-        const target = resolveTarget(sourceOfRelationships(path21), String(attributes2.Target));
+        const target = resolveTarget(sourceOfRelationships(path22), String(attributes2.Target));
         const data = binaryParts.get(target);
         const read = attributes2.Type === IMPORT && attributes2.TargetMode !== "External" && data ? yield readPackage(data) : void 0;
         if (read) imported.set(target, read);
@@ -135269,18 +135778,18 @@ var childElementsOf = (element) => {
   var _element$elements;
   return (_element$elements = element.elements) !== null && _element$elements !== void 0 ? _element$elements : [];
 };
-var isInsideElementAtPath = (path21, ancestorPath) => path21.length > ancestorPath.length && ancestorPath.every((index4, i2) => path21[i2] === index4);
+var isInsideElementAtPath = (path22, ancestorPath) => path22.length > ancestorPath.length && ancestorPath.every((index4, i2) => path22[i2] === index4);
 var withoutNestedParagraphs = (paragraphs) => paragraphs.filter((paragraph2) => !paragraphs.some((other) => isInsideElementAtPath(paragraph2.pathToParagraph, other.pathToParagraph)));
-var goToElementFromPath = (json, path21) => {
+var goToElementFromPath = (json, path22) => {
   let element = json;
-  for (let i2 = 1; i2 < path21.length; i2++) {
-    const index4 = path21[i2];
+  for (let i2 = 1; i2 < path22.length; i2++) {
+    const index4 = path22[i2];
     element = element.elements[index4];
   }
   return element;
 };
-var goToParentElementFromPath = (json, path21) => goToElementFromPath(json, path21.slice(0, path21.length - 1));
-var getLastElementIndexFromPath = (path21) => path21[path21.length - 1];
+var goToParentElementFromPath = (json, path22) => goToElementFromPath(json, path22.slice(0, path22.length - 1));
+var getLastElementIndexFromPath = (path22) => path22[path22.length - 1];
 var formatter = new Formatter();
 var STYLES_PATH = "word/styles.xml";
 var REFERENCES = /* @__PURE__ */ new Set([
@@ -135415,7 +135924,7 @@ var rowHolding = (json, pathToParagraph) => {
   }
   return row;
 };
-var isInside = (path21, ancestorPath) => path21.length > ancestorPath.length && ancestorPath.every((index4, i2) => path21[i2] === index4);
+var isInside = (path22, ancestorPath) => path22.length > ancestorPath.length && ancestorPath.every((index4, i2) => path22[i2] === index4);
 var hasRows = (table) => {
   var _table$elements;
   return ((_table$elements = table.elements) !== null && _table$elements !== void 0 ? _table$elements : []).some((e) => e.name === "w:tr" || e.name !== "w:tblPr" && e.name !== "w:tblGrid" && hasRows(e));
@@ -135467,8 +135976,8 @@ var hexValue = (color3) => {
 };
 var isUtf16 = (bytes) => bytes[0] === 255 && bytes[1] === 254 || bytes[0] === 254 && bytes[1] === 255;
 var readPart = (function() {
-  var _ref = _asyncToGenerator(function* (zip, path21) {
-    const part = zip.file(path21);
+  var _ref = _asyncToGenerator(function* (zip, path22) {
+    const part = zip.file(path22);
     if (part === null) return;
     return isUtf16(yield part.async("uint8array")) ? void 0 : toJson(yield part.async("text"));
   });
@@ -135544,7 +136053,7 @@ var patchDocument = (function() {
       PackageParts: new PackageParts({ addOverride: (contentType, partName) => contentTypeOverrides.push({
         contentType,
         partName
-      }) }, new Set(Object.keys(zipContent.files).filter((path21) => path21.startsWith("word/")).map((path21) => path21.slice(5))))
+      }) }, new Set(Object.keys(zipContent.files).filter((path22) => path22.startsWith("word/")).map((path22) => path22.slice(5))))
     };
     const map3 = /* @__PURE__ */ new Map();
     const imageRelationshipAdditions = [];
@@ -135742,7 +136251,7 @@ var patchDocument = (function() {
     }
     for (const [key, value] of binaryContentMap) zip.file(key, value);
     for (const { data: stream, fileName } of file.Media.Array) zip.file(`word/media/${fileName}`, stream);
-    for (const { path: path21, data: partData } of packageParts) zip.file(path21, typeof partData === "string" ? encodeUtf8(partData) : partData);
+    for (const { path: path22, data: partData } of packageParts) zip.file(path22, typeof partData === "string" ? encodeUtf8(partData) : partData);
     return zip.generateAsync({
       type: outputType,
       mimeType: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
@@ -136208,7 +136717,7 @@ function transformGfmAutolinkLiterals(tree2) {
     { ignore: ["link", "linkReference"] }
   );
 }
-function findUrl(_, protocol, domain2, path21, match) {
+function findUrl(_, protocol, domain2, path22, match) {
   let prefix = "";
   if (!previous(match)) {
     return false;
@@ -136221,7 +136730,7 @@ function findUrl(_, protocol, domain2, path21, match) {
   if (!isCorrectDomain(domain2)) {
     return false;
   }
-  const parts = splitUrl(domain2 + path21);
+  const parts = splitUrl(domain2 + path22);
   if (!parts[0]) return false;
   const result = {
     type: "link",
@@ -145318,27 +145827,27 @@ var sqrtTall = function sqrtTall2(extraVinculum, hLinePad2, viewBoxHeight) {
 };
 var sqrtPath = function sqrtPath2(size, extraVinculum, viewBoxHeight) {
   extraVinculum = 1e3 * extraVinculum;
-  var path21 = "";
+  var path22 = "";
   switch (size) {
     case "sqrtMain":
-      path21 = sqrtMain(extraVinculum, hLinePad);
+      path22 = sqrtMain(extraVinculum, hLinePad);
       break;
     case "sqrtSize1":
-      path21 = sqrtSize1(extraVinculum, hLinePad);
+      path22 = sqrtSize1(extraVinculum, hLinePad);
       break;
     case "sqrtSize2":
-      path21 = sqrtSize2(extraVinculum, hLinePad);
+      path22 = sqrtSize2(extraVinculum, hLinePad);
       break;
     case "sqrtSize3":
-      path21 = sqrtSize3(extraVinculum, hLinePad);
+      path22 = sqrtSize3(extraVinculum, hLinePad);
       break;
     case "sqrtSize4":
-      path21 = sqrtSize4(extraVinculum, hLinePad);
+      path22 = sqrtSize4(extraVinculum, hLinePad);
       break;
     case "sqrtTall":
-      path21 = sqrtTall(extraVinculum, hLinePad, viewBoxHeight);
+      path22 = sqrtTall(extraVinculum, hLinePad, viewBoxHeight);
   }
-  return path21;
+  return path22;
 };
 var innerPath = function innerPath2(name, height) {
   switch (name) {
@@ -149512,8 +150021,8 @@ var svgData = {
 };
 var staticSvg = function staticSvg2(value, options2) {
   var _svgData$value = svgData[value], pathName = _svgData$value[0], width = _svgData$value[1], height = _svgData$value[2];
-  var path21 = new PathNode(pathName);
-  var svgNode = new SvgNode([path21], {
+  var path22 = new PathNode(pathName);
+  var svgNode = new SvgNode([path22], {
     "width": makeEm(width),
     "height": makeEm(height),
     // Override CSS rule `.katex svg { width: 100% }`
@@ -150654,8 +151163,8 @@ var stretchySvg = function stretchySvg2(group, options2) {
           pathName = "tilde" + imgIndex;
         }
       }
-      var path21 = new PathNode(pathName);
-      var svgNode = new SvgNode([path21], {
+      var path22 = new PathNode(pathName);
+      var svgNode = new SvgNode([path22], {
         "width": "100%",
         "height": makeEm(_height),
         "viewBox": "0 0 " + viewBoxWidth + " " + viewBoxHeight,
@@ -151859,8 +152368,8 @@ var makeGlyphSpan = function makeGlyphSpan2(symbol, font, mode) {
 };
 var makeInner = function makeInner2(ch3, height, options2) {
   var width = fontMetricsData["Size4-Regular"][ch3.charCodeAt(0)] ? fontMetricsData["Size4-Regular"][ch3.charCodeAt(0)][4] : fontMetricsData["Size1-Regular"][ch3.charCodeAt(0)][4];
-  var path21 = new PathNode("inner", innerPath(ch3, Math.round(1e3 * height)));
-  var svgNode = new SvgNode([path21], {
+  var path22 = new PathNode("inner", innerPath(ch3, Math.round(1e3 * height)));
+  var svgNode = new SvgNode([path22], {
     "width": makeEm(width),
     "height": makeEm(height),
     // Override CSS rule `.katex svg { width: 100% }`
@@ -152029,10 +152538,10 @@ var makeStackedDelim = function makeStackedDelim2(delim, heightTotal, center, op
     var midHeight = realHeightTotal - topHeightTotal - bottomHeightTotal;
     var viewBoxHeight = Math.round(realHeightTotal * 1e3);
     var pathStr = tallDelim(svgLabel, Math.round(midHeight * 1e3));
-    var path21 = new PathNode(svgLabel, pathStr);
+    var path22 = new PathNode(svgLabel, pathStr);
     var width = makeEm(viewBoxWidth / 1e3);
     var height = makeEm(viewBoxHeight / 1e3);
-    var svg = new SvgNode([path21], {
+    var svg = new SvgNode([path22], {
       "width": width,
       "height": height,
       "viewBox": "0 0 " + viewBoxWidth + " " + viewBoxHeight
@@ -152073,8 +152582,8 @@ var makeStackedDelim = function makeStackedDelim2(delim, heightTotal, center, op
 var vbPad = 80;
 var emPad = 0.08;
 var sqrtSvg = function sqrtSvg2(sqrtName, height, viewBoxHeight, extraVinculum, options2) {
-  var path21 = sqrtPath(sqrtName, extraVinculum, viewBoxHeight);
-  var pathNode = new PathNode(sqrtName, path21);
+  var path22 = sqrtPath(sqrtName, extraVinculum, viewBoxHeight);
+  var pathNode = new PathNode(sqrtName, path22);
   var svg = new SvgNode([pathNode], {
     // Note: 1000:1 ratio of viewBox to document em width.
     "width": "400em",
@@ -152573,8 +153082,8 @@ var htmlBuilder$7 = (group, options2) => {
     var angleHeight = inner2.height + inner2.depth + lineWeight + clearance;
     inner2.style.paddingLeft = makeEm(angleHeight / 2 + lineWeight);
     var viewBoxHeight = Math.floor(1e3 * angleHeight * scale);
-    var path21 = phasePath(viewBoxHeight);
-    var svgNode = new SvgNode([new PathNode("phase", path21)], {
+    var path22 = phasePath(viewBoxHeight);
+    var svgNode = new SvgNode([new PathNode("phase", path22)], {
       "width": "400em",
       "height": makeEm(viewBoxHeight / 1e3),
       "viewBox": "0 0 400000 " + viewBoxHeight,
@@ -161171,13 +161680,13 @@ var VFile = class {
    * @returns {undefined}
    *   Nothing.
    */
-  set path(path21) {
-    if (isUrl(path21)) {
-      path21 = fileURLToPath3(path21);
+  set path(path22) {
+    if (isUrl(path22)) {
+      path22 = fileURLToPath3(path22);
     }
-    assertNonEmpty(path21, "path");
-    if (this.path !== path21) {
-      this.history.push(path21);
+    assertNonEmpty(path22, "path");
+    if (this.path !== path22) {
+      this.history.push(path22);
     }
   }
   /**
@@ -161444,8 +161953,8 @@ function assertNonEmpty(part, name) {
     throw new Error("`" + name + "` cannot be empty");
   }
 }
-function assertPath(path21, name) {
-  if (!path21) {
+function assertPath(path22, name) {
+  if (!path22) {
     throw new Error("Setting `" + name + "` requires `path` to be set too");
   }
 }
@@ -162477,6 +162986,10 @@ function inlineRuns(nodes, refs, marks = {}) {
         out.push(new TextRun({ text: "", break: 1 }));
         break;
       case "image": {
+        if (isDrawioReference(node2.url)) {
+          out.push(new ExternalHyperlink({ children: [runOf(drawioLinkLabel(node2.url, node2.alt), marks)], link: node2.url }));
+          break;
+        }
         const picture = refs.get(node2);
         if (picture === void 0) out.push(runOf(node2.alt ?? node2.url, marks));
         else out.push(pictureRun(picture, node2.alt));
@@ -162561,13 +163074,24 @@ function countDiagrams(text7) {
   walk(parseMarkdown(text7));
   return count;
 }
+function isDrawioReference(url) {
+  return !/^[a-z][a-z0-9+.-]*:|^\/\//i.test(url) && /\.(drawio|dio)$/i.test(url.split(/[?#]/)[0]);
+}
+function drawioLinkLabel(url, alt) {
+  let path22 = url.split(/[?#]/)[0].replace(/^\.\//, "");
+  try {
+    path22 = decodeURIComponent(path22);
+  } catch {
+  }
+  return alt && alt.trim() !== "" ? `${alt.trim()} (draw.io diagram: ${path22})` : `draw.io diagram: ${path22}`;
+}
 async function loadReferences(root2, source) {
   const refs = /* @__PURE__ */ new Map();
   const { imageKey, loadImage } = source;
   if (imageKey === void 0 || loadImage === void 0) return refs;
   const nodes = [];
   const walk = (node2) => {
-    if (node2.type === "image") nodes.push(node2);
+    if (node2.type === "image" && !isDrawioReference(node2.url)) nodes.push(node2);
     for (const child2 of node2.children ?? []) walk(child2);
   };
   walk(root2);
@@ -163613,8 +164137,8 @@ function sectionEnd(headings, heading3, bodyEnd) {
   const next = headings.find((candidate) => candidate.index > heading3.index && candidate.level <= heading3.level);
   return next === void 0 ? bodyEnd : next.index;
 }
-function findSection(path21, headings, bodyEnd) {
-  const segments = path21.split(">").map((segment4) => segment4.trim()).filter(Boolean);
+function findSection(path22, headings, bodyEnd) {
+  const segments = path22.split(">").map((segment4) => segment4.trim()).filter(Boolean);
   if (segments.length === 0) throw new WordTemplateError(`the section path is empty.
 ${outline(headings)}`);
   const matches = (heading3, segment4) => normalise2(heading3.text) === normalise2(segment4) || normalise2(heading3.text) === normalise2(withoutNumber(segment4));
@@ -163631,7 +164155,7 @@ ${outline(headings)}`);
     scope = found;
   }
   if (scope.length > 1) {
-    throw new WordTemplateError(`"${path21}" names ${scope.length} sections; add the heading above it, as in "Parent > ${segments[segments.length - 1]}".
+    throw new WordTemplateError(`"${path22}" names ${scope.length} sections; add the heading above it, as in "Parent > ${segments[segments.length - 1]}".
 ${outline(headings)}`);
   }
   return scope[0];
@@ -164677,9 +165201,188 @@ function createDocxRenderToolDefinition(options2) {
   };
 }
 
+// ../server/src/docxCompare.ts
+import fs9 from "node:fs/promises";
+import os2 from "node:os";
+import path12 from "node:path";
+var COMPARISON_AUTHOR = "Word comparison";
+var MANUAL_COMPARISON = "To compare by hand, open the revised document in Word, choose Review \u2192 Compare \u2192 Compare\u2026, save the result, and read it with docx_extract and review: true.";
+var COMPARE_SCRIPT = [
+  "$ErrorActionPreference = 'Stop'",
+  "[Console]::OutputEncoding = [Text.Encoding]::UTF8",
+  "$app = $null; $original = $null; $revised = $null; $result = $null",
+  "try {",
+  ...startWordLines(),
+  "  $missing = [Type]::Missing",
+  "  $original = $app.Documents.Open($env:PI_OUTPOST_COMPARE_ORIGINAL, $false, $true, $false, $missing, $missing, $missing, $missing, $missing, 0, $missing, $false)",
+  "  $revised = $app.Documents.Open($env:PI_OUTPOST_COMPARE_REVISED, $false, $true, $false, $missing, $missing, $missing, $missing, $missing, 0, $missing, $false)",
+  "  $result = $app.CompareDocuments($original, $revised, 2, 1, $false, $true, $true, $true, $true, $true, $true, $true, $true, $true, $env:PI_OUTPOST_COMPARE_AUTHOR, $true)",
+  "  $result.SaveAs2($env:PI_OUTPOST_COMPARE_OUTPUT, 16)",
+  "} catch {",
+  "  [Console]::Error.WriteLine($_.Exception.Message); exit 1",
+  "} finally {",
+  "  foreach ($doc in @($result, $revised, $original)) { if ($doc -ne $null) { try { $doc.Close(0) } catch { } } }",
+  "  if ($app -ne $null -and $app.Documents.Count -eq 0) { $app.Quit([ref]0) }",
+  "}"
+].join("\n");
+async function compareWithWord(original, revised, settings2, environment, signal) {
+  if (environment.platform !== "win32") {
+    throw new Error(`Microsoft Word is unavailable: Word automation is only available on Windows. ${MANUAL_COMPARISON}`);
+  }
+  const workDir = await fs9.mkdtemp(path12.join(os2.tmpdir(), "pi-outpost-compare-"));
+  try {
+    const files = {
+      original: path12.join(workDir, "original.docx"),
+      revised: path12.join(workDir, "revised.docx"),
+      output: path12.join(workDir, "compared.docx")
+    };
+    await fs9.writeFile(files.original, original);
+    await fs9.writeFile(files.revised, revised);
+    if (signal?.aborted) throw new Error("The comparison was stopped.");
+    const result = await environment.run(powershellPath(environment), powershellArgs(COMPARE_SCRIPT), {
+      env: {
+        ...environment.env,
+        PI_OUTPOST_COMPARE_ORIGINAL: files.original,
+        PI_OUTPOST_COMPARE_REVISED: files.revised,
+        PI_OUTPOST_COMPARE_OUTPUT: files.output,
+        PI_OUTPOST_COMPARE_AUTHOR: COMPARISON_AUTHOR
+      },
+      timeoutMs: settings2.timeoutMs,
+      signal,
+      holdKillUntil: WORD_STARTED_LINE
+    });
+    stopStartedWord(result, environment, signal);
+    if (signal?.aborted) throw new Error("The comparison was stopped.");
+    const bytes = result.code === 0 ? await fs9.readFile(files.output).catch(() => null) : null;
+    if (bytes !== null && bytes.length > 0) return bytes;
+    if (result.timedOut) {
+      throw new Error(
+        `Word did not finish the comparison within ${Math.round(settings2.timeoutMs / 1e3)} s (office.renderTimeoutMs). ${MANUAL_COMPARISON}`
+      );
+    }
+    throw new Error(`Microsoft Word is unavailable: ${powershellError(result) ?? describeFailure(result, settings2.timeoutMs)}. ${MANUAL_COMPARISON}`);
+  } finally {
+    await fs9.rm(workDir, { recursive: true, force: true, maxRetries: 5, retryDelay: 200 }).catch(() => {
+    });
+  }
+}
+function powershellError(result) {
+  const first = result.stderr.split(/\r?\n/).map((line) => line.trim()).find((line) => line !== "");
+  return first?.replace(/\.$/, "");
+}
+async function comparisonAnswer(compared, names2, sources = {}) {
+  const opening = `> Compared by Microsoft Word: "${names2.original}" \u2192 "${names2.revised}". The authors and dates on the changes below are the comparison's, not those of whoever edited the document.`;
+  const written = names2.written === void 0 ? [] : [`Saved the compared document, with Word's tracked changes, to \`${names2.written}\`.`];
+  const own4 = sourcesLine(names2, sources);
+  let extraction;
+  let truncated = false;
+  try {
+    try {
+      extraction = await extractDocx(compared, { review: true, full: true });
+    } catch (error) {
+      if (!(error instanceof DocxError) || error.reason !== "too-large") throw error;
+      extraction = await extractDocx(compared, { review: true });
+      truncated = true;
+    }
+  } catch (error) {
+    if (error instanceof DocxError) throw new Error(`Word's compared document could not be read: ${error.message}`);
+    throw error;
+  }
+  if ((extraction.review?.revisions ?? 0) === 0) {
+    return [opening, ...own4, "Word found no difference between the two versions' text (formatting is not compared).", ...written].join("\n\n");
+  }
+  const rest = !truncated ? ["> This is every difference Word found between the two versions. Reading the two versions is not needed to find them."] : names2.written !== void 0 ? [`> Read the rest with docx_extract on \`${names2.written}\` with review: true and the blocks named above.`] : ["> Call docx_compare again with output_path to keep the compared document, then read the rest with docx_extract, review: true and the blocks named above."];
+  return [opening, ...own4, extraction.markdown, ...rest, ...written].join("\n\n");
+}
+function sourcesLine(names2, sources) {
+  const { original, revised } = sources;
+  if (original === void 0 || revised === void 0) return [];
+  const holds = (counts) => counts.revisions > 0 || counts.comments > 0;
+  if (!holds(original) && !holds(revised)) return ["> Neither version holds tracked changes or comments of its own."];
+  const described = [
+    [names2.original, original],
+    [names2.revised, revised]
+  ].filter(([, counts]) => holds(counts)).map(([name, counts]) => `"${name}" holds ${countOf(counts)} of its own`);
+  return [`> ${described.join("; ")}, not listed here: read it with docx_extract and review: true to see them.`];
+}
+function countOf(counts) {
+  const plural2 = (n, word) => `${n} ${word}${n === 1 ? "" : "s"}`;
+  return [counts.revisions > 0 ? plural2(counts.revisions, "tracked change") : "", counts.comments > 0 ? plural2(counts.comments, "comment") : ""].filter(Boolean).join(" and ");
+}
+async function reviewLayerOf(bytes) {
+  try {
+    return (await extractDocx(bytes, { review: true, maxBlocks: 1 })).review;
+  } catch {
+    return void 0;
+  }
+}
+function createDocxCompareToolDefinition(options2) {
+  const environment = options2.environment ?? defaultEnvironment();
+  return {
+    name: "docx_compare",
+    label: "Compare Word documents",
+    description: [
+      "Compare two versions of a Word document (.docx) with Microsoft Word, and return what changed in the review reading:",
+      "{++inserted++} and {--deleted--} text, moves marked [mN] at both ends, each change listed at the end with its section.",
+      "Use it whenever you have two versions of a document and need what changed between them, for instance a revision sent without tracked changes.",
+      "Its answer is the complete list of differences, and says whether either version holds tracked changes of its own: do not read the two versions to compare them yourself.",
+      "Formatting is not compared. The authors and dates on the changes are the comparison's, not the editors'. Neither file is modified.",
+      "output_path also saves Word's compared document, for the user to open in Word."
+    ].join(" "),
+    promptSnippet: "Compare two versions of a Word document with Word, to see what changed",
+    parameters: typebox_exports.Object({
+      original: typebox_exports.String({ description: "The earlier version (.docx)." }),
+      revised: typebox_exports.String({ description: "The later version (.docx)." }),
+      output_path: typebox_exports.Optional(typebox_exports.String({ description: "Also save Word's compared document at this workspace path (.docx). The file must not already exist." }))
+    }),
+    executionMode: "sequential",
+    async execute(_toolCallId, params, signal) {
+      const p = params;
+      const original = await readSource(p.original, options2, options2.maxBytes, "Word");
+      const revised = await readSource(p.revised, options2, options2.maxBytes, "Word");
+      let destination;
+      if (p.output_path !== void 0) {
+        if (!/\.docx$/i.test(p.output_path)) throw new Error(`"${p.output_path}" must end in .docx.`);
+        destination = await assertWritableDestination(p.output_path, { cwd: options2.cwd, writableRoot: options2.writableRoot });
+        if (await fs9.lstat(destination).then(() => true, () => false)) {
+          throw new Error(`"${p.output_path}" already exists; choose another path for the compared document.`);
+        }
+        if (!await fs9.stat(path12.dirname(destination)).then((stat) => stat.isDirectory(), () => false)) {
+          throw new Error(`The folder for "${p.output_path}" does not exist.`);
+        }
+      }
+      const compared = await compareWithWord(original.bytes, revised.bytes, options2.render, environment, signal);
+      if (destination !== void 0) {
+        try {
+          await fs9.writeFile(destination, compared, { flag: "wx" });
+        } catch (error) {
+          const code3 = error.code;
+          if (code3 === "EEXIST") throw new Error(`"${p.output_path}" already exists; choose another path for the compared document.`);
+          if (code3 === "ENOENT") throw new Error(`The folder for "${p.output_path}" does not exist.`);
+          throw error;
+        }
+      }
+      const [ownOriginal, ownRevised] = await Promise.all([reviewLayerOf(original.bytes), reviewLayerOf(revised.bytes)]);
+      const text7 = await comparisonAnswer(
+        compared,
+        {
+          original: p.original,
+          revised: p.revised,
+          ...p.output_path === void 0 ? {} : { written: p.output_path }
+        },
+        {
+          ...ownOriginal === void 0 ? {} : { original: ownOriginal },
+          ...ownRevised === void 0 ? {} : { revised: ownRevised }
+        }
+      );
+      return { content: [{ type: "text", text: text7 }], details: void 0 };
+    }
+  };
+}
+
 // ../server/src/structuredExchangeFigureTool.ts
-import fs10 from "node:fs/promises";
-import path13 from "node:path";
+import fs11 from "node:fs/promises";
+import path14 from "node:path";
 
 // ../shared/src/structuredExchangeText.ts
 var CHAR_WIDTH = 6.6;
@@ -165614,32 +166317,32 @@ function findCycle(edges) {
     outgoing.set(edge.from, list3);
   }
   const state2 = /* @__PURE__ */ new Map();
-  const path21 = [];
+  const path22 = [];
   for (const root2 of outgoing.keys()) {
     if (state2.has(root2)) continue;
     const stack = [{ id: root2, next: 0 }];
     state2.set(root2, "open");
-    path21.push({ id: root2, index: -1 });
+    path22.push({ id: root2, index: -1 });
     while (stack.length > 0) {
       const frame = stack[stack.length - 1];
       const edgesOut = outgoing.get(frame.id) ?? [];
       if (frame.next >= edgesOut.length) {
         state2.set(frame.id, "done");
         stack.pop();
-        path21.pop();
+        path22.pop();
         continue;
       }
       const edge = edgesOut[frame.next++];
       const seen = state2.get(edge.to);
       if (seen === "open") {
-        const start = path21.findIndex((step) => step.id === edge.to);
-        const ids2 = [...path21.slice(start).map((step) => step.id), edge.to];
+        const start = path22.findIndex((step) => step.id === edge.to);
+        const ids2 = [...path22.slice(start).map((step) => step.id), edge.to];
         return { ids: ids2, index: edge.index };
       }
       if (seen === void 0) {
         state2.set(edge.to, "open");
         stack.push({ id: edge.to, next: 0 });
-        path21.push({ id: edge.to, index: edge.index });
+        path22.push({ id: edge.to, index: edge.index });
       }
     }
   }
@@ -177218,13 +177921,13 @@ var STRUCTURED_EXCHANGE_RULES_CEILINGS = {
 };
 
 // ../shared/src/structuredExchangeDocumentItems.ts
-function effective(raw, path21) {
+function effective(raw, path22) {
   const set = raw.set ?? void 0;
   const attributes2 = { ...raw.attributes ?? {} };
   Object.assign(attributes2, set?.attributes ?? {});
   for (const name of set?.removeAttributes ?? []) delete attributes2[name];
   const kind = typeof set?.kind === "string" ? set.kind : typeof raw.kind === "string" ? raw.kind : void 0;
-  return { ...typeof raw.id === "string" ? { id: raw.id } : {}, ...kind === void 0 ? {} : { kind }, attributes: attributes2, path: path21 };
+  return { ...typeof raw.id === "string" ? { id: raw.id } : {}, ...kind === void 0 ? {} : { kind }, attributes: attributes2, path: path22 };
 }
 function itemsAndRelationships(envelope) {
   const document4 = envelope;
@@ -177363,8 +178066,8 @@ function evaluateRules(envelope, rules, options2 = {}) {
       });
     }
   }
-  const order2 = (path21) => {
-    const [, , collection, index4] = path21.split("/");
+  const order2 = (path22) => {
+    const [, , collection, index4] = path22.split("/");
     const rank = { nodes: 0, rows: 0, edges: 1, relations: 1 }[collection] ?? 2;
     return rank * 1e6 + Number(index4);
   };
@@ -177435,12 +178138,12 @@ function checkAgainstProfile(envelope, profile, options2 = {}) {
     if (typeof value === "string") return `the string ${JSON.stringify(value)}`;
     return `the ${typeof value} ${String(value)}`;
   }
-  function checkScalar(attribute, kind, value, path21) {
+  function checkScalar(attribute, kind, value, path22) {
     const typed = attribute.type === "string" || attribute.type === "enumeration" ? typeof value === "string" : attribute.type === "number" ? typeof value === "number" : attribute.type === "boolean" ? typeof value === "boolean" : value !== null && typeof value === "object" && typeof value.ref === "string";
     if (!typed) {
       issues.push({
         rule: "profile/attribute-type",
-        path: path21,
+        path: path22,
         message: `attribute "${attribute.name}" of kind "${kind}" holds a ${describeType(attribute)}, and this is ${describeValue(value)}`
       });
       return;
@@ -177451,25 +178154,25 @@ function checkAgainstProfile(envelope, profile, options2 = {}) {
     if (attribute.closed) {
       issues.push({
         rule: "profile/closed-enumeration",
-        path: path21,
+        path: path22,
         message: `"${value}" is not a value of "${attribute.name}" on kind "${kind}"; profile "${profile.id}" allows ${quoted2(declared)}`
       });
     } else {
       notes.push({
         rule: "profile/open-enumeration-value",
-        path: path21,
+        path: path22,
         value,
         declared: [...declared],
         message: `"${value}" is not among the values profile "${profile.id}" lists for "${attribute.name}" on kind "${kind}" (${quoted2(declared)}); accepted, since that enumeration is open`
       });
     }
   }
-  function checkValue(attribute, kind, value, path21) {
+  function checkValue(attribute, kind, value, path22) {
     if (value === null) {
       if (attribute.required) {
         issues.push({
           rule: "profile/null-required-attribute",
-          path: path21,
+          path: path22,
           message: `attribute "${attribute.name}" is required on kind "${kind}", and null is not a value`
         });
       }
@@ -177478,13 +178181,13 @@ function checkAgainstProfile(envelope, profile, options2 = {}) {
     if (Array.isArray(value) !== (attribute.list === true)) {
       issues.push({
         rule: "profile/attribute-type",
-        path: path21,
+        path: path22,
         message: attribute.list ? `attribute "${attribute.name}" of kind "${kind}" holds a list of ${describeType(attribute)}s, not one value` : `attribute "${attribute.name}" of kind "${kind}" holds one ${describeType(attribute)}, not a list`
       });
       return;
     }
-    if (Array.isArray(value)) value.forEach((item, index4) => checkScalar(attribute, kind, item, `${path21}/${index4}`));
-    else checkScalar(attribute, kind, value, path21);
+    if (Array.isArray(value)) value.forEach((item, index4) => checkScalar(attribute, kind, item, `${path22}/${index4}`));
+    else checkScalar(attribute, kind, value, path22);
   }
   function checkItem(item, at2, vocabulary, noun) {
     const kinds = vocabularies[vocabulary];
@@ -177515,17 +178218,17 @@ function checkAgainstProfile(envelope, profile, options2 = {}) {
     const checkAttributes = (values, base) => {
       if (values === null || typeof values !== "object") return;
       for (const [name, value] of Object.entries(values)) {
-        const path21 = `${base}/${segment(name)}`;
+        const path22 = `${base}/${segment(name)}`;
         const attribute = attributes2.get(name);
         if (attribute === void 0) {
           issues.push({
             rule: "profile/undeclared-attribute",
-            path: path21,
+            path: path22,
             message: `kind "${kind}" of profile "${profile.id}" has no attribute "${name}"; it declares ${quoted2([...attributes2.keys()])}`
           });
           continue;
         }
-        checkValue(attribute, kind, value, path21);
+        checkValue(attribute, kind, value, path22);
       }
     };
     checkAttributes(item.attributes, `${at2}/attributes`);
@@ -177650,8 +178353,8 @@ function holdToProfile(envelope, context, options2 = {}) {
 
 // ../shared/src/structuredExchangeProjectRegistry.ts
 import { createHash as createHash2 } from "node:crypto";
-import fs9 from "node:fs/promises";
-import path12 from "node:path";
+import fs10 from "node:fs/promises";
+import path13 from "node:path";
 
 // ../shared/schemas/structured-exchange-profile-1.json
 var structured_exchange_profile_1_default = {
@@ -178168,10 +178871,10 @@ function validateRegistry(value) {
   const registry = value;
   const issues = [];
   const seenPaths = /* @__PURE__ */ new Map();
-  (registry.profiles ?? []).forEach((listed, index4) => {
-    const first = seenPaths.get(listed);
-    if (first === void 0) seenPaths.set(listed, index4);
-    else issues.push({ rule: "registry/repeated-profile-path", path: `/profiles/${index4}`, message: `"${listed}" is already listed at /profiles/${first}` });
+  (registry.profiles ?? []).forEach((listed2, index4) => {
+    const first = seenPaths.get(listed2);
+    if (first === void 0) seenPaths.set(listed2, index4);
+    else issues.push({ rule: "registry/repeated-profile-path", path: `/profiles/${index4}`, message: `"${listed2}" is already listed at /profiles/${first}` });
   });
   return issues.length > 0 ? { valid: false, issues } : { valid: true, registry, issues: [] };
 }
@@ -178545,29 +179248,29 @@ async function realResolve2(target) {
   let tail = "";
   for (; ; ) {
     try {
-      const real = await fs9.realpath(existing);
-      return tail ? path12.join(real, tail) : real;
+      const real = await fs10.realpath(existing);
+      return tail ? path13.join(real, tail) : real;
     } catch {
-      const parent = path12.dirname(existing);
+      const parent = path13.dirname(existing);
       if (parent === existing) return target;
-      tail = tail ? path12.join(path12.basename(existing), tail) : path12.basename(existing);
+      tail = tail ? path13.join(path13.basename(existing), tail) : path13.basename(existing);
       existing = parent;
     }
   }
 }
-var isWithin2 = (root2, target) => target === root2 || target.startsWith(root2 + path12.sep);
+var isWithin2 = (root2, target) => target === root2 || target.startsWith(root2 + path13.sep);
 function digestOf(text7) {
   return `sha256:${createHash2("sha256").update(text7, "utf8").digest("hex")}`;
 }
 async function readConfinedJson(root2, relative, maxBytes, namespace) {
-  const resolved = await realResolve2(path12.resolve(root2, relative));
-  if (path12.isAbsolute(relative) || !isWithin2(root2, resolved)) {
+  const resolved = await realResolve2(path13.resolve(root2, relative));
+  if (path13.isAbsolute(relative) || !isWithin2(root2, resolved)) {
     return {
       ok: false,
       issue: { rule: `${namespace}/outside-project`, path: "", message: `"${relative}" is outside the project directory` }
     };
   }
-  const stat = await fs9.stat(resolved).catch(() => null);
+  const stat = await fs10.stat(resolved).catch(() => null);
   if (stat === null) return { ok: "missing" };
   if (!stat.isFile()) {
     return { ok: false, issue: { rule: `${namespace}/not-a-file`, path: "", message: `"${relative}" is not a file` } };
@@ -178587,7 +179290,7 @@ async function readConfinedJson(root2, relative, maxBytes, namespace) {
   }
   let text7;
   try {
-    text7 = await fs9.readFile(resolved, "utf8");
+    text7 = await fs10.readFile(resolved, "utf8");
   } catch (error) {
     if (error.code === "ENOENT") return { ok: "missing" };
     return { ok: false, issue: { rule: `${namespace}/unreadable`, path: "", message: `"${relative}" cannot be read: ${error.message}` } };
@@ -178599,7 +179302,7 @@ async function readConfinedJson(root2, relative, maxBytes, namespace) {
   }
 }
 async function readProjectRegistry(projectRoot, registryPath = STRUCTURED_EXCHANGE_PROFILE_REGISTRY_PATH) {
-  const root2 = await realResolve2(path12.resolve(projectRoot));
+  const root2 = await realResolve2(path13.resolve(projectRoot));
   const registryFile = registryPath;
   const registryRead = await readConfinedJson(root2, registryFile, STRUCTURED_EXCHANGE_PROFILE_CEILINGS.registryBytes, "registry");
   if (registryRead.ok === "missing") return { state: "none" };
@@ -178612,54 +179315,54 @@ async function readProjectRegistry(projectRoot, registryPath = STRUCTURED_EXCHAN
   const files = [];
   const issues = [];
   const loaded = [];
-  for (const [index4, listed] of (registry.profiles ?? []).entries()) {
-    const read = await readConfinedJson(root2, listed, STRUCTURED_EXCHANGE_PROFILE_CEILINGS.profileBytes, "profile-format");
+  for (const [index4, listed2] of (registry.profiles ?? []).entries()) {
+    const read = await readConfinedJson(root2, listed2, STRUCTURED_EXCHANGE_PROFILE_CEILINGS.profileBytes, "profile-format");
     if (read.ok === "missing") {
-      issues.push({ rule: "registry/missing-profile", path: `/profiles/${index4}`, message: `"${listed}" does not exist`, file: registryFile });
+      issues.push({ rule: "registry/missing-profile", path: `/profiles/${index4}`, message: `"${listed2}" does not exist`, file: registryFile });
       continue;
     }
     if (read.ok === false) {
       issues.push(
-        read.issue.rule === "profile-format/outside-project" ? { ...read.issue, rule: "registry/profile-outside-project", path: `/profiles/${index4}`, file: registryFile } : { ...read.issue, file: listed }
+        read.issue.rule === "profile-format/outside-project" ? { ...read.issue, rule: "registry/profile-outside-project", path: `/profiles/${index4}`, file: registryFile } : { ...read.issue, file: listed2 }
       );
       continue;
     }
     const verdict = validateProfile(read.value);
     if (!verdict.valid) {
-      issues.push(...verdict.issues.map((issue) => ({ ...issue, file: listed })));
+      issues.push(...verdict.issues.map((issue) => ({ ...issue, file: listed2 })));
       continue;
     }
-    loaded.push({ path: listed, profile: verdict.profile });
-    files.push({ path: listed, sha256: read.sha256 });
+    loaded.push({ path: listed2, profile: verdict.profile });
+    files.push({ path: listed2, sha256: read.sha256 });
   }
   if (issues.length > 0) return { state: "unusable", issues };
   const consistency = registryConsistencyIssues(registry, loaded);
   if (consistency.length > 0) return { state: "unusable", issues: consistency.map((issue) => ({ ...issue, file: registryFile })) };
   const profiles = new Map(loaded.map((entry) => [entry.profile.id, entry.profile]));
   const loadedRules = [];
-  for (const [index4, listed] of (registry.rules ?? []).entries()) {
-    const read = await readConfinedJson(root2, listed, STRUCTURED_EXCHANGE_RULES_CEILINGS.rulesBytes, "rules-format");
+  for (const [index4, listed2] of (registry.rules ?? []).entries()) {
+    const read = await readConfinedJson(root2, listed2, STRUCTURED_EXCHANGE_RULES_CEILINGS.rulesBytes, "rules-format");
     if (read.ok === "missing") {
-      issues.push({ rule: "registry/missing-rules", path: `/rules/${index4}`, message: `"${listed}" does not exist`, file: registryFile });
+      issues.push({ rule: "registry/missing-rules", path: `/rules/${index4}`, message: `"${listed2}" does not exist`, file: registryFile });
       continue;
     }
     if (read.ok === false) {
       issues.push(
-        read.issue.rule === "rules-format/outside-project" ? { ...read.issue, rule: "registry/rules-outside-project", path: `/rules/${index4}`, file: registryFile } : { ...read.issue, file: listed }
+        read.issue.rule === "rules-format/outside-project" ? { ...read.issue, rule: "registry/rules-outside-project", path: `/rules/${index4}`, file: registryFile } : { ...read.issue, file: listed2 }
       );
       continue;
     }
     const verdict = validateRules(read.value);
     if (!verdict.valid) {
-      issues.push(...verdict.issues.map((issue) => ({ ...issue, file: listed })));
+      issues.push(...verdict.issues.map((issue) => ({ ...issue, file: listed2 })));
       continue;
     }
     const profile = profiles.get(verdict.rules.profile);
     if (profile !== void 0) {
-      issues.push(...rulesAgainstProfile(verdict.rules, profile).map((issue) => ({ ...issue, file: listed })));
+      issues.push(...rulesAgainstProfile(verdict.rules, profile).map((issue) => ({ ...issue, file: listed2 })));
     }
-    loadedRules.push({ path: listed, rules: verdict.rules });
-    files.push({ path: listed, sha256: read.sha256 });
+    loadedRules.push({ path: listed2, rules: verdict.rules });
+    files.push({ path: listed2, sha256: read.sha256 });
   }
   if (issues.length === 0) {
     issues.push(...registryRulesIssues(loadedRules, profiles).map((issue) => ({ ...issue, file: registryFile })));
@@ -178775,7 +179478,7 @@ function createStructuredExchangeFigureToolDefinition(options2) {
         reference_line: referenceLine,
         comparison
       } = params;
-      const resolved = await realResolve(path13.resolve(options2.cwd, target));
+      const resolved = await realResolve(path14.resolve(options2.cwd, target));
       if (!isWithinAny(options2.allowedRoots, resolved)) {
         throw new Error(`Access denied: "${target}" is outside the sandbox (${options2.allowedRoots[0]})`);
       }
@@ -178788,12 +179491,12 @@ function createStructuredExchangeFigureToolDefinition(options2) {
         cwd: options2.cwd,
         writableRoot: options2.writableRoot
       });
-      const stat = await fs10.stat(resolved).catch(() => null);
+      const stat = await fs11.stat(resolved).catch(() => null);
       if (stat === null || !stat.isFile()) throw new Error(`No such file: ${target}`);
       if (stat.size > options2.maxBytes) {
         throw new Error(`"${target}" is larger than the ${describeSize6(options2.maxBytes)} document limit`);
       }
-      const text7 = await fs10.readFile(resolved, "utf8");
+      const text7 = await fs11.readFile(resolved, "utf8");
       const parsed = parseSerializedStructuredExchange(text7, checkStructuredExchangeSchema, options2.limits);
       let heldTo;
       let appearance;
@@ -178871,9 +179574,9 @@ function createStructuredExchangeFigureToolDefinition(options2) {
           isError: true
         };
       }
-      await fs10.mkdir(path13.dirname(writeTo), { recursive: true });
+      await fs11.mkdir(path14.dirname(writeTo), { recursive: true });
       try {
-        await fs10.writeFile(writeTo, result.svg, { flag: "wx" });
+        await fs11.writeFile(writeTo, result.svg, { flag: "wx" });
       } catch (error) {
         const code3 = error.code;
         if (code3 === "EEXIST") {
@@ -178892,7 +179595,7 @@ function createStructuredExchangeFigureToolDefinition(options2) {
               result.viewpoint === void 0 ? void 0 : `Drawn for viewpoint \`${result.viewpoint.id}\` (${result.viewpoint.label}), declared by ${result.viewpoint.source === "profile" ? `this project's profile "${result.viewpoint.profile}"` : "the document"}.`,
               result.narrowing === void 0 ? void 0 : `The figure states: "${result.narrowing}"`,
               result.overWidth === true ? `The plan is too long to fit the width asked at a legible scale, so the figure is wider than ${width}; split the range or ask for more width.` : void 0,
-              `Reference it from Markdown as a relative path, e.g. \`![${path13.basename(destination, ".svg")}](${destination})\`.`
+              `Reference it from Markdown as a relative path, e.g. \`![${path14.basename(destination, ".svg")}](${destination})\`.`
             ].filter((line) => line !== void 0).join("\n")
           }
         ],
@@ -178903,8 +179606,8 @@ function createStructuredExchangeFigureToolDefinition(options2) {
 }
 
 // ../server/src/timelineComparisonTool.ts
-import fs11 from "node:fs/promises";
-import path14 from "node:path";
+import fs12 from "node:fs/promises";
+import path15 from "node:path";
 
 // ../server/src/structuredExchangeTool.ts
 var DESCRIPTION6 = [
@@ -179114,14 +179817,14 @@ var DESCRIPTION7 = [
   "The current plan is not modified. To put the comparison in a report, give `output_path` and draw it with write_structure_figure."
 ].join(" ");
 async function readTimeline(options2, target) {
-  const resolved = await realResolve(path14.resolve(options2.cwd, target));
+  const resolved = await realResolve(path15.resolve(options2.cwd, target));
   if (!isWithinAny(options2.allowedRoots, resolved)) {
     throw new Error(`Access denied: "${target}" is outside the sandbox (${options2.allowedRoots[0]})`);
   }
-  const stat = await fs11.stat(resolved).catch(() => null);
+  const stat = await fs12.stat(resolved).catch(() => null);
   if (stat === null || !stat.isFile()) throw new Error(`No such file: ${target}`);
   if (stat.size > options2.maxBytes) throw new Error(`"${target}" is larger than the document limit`);
-  const verdict = parseSerializedStructuredExchange(await fs11.readFile(resolved, "utf8"), checkStructuredExchangeSchema, options2.limits);
+  const verdict = parseSerializedStructuredExchange(await fs12.readFile(resolved, "utf8"), checkStructuredExchangeSchema, options2.limits);
   if (!verdict.valid) {
     const lines = verdict.issues.map((issue) => `- ${issue.rule} at ${issue.path === "" ? "(document)" : issue.path}: ${issue.message}`);
     return { ok: false, text: [`\`${target}\` does not satisfy the structured-exchange contract:`, ...lines].join("\n") };
@@ -179131,7 +179834,7 @@ async function readTimeline(options2, target) {
   if (data.comparedTo !== void 0) {
     return { ok: false, text: `\`${target}\` is already a comparison (with "${data.comparedTo.label}"); compare the plans themselves.` };
   }
-  return { ok: true, data, name: path14.basename(target).replace(/\.json$/i, "") };
+  return { ok: true, data, name: path15.basename(target).replace(/\.json$/i, "") };
 }
 function createTimelineComparisonToolDefinition(options2) {
   return {
@@ -179173,9 +179876,9 @@ function createTimelineComparisonToolDefinition(options2) {
         };
       }
       if (writeTo !== void 0) {
-        await fs11.mkdir(path14.dirname(writeTo), { recursive: true });
+        await fs12.mkdir(path15.dirname(writeTo), { recursive: true });
         try {
-          await fs11.writeFile(writeTo, `${JSON.stringify(document4, null, 2)}
+          await fs12.writeFile(writeTo, `${JSON.stringify(document4, null, 2)}
 `, { flag: "wx" });
         } catch (error) {
           if (error.code === "EEXIST") {
@@ -179197,8 +179900,8 @@ function createTimelineComparisonToolDefinition(options2) {
 }
 
 // ../server/src/drawioTool.ts
-import fs12 from "node:fs/promises";
-import path15 from "node:path";
+import fs13 from "node:fs/promises";
+import path16 from "node:path";
 
 // ../server/src/drawio.ts
 import { inflateRawSync } from "node:zlib";
@@ -179459,19 +180162,19 @@ function checkDrawio(xml) {
     issues
   };
 }
-function describeDrawioReport(path21, report) {
+function describeDrawioReport(path22, report) {
   const shapes = report.pages.reduce((sum, page) => sum + page.shapes, 0);
   const connectors = report.pages.reduce((sum, page) => sum + page.connectors, 0);
   const errors = report.issues.filter((issue) => issue.severity === "error");
   const warnings = report.issues.filter((issue) => issue.severity === "warning");
   const summary = `${report.pages.length} page${report.pages.length === 1 ? "" : "s"} (${report.pages.map((page) => `"${page.name}"`).join(", ")}), ${shapes} shape${shapes === 1 ? "" : "s"}, ${connectors} connector${connectors === 1 ? "" : "s"}`;
-  if (report.issues.length === 0) return `\`${path21}\` is a valid draw.io diagram with no defect found: ${summary}.`;
+  if (report.issues.length === 0) return `\`${path22}\` is a valid draw.io diagram with no defect found: ${summary}.`;
   const lines = [
-    errors.length > 0 ? `\`${path21}\` would not open as intended: ${errors.length} error${errors.length === 1 ? "" : "s"} and ${warnings.length} warning${warnings.length === 1 ? "" : "s"}. ${summary}.` : `\`${path21}\` opens, but ${warnings.length} warning${warnings.length === 1 ? "" : "s"} would make it read badly. ${summary}.`
+    errors.length > 0 ? `\`${path22}\` would not open as intended: ${errors.length} error${errors.length === 1 ? "" : "s"} and ${warnings.length} warning${warnings.length === 1 ? "" : "s"}. ${summary}.` : `\`${path22}\` opens, but ${warnings.length} warning${warnings.length === 1 ? "" : "s"} would make it read badly. ${summary}.`
   ];
-  const listed = [...errors, ...warnings].slice(0, MAX_LISTED_ISSUES);
-  for (const issue of listed) lines.push(`- ${issue.severity} [${issue.page}]: ${issue.message}`);
-  if (report.issues.length > listed.length) lines.push(`- \u2026 and ${report.issues.length - listed.length} more`);
+  const listed2 = [...errors, ...warnings].slice(0, MAX_LISTED_ISSUES);
+  for (const issue of listed2) lines.push(`- ${issue.severity} [${issue.page}]: ${issue.message}`);
+  if (report.issues.length > listed2.length) lines.push(`- \u2026 and ${report.issues.length - listed2.length} more`);
   lines.push(errors.length > 0 ? "Fix the errors, then run drawio_check again." : "Move the shapes apart or resize them, then run drawio_check again.");
   return lines.join("\n");
 }
@@ -179496,19 +180199,20 @@ function createDrawioCheckToolDefinition(options2) {
     promptSnippet: "Check a .drawio diagram for errors and layout problems",
     promptGuidelines: [
       "When the user wants a diagram they can open or edit in draw.io, write it as a .drawio file and check it with drawio_check; the interface draws it in the file viewer.",
-      "After every write or edit of a .drawio file, run drawio_check and fix what it reports before saying the diagram is done."
+      "After every write or edit of a .drawio file, run drawio_check and fix what it reports before saying the diagram is done.",
+      "Once drawio_check reports no error, show the diagram in your reply as a picture of the file \u2014 ![name](./path/to/file.drawio) \u2014 where the conversation draws it."
     ],
     parameters: parameters8,
     async execute(_toolCallId, params) {
       const { path: target } = params;
-      const resolved = await realResolve(path15.resolve(options2.cwd, target));
+      const resolved = await realResolve(path16.resolve(options2.cwd, target));
       if (!isWithinAny(options2.allowedRoots, resolved)) {
         throw new Error(`Access denied: "${target}" is outside the sandbox (${options2.allowedRoots[0]})`);
       }
-      const stat = await fs12.stat(resolved).catch(() => null);
+      const stat = await fs13.stat(resolved).catch(() => null);
       if (stat === null || !stat.isFile()) return refused(`No such file: ${target}`);
       if (stat.size > maxBytes) return refused(`"${target}" is larger than the ${Math.round(maxBytes / (1024 * 1024))} MB a diagram may be`);
-      const text7 = await fs12.readFile(resolved, "utf8");
+      const text7 = await fs13.readFile(resolved, "utf8");
       try {
         const report = checkDrawio(text7);
         return { content: [{ type: "text", text: describeDrawioReport(target, report) }], details: void 0 };
@@ -179521,8 +180225,8 @@ function createDrawioCheckToolDefinition(options2) {
 }
 
 // ../server/src/structuredExchangeTableTool.ts
-import fs13 from "node:fs/promises";
-import path16 from "node:path";
+import fs14 from "node:fs/promises";
+import path17 from "node:path";
 
 // ../shared/src/structuredExchangeTableExport.ts
 var ROLE_COLUMN = "change";
@@ -179601,7 +180305,7 @@ function createStructuredExchangeTableToolDefinition(options2) {
     parameters: parameters9,
     async execute(_toolCallId, params) {
       const { path: target, output_path: destination } = params;
-      const resolved = await realResolve(path16.resolve(options2.cwd, target));
+      const resolved = await realResolve(path17.resolve(options2.cwd, target));
       if (!isWithinAny(options2.allowedRoots, resolved)) {
         throw new Error(`Access denied: "${target}" is outside the sandbox (${options2.allowedRoots[0]})`);
       }
@@ -179609,12 +180313,12 @@ function createStructuredExchangeTableToolDefinition(options2) {
         throw new Error(`Cannot write "${destination}": a table is written as Markdown and must be named .md.`);
       }
       const writeTo = await assertWritableDestination(destination, { cwd: options2.cwd, writableRoot: options2.writableRoot });
-      const stat = await fs13.stat(resolved).catch(() => null);
+      const stat = await fs14.stat(resolved).catch(() => null);
       if (stat === null || !stat.isFile()) throw new Error(`No such file: ${target}`);
       if (stat.size > options2.maxBytes) {
         throw new Error(`"${target}" is larger than the ${describeSize7(options2.maxBytes)} document limit`);
       }
-      const verdict = parseSerializedStructuredExchange(await fs13.readFile(resolved, "utf8"), checkStructuredExchangeSchema, options2.limits);
+      const verdict = parseSerializedStructuredExchange(await fs14.readFile(resolved, "utf8"), checkStructuredExchangeSchema, options2.limits);
       if (!verdict.valid) {
         const lines = verdict.issues.map((issue) => `- ${issue.rule} at ${issue.path === "" ? "(document)" : issue.path}: ${issue.message}`);
         return refused2([`No table was written. \`${target}\` does not satisfy the structured-exchange contract:`, ...lines].join("\n"));
@@ -179647,9 +180351,9 @@ function createStructuredExchangeTableToolDefinition(options2) {
       }
       const data = verdict.envelope.data;
       const markdown = tableMarkdown(data);
-      await fs13.mkdir(path16.dirname(writeTo), { recursive: true });
+      await fs14.mkdir(path17.dirname(writeTo), { recursive: true });
       try {
-        await fs13.writeFile(writeTo, markdown, { flag: "wx" });
+        await fs14.writeFile(writeTo, markdown, { flag: "wx" });
       } catch (error) {
         if (error.code === "EEXIST") {
           throw new Error(`"${destination}" already exists; a table is written to a new file only. Choose another path.`);
@@ -179664,7 +180368,7 @@ function createStructuredExchangeTableToolDefinition(options2) {
             type: "text",
             text: [
               `Wrote \`${destination}\` (${Buffer.byteLength(markdown, "utf8")} bytes): ${rows} row${rows === 1 ? "" : "s"}${chapters === 0 ? "" : ` in ${chapters} chapter${chapters === 1 ? "" : "s"}`}.`,
-              `Include it in a Markdown document by copying its content, or link it as \`[${path16.basename(destination, ".md")}](${destination})\`.`
+              `Include it in a Markdown document by copying its content, or link it as \`[${path17.basename(destination, ".md")}](${destination})\`.`
             ].join("\n")
           }
         ],
@@ -179684,26 +180388,26 @@ async function realResolve(target) {
   let tail = "";
   for (; ; ) {
     try {
-      const real = await fs14.realpath(existing);
-      return tail ? path17.join(real, tail) : real;
+      const real = await fs15.realpath(existing);
+      return tail ? path18.join(real, tail) : real;
     } catch {
-      const parent = path17.dirname(existing);
+      const parent = path18.dirname(existing);
       if (parent === existing) return target;
-      tail = tail ? path17.join(path17.basename(existing), tail) : path17.basename(existing);
+      tail = tail ? path18.join(path18.basename(existing), tail) : path18.basename(existing);
       existing = parent;
     }
   }
 }
 function isWithin3(root2, target) {
-  return target === root2 || target.startsWith(root2 + path17.sep);
+  return target === root2 || target.startsWith(root2 + path18.sep);
 }
 function isWithinAny(roots, target) {
   return roots.some((root2) => isWithin3(root2, target));
 }
 function piConfigWriteRefusal(writableRoot, resolved, target) {
-  const relative = path17.relative(writableRoot, resolved);
-  if (relative === "" || relative.startsWith("..") || path17.isAbsolute(relative)) return void 0;
-  if (!relative.split(path17.sep).includes(".pi")) return void 0;
+  const relative = path18.relative(writableRoot, resolved);
+  if (relative === "" || relative.startsWith("..") || path18.isAbsolute(relative)) return void 0;
+  if (!relative.split(path18.sep).includes(".pi")) return void 0;
   return `Cannot write "${target}": it is in a .pi directory, which holds the configuration that confines the agent (Pi settings and extensions, sandbox policies). Edit it yourself if it needs to change.`;
 }
 
@@ -179714,7 +180418,7 @@ async function assertWritableDestination(destination, options2) {
       `Cannot write "${destination}": this sandbox is read-only. Ask for the extraction itself instead.`
     );
   }
-  const resolved = await realResolve(path18.resolve(options2.cwd, destination));
+  const resolved = await realResolve(path19.resolve(options2.cwd, destination));
   if (!isWithin3(options2.writableRoot, resolved)) {
     throw new Error(
       `Cannot write "${destination}": it is outside the writable zone (${options2.writableRoot}). Ask for the extraction itself, or choose a path inside that zone.`
@@ -179728,7 +180432,7 @@ async function writeExtraction(destination, markdown, options2) {
   const resolved = await assertWritableDestination(destination, options2);
   const bytes = Buffer.byteLength(markdown, "utf8");
   try {
-    await fs15.writeFile(resolved, markdown, { flag: "wx" });
+    await fs16.writeFile(resolved, markdown, { flag: "wx" });
   } catch (error) {
     const code3 = error.code;
     if (code3 === "EEXIST") {
@@ -179784,6 +180488,11 @@ var parameters10 = typebox_exports.Object({
       description: "Write the whole extraction to this workspace path and return a summary instead of the content. The file must not already exist."
     })
   ),
+  review: typebox_exports.Optional(
+    typebox_exports.Boolean({
+      description: "Show tracked changes and comments: insertions, deletions and moves marked where they sit, comments on the text they are about, and a closing list with each one's author, date and section. Use it for any question about what changed in a document or what its reviewers said."
+    })
+  ),
   images: imagesParameter
 });
 var DESCRIPTION10 = [
@@ -179791,13 +180500,14 @@ var DESCRIPTION10 = [
   "If the user wants the document saved, converted, or written anywhere, pass output_path: it writes the whole document there in one call and returns a short summary.",
   "Do not return the content and then write it yourself \u2014 that spends the context twice.",
   "Otherwise output is capped per call \u2014 when it is truncated it says so and names the block range to ask for next, or pass full:true to get everything at once.",
-  "Tracked changes are resolved to the accepted text: insertions are kept, deletions are not returned.",
+  "By default tracked changes are resolved to the accepted text \u2014 insertions kept, deletions not returned \u2014 and the answer opens with a line saying how many changes and comments the document holds.",
+  "Pass review: true to see them: {++inserted++}, {--deleted--}, a move marked at both ends, {==commented text==}, each with a reference such as [r1] or [c1] listed at the end with its author, date, section and, for a comment, its text, replies and whether it is resolved. Formatting changes are not reported. The document is never modified.",
   "Text the document crosses out is returned as ~~struck through~~ and means the document withdrew it \u2014 do not treat it as current, and say which passages are struck when you transcribe, quote or summarise the document.",
   "Bold and italic runs are returned as markdown emphasis; underline has no markdown equivalent and is not marked.",
   "Only formatting written on the run itself is read, so strikethrough applied through a character style is not detected.",
   'Each picture is named where it sits, as [picture 3: PNG 800\xD7600 \u2014 "its alt text"]; pass images: "all" to get them as images too, or images: ["3"] for one by its number.',
   "A picture whose bytes cannot be shown \u2014 a metafile, a missing part \u2014 is still named, with the reason, so nothing the document holds goes unmentioned.",
-  "Headers, footers, footnotes, comments and text boxes are not read. Charts, diagrams and grouped shapes are not pictures and have no bytes to return; call docx_render to see those."
+  "Headers, footers, footnotes and text boxes are not read, nor are comments unless review is true. Charts, diagrams and grouped shapes are not pictures and have no bytes to return; call docx_render to see those."
 ].join(" ");
 var LARGE_ANSWER_CHARS5 = 6e4;
 function describeSize8(bytes) {
@@ -179821,13 +180531,14 @@ function createDocxExtractToolDefinition(options2) {
         mode,
         full,
         output_path: destination,
+        review,
         images = "none"
       } = params;
-      const resolved = await realResolve(path19.resolve(options2.cwd, target));
+      const resolved = await realResolve(path20.resolve(options2.cwd, target));
       if (!isWithinAny(options2.allowedRoots, resolved)) {
         throw new Error(`Access denied: "${target}" is outside the sandbox (${options2.allowedRoots[0]})`);
       }
-      const stat = await fs16.stat(resolved).catch(() => null);
+      const stat = await fs17.stat(resolved).catch(() => null);
       if (stat === null || !stat.isFile()) throw new Error(`No such file: ${target}`);
       if (stat.size > options2.maxBytes) {
         throw new Error(`"${target}" is larger than the ${describeSize8(options2.maxBytes)} Word limit`);
@@ -179838,10 +180549,11 @@ function createDocxExtractToolDefinition(options2) {
       const wholeDocument = full === true || destination !== void 0;
       let extraction;
       try {
-        extraction = await extractDocx(new Uint8Array(await fs16.readFile(resolved)), {
+        extraction = await extractDocx(new Uint8Array(await fs17.readFile(resolved)), {
           ...blocks === void 0 ? {} : { blocks },
           ...mode === void 0 ? {} : { mode },
-          ...wholeDocument ? { full: true } : {}
+          ...wholeDocument ? { full: true } : {},
+          ...review === true ? { review: true } : {}
         });
       } catch (error) {
         if (error instanceof DocxError) throw new Error(error.message);
@@ -180438,13 +181150,13 @@ function mutateWorkPlan(current, mutation) {
 }
 
 // ../server/src/workPlanStore.ts
-import fs17 from "node:fs/promises";
-import path20 from "node:path";
+import fs18 from "node:fs/promises";
+import path21 from "node:path";
 var workPlanPath = (sessionFile) => `${sessionFile}.work-plan.json`;
 async function loadWorkPlan(sessionFile) {
   if (!sessionFile) return null;
   try {
-    return validateWorkPlan(JSON.parse(await fs17.readFile(workPlanPath(sessionFile), "utf8")));
+    return validateWorkPlan(JSON.parse(await fs18.readFile(workPlanPath(sessionFile), "utf8")));
   } catch (error) {
     if (error.code === "ENOENT") return null;
     throw new Error(`Cannot load the Work Plan: ${error instanceof Error ? error.message : String(error)}`);
@@ -180453,18 +181165,18 @@ async function loadWorkPlan(sessionFile) {
 async function persist(sessionFile, plan) {
   const target = workPlanPath(sessionFile);
   if (plan === null) {
-    await fs17.unlink(target).catch((error) => {
+    await fs18.unlink(target).catch((error) => {
       if (error.code !== "ENOENT") throw error;
     });
     return;
   }
-  const temporary = path20.join(path20.dirname(target), `.${path20.basename(target)}.${process.pid}.${Date.now()}.tmp`);
+  const temporary = path21.join(path21.dirname(target), `.${path21.basename(target)}.${process.pid}.${Date.now()}.tmp`);
   try {
-    await fs17.writeFile(temporary, `${JSON.stringify(plan, null, 2)}
+    await fs18.writeFile(temporary, `${JSON.stringify(plan, null, 2)}
 `, { encoding: "utf8", mode: 384, flag: "wx" });
-    await fs17.rename(temporary, target);
+    await fs18.rename(temporary, target);
   } catch (error) {
-    await fs17.unlink(temporary).catch(() => {
+    await fs18.unlink(temporary).catch(() => {
     });
     throw error;
   }
@@ -180732,7 +181444,7 @@ function parseToolsSettings(raw) {
 }
 async function createPiOutpostTools(settings2) {
   const cwd = settings2.cwd;
-  const root2 = await fs18.realpath(cwd);
+  const root2 = await fs19.realpath(cwd);
   const common = { cwd, allowedRoots: [root2], writableRoot: root2 };
   const render3 = settings2.officeRender ?? { renderer: "auto", timeoutMs: DEFAULT_RENDER_TIMEOUT_MS };
   return [
@@ -180750,6 +181462,8 @@ async function createPiOutpostTools(settings2) {
     createDocxUpdateToolDefinition({ ...common, maxBytes: settings2.maxBytes.docx, render: render3 }),
     createDocxRestyleToolDefinition({ ...common, maxBytes: settings2.maxBytes.docx, render: render3 }),
     createDocxRenderToolDefinition({ ...common, maxBytes: settings2.maxBytes.docx, render: render3 }),
+    // Comparing two versions drives Word itself: Windows only.
+    ...process.platform === "win32" ? [createDocxCompareToolDefinition({ ...common, maxBytes: settings2.maxBytes.docx, render: render3 })] : [],
     createStructuredExchangeFigureToolDefinition({ ...common, maxBytes: settings2.maxBytes.structuredExchange, projectRoot: root2 }),
     createStructuredExchangeTableToolDefinition({ ...common, maxBytes: settings2.maxBytes.structuredExchange, projectRoot: root2 }),
     createTimelineComparisonToolDefinition({ ...common, maxBytes: settings2.maxBytes.structuredExchange }),