@fenfill/mcp 0.2.3 → 0.2.4

package/dist/index.js

@@ -7211,6 +7211,88 @@ var require_dist = __commonJS({
   }
 });
 
+// ../../app/t/[template_id]/bidiText.ts
+function inRtlBlock(cp) {
+  for (const [a, b] of RTL_BLOCKS) {
+    if (cp < a) return false;
+    if (cp <= b) return true;
+  }
+  return false;
+}
+function stripBidiControls(text) {
+  return text.replace(BIDI_CONTROLS, "");
+}
+function needsBidi(text) {
+  for (const ch of text) {
+    if (inRtlBlock(ch.codePointAt(0) ?? 0)) return true;
+  }
+  return false;
+}
+function marksNeedBidi(marksByPage) {
+  for (const marks of marksByPage.values()) {
+    for (const m of marks) {
+      if (m.text && needsBidi(m.text)) return true;
+    }
+  }
+  return false;
+}
+function strongDirection(ch) {
+  const cp = ch.codePointAt(0) ?? 0;
+  if (cp === 8207 || cp === 1564) return "rtl";
+  if (cp === 8206) return "ltr";
+  if (!LETTER.test(ch)) return null;
+  for (const [a, b] of NEUTRAL_LETTERS) if (cp >= a && cp <= b) return null;
+  return inRtlBlock(cp) ? "rtl" : "ltr";
+}
+function isRtlDominant(text) {
+  for (const ch of text) {
+    const d = strongDirection(ch);
+    if (d) return d === "rtl";
+  }
+  return false;
+}
+function bidiAnchor(anchor2, rtl) {
+  if (!rtl) return anchor2;
+  switch (anchor2) {
+    case "top-left":
+      return "top-right";
+    case "middle-left":
+      return "middle-right";
+    case "bottom-left":
+      return "bottom-right";
+    default:
+      return anchor2;
+  }
+}
+function stampsRtl(text) {
+  return needsBidi(text) && isRtlDominant(text);
+}
+var RTL_BLOCKS, BIDI_CONTROLS, NEUTRAL_LETTERS, LETTER;
+var init_bidiText = __esm({
+  "../../app/t/[template_id]/bidiText.ts"() {
+    "use strict";
+    RTL_BLOCKS = [
+      [1424, 2303],
+      [64285, 65023],
+      [65136, 65279],
+      [67584, 69631],
+      [124928, 126975]
+    ];
+    BIDI_CONTROLS = /[\u061c\u200e\u200f\u202a-\u202e\u2066-\u2069]/g;
+    NEUTRAL_LETTERS = [
+      [697, 698],
+      [710, 719],
+      [748, 748],
+      [884, 884],
+      [11823, 11823],
+      [42623, 42623],
+      [42775, 42783],
+      [42888, 42888]
+    ];
+    LETTER = new RegExp("\\p{L}", "u");
+  }
+});
+
 // ../../node_modules/pdf-lib/node_modules/tslib/tslib.es6.js
 var tslib_es6_exports = {};
 __export(tslib_es6_exports, {
@@ -58065,7 +58147,7 @@ var require_fontkit_umd = __commonJS({
           plan.addStage(["pref"]);
           plan.addStage(recordPref);
           plan.addStage(["rkrf", "abvf", "blwf", "half", "pstf", "vatu", "cjct"]);
-          plan.addStage(reorder2);
+          plan.addStage(reorder3);
           plan.addStage(["abvs", "blws", "pres", "psts", "dist", "abvm", "blwm"]);
         };
         UniversalShaper2.assignFeatures = function assignFeatures(plan, glyphs) {
@@ -58130,7 +58212,7 @@ var require_fontkit_umd = __commonJS({
           }
         }
       }
-      function reorder2(font, glyphs) {
+      function reorder3(font, glyphs) {
         var dottedCircle = font.glyphForCodePoint(9676).id;
         for (var start = 0, end = nextSyllable$1(glyphs, 0); start < glyphs.length; start = end, end = nextSyllable$1(glyphs, start)) {
           var i3 = void 0, j = void 0;
@@ -99623,6 +99705,1043 @@ var init_decryptPdf = __esm({
   }
 });
 
+// ../../node_modules/bidi-js/dist/bidi.js
+var require_bidi = __commonJS({
+  "../../node_modules/bidi-js/dist/bidi.js"(exports, module) {
+    "use strict";
+    (function(global2, factory) {
+      typeof exports === "object" && typeof module !== "undefined" ? module.exports = factory() : typeof define === "function" && define.amd ? define(factory) : (global2 = typeof globalThis !== "undefined" ? globalThis : global2 || self, global2.bidi_js = factory());
+    })(exports, (function() {
+      "use strict";
+      function bidiFactory2() {
+        var bidi2 = (function(exports2) {
+          var DATA = {
+            "R": "13k,1a,2,3,3,2+1j,ch+16,a+1,5+2,2+n,5,a,4,6+16,4+3,h+1b,4mo,179q,2+9,2+11,2i9+7y,2+68,4,3+4,5+13,4+3,2+4k,3+29,8+cf,1t+7z,w+17,3+3m,1t+3z,16o1+5r,8+30,8+mc,29+1r,29+4v,75+73",
+            "EN": "1c+9,3d+1,6,187+9,513,4+5,7+9,sf+j,175h+9,qw+q,161f+1d,4xt+a,25i+9",
+            "ES": "17,2,6dp+1,f+1,av,16vr,mx+1,4o,2",
+            "ET": "z+2,3h+3,b+1,ym,3e+1,2o,p4+1,8,6u,7c,g6,1wc,1n9+4,30+1b,2n,6d,qhx+1,h0m,a+1,49+2,63+1,4+1,6bb+3,12jj",
+            "AN": "16o+5,2j+9,2+1,35,ed,1ff2+9,87+u",
+            "CS": "18,2+1,b,2u,12k,55v,l,17v0,2,3,53,2+1,b",
+            "B": "a,3,f+2,2v,690",
+            "S": "9,2,k",
+            "WS": "c,k,4f4,1vk+a,u,1j,335",
+            "ON": "x+1,4+4,h+5,r+5,r+3,z,5+3,2+1,2+1,5,2+2,3+4,o,w,ci+1,8+d,3+d,6+8,2+g,39+1,9,6+1,2,33,b8,3+1,3c+1,7+1,5r,b,7h+3,sa+5,2,3i+6,jg+3,ur+9,2v,ij+1,9g+9,7+a,8m,4+1,49+x,14u,2+2,c+2,e+2,e+2,e+1,i+n,e+e,2+p,u+2,e+2,36+1,2+3,2+1,b,2+2,6+5,2,2,2,h+1,5+4,6+3,3+f,16+2,5+3l,3+81,1y+p,2+40,q+a,m+13,2r+ch,2+9e,75+hf,3+v,2+2w,6e+5,f+6,75+2a,1a+p,2+2g,d+5x,r+b,6+3,4+o,g,6+1,6+2,2k+1,4,2j,5h+z,1m+1,1e+f,t+2,1f+e,d+3,4o+3,2s+1,w,535+1r,h3l+1i,93+2,2s,b+1,3l+x,2v,4g+3,21+3,kz+1,g5v+1,5a,j+9,n+v,2,3,2+8,2+1,3+2,2,3,46+1,4+4,h+5,r+5,r+a,3h+2,4+6,b+4,78,1r+24,4+c,4,1hb,ey+6,103+j,16j+c,1ux+7,5+g,fsh,jdq+1t,4,57+2e,p1,1m,1m,1m,1m,4kt+1,7j+17,5+2r,d+e,3+e,2+e,2+10,m+4,w,1n+5,1q,4z+5,4b+rb,9+c,4+c,4+37,d+2g,8+b,l+b,5+1j,9+9,7+13,9+t,3+1,27+3c,2+29,2+3q,d+d,3+4,4+2,6+6,a+o,8+6,a+2,e+6,16+42,2+1i",
+            "BN": "0+8,6+d,2s+5,2+p,e,4m9,1kt+2,2b+5,5+5,17q9+v,7k,6p+8,6+1,119d+3,440+7,96s+1,1ekf+1,1ekf+1,1ekf+1,1ekf+1,1ekf+1,1ekf+1,1ekf+1,1ekf+1,1ekf+1,1ekf+1,1ekf+1,1ekf+75,6p+2rz,1ben+1,1ekf+1,1ekf+1",
+            "NSM": "lc+33,7o+6,7c+18,2,2+1,2+1,2,21+a,1d+k,h,2u+6,3+5,3+1,2+3,10,v+q,2k+a,1n+8,a,p+3,2+8,2+2,2+4,18+2,3c+e,2+v,1k,2,5+7,5,4+6,b+1,u,1n,5+3,9,l+1,r,3+1,1m,5+1,5+1,3+2,4,v+1,4,c+1,1m,5+4,2+1,5,l+1,n+5,2,1n,3,2+3,9,8+1,c+1,v,1q,d,1f,4,1m+2,6+2,2+3,8+1,c+1,u,1n,g+1,l+1,t+1,1m+1,5+3,9,l+1,u,21,8+2,2,2j,3+6,d+7,2r,3+8,c+5,23+1,s,2,2,1k+d,2+4,2+1,6+a,2+z,a,2v+3,2+5,2+1,3+1,q+1,5+2,h+3,e,3+1,7,g,jk+2,qb+2,u+2,u+1,v+1,1t+1,2+6,9,3+a,a,1a+2,3c+1,z,3b+2,5+1,a,7+2,64+1,3,1n,2+6,2,2,3+7,7+9,3,1d+g,1s+3,1d,2+4,2,6,15+8,d+1,x+3,3+1,2+2,1l,2+1,4,2+2,1n+7,3+1,49+2,2+c,2+6,5,7,4+1,5j+1l,2+4,k1+w,2db+2,3y,2p+v,ff+3,30+1,n9x+3,2+9,x+1,29+1,7l,4,5,q+1,6,48+1,r+h,e,13+7,q+a,1b+2,1d,3+3,3+1,14,1w+5,3+1,3+1,d,9,1c,1g,2+2,3+1,6+1,2,17+1,9,6n,3,5,fn5,ki+f,h+f,r2,6b,46+4,1af+2,2+1,6+3,15+2,5,4m+1,fy+3,as+1,4a+a,4x,1j+e,1l+2,1e+3,3+1,1y+2,11+4,2+7,1r,d+1,1h+8,b+3,3,2o+2,3,2+1,7,4h,4+7,m+1,1m+1,4,12+6,4+4,5g+7,3+2,2,o,2d+5,2,5+1,2+1,6n+3,7+1,2+1,s+1,2e+7,3,2+1,2z,2,3+5,2,2u+2,3+3,2+4,78+8,2+1,75+1,2,5,41+3,3+1,5,x+5,3+1,15+5,3+3,9,a+5,3+2,1b+c,2+1,bb+6,2+5,2d+l,3+6,2+1,2+1,3f+5,4,2+1,2+6,2,21+1,4,2,9o+1,f0c+4,1o+6,t5,1s+3,2a,f5l+1,43t+2,i+7,3+6,v+3,45+2,1j0+1i,5+1d,9,f,n+4,2+e,11t+6,2+g,3+6,2+1,2+4,7a+6,c6+3,15t+6,32+6,gzhy+6n",
+            "AL": "16w,3,2,e+1b,z+2,2+2s,g+1,8+1,b+m,2+t,s+2i,c+e,4h+f,1d+1e,1bwe+dp,3+3z,x+c,2+1,35+3y,2rm+z,5+7,b+5,dt+l,c+u,17nl+27,1t+27,4x+6n,3+d",
+            "LRO": "6ct",
+            "RLO": "6cu",
+            "LRE": "6cq",
+            "RLE": "6cr",
+            "PDF": "6cs",
+            "LRI": "6ee",
+            "RLI": "6ef",
+            "FSI": "6eg",
+            "PDI": "6eh"
+          };
+          var TYPES = {};
+          var TYPES_TO_NAMES = {};
+          TYPES.L = 1;
+          TYPES_TO_NAMES[1] = "L";
+          Object.keys(DATA).forEach(function(type, i2) {
+            TYPES[type] = 1 << i2 + 1;
+            TYPES_TO_NAMES[TYPES[type]] = type;
+          });
+          Object.freeze(TYPES);
+          var ISOLATE_INIT_TYPES = TYPES.LRI | TYPES.RLI | TYPES.FSI;
+          var STRONG_TYPES = TYPES.L | TYPES.R | TYPES.AL;
+          var NEUTRAL_ISOLATE_TYPES = TYPES.B | TYPES.S | TYPES.WS | TYPES.ON | TYPES.FSI | TYPES.LRI | TYPES.RLI | TYPES.PDI;
+          var BN_LIKE_TYPES = TYPES.BN | TYPES.RLE | TYPES.LRE | TYPES.RLO | TYPES.LRO | TYPES.PDF;
+          var TRAILING_TYPES = TYPES.S | TYPES.WS | TYPES.B | ISOLATE_INIT_TYPES | TYPES.PDI | BN_LIKE_TYPES;
+          var map2 = null;
+          function parseData() {
+            if (!map2) {
+              map2 = /* @__PURE__ */ new Map();
+              var loop = function(type2) {
+                if (DATA.hasOwnProperty(type2)) {
+                  var lastCode = 0;
+                  DATA[type2].split(",").forEach(function(range4) {
+                    var ref = range4.split("+");
+                    var skip = ref[0];
+                    var step = ref[1];
+                    skip = parseInt(skip, 36);
+                    step = step ? parseInt(step, 36) : 0;
+                    map2.set(lastCode += skip, TYPES[type2]);
+                    for (var i2 = 0; i2 < step; i2++) {
+                      map2.set(++lastCode, TYPES[type2]);
+                    }
+                  });
+                }
+              };
+              for (var type in DATA) loop(type);
+            }
+          }
+          function getBidiCharType(char) {
+            parseData();
+            return map2.get(char.codePointAt(0)) || TYPES.L;
+          }
+          function getBidiCharTypeName(char) {
+            return TYPES_TO_NAMES[getBidiCharType(char)];
+          }
+          var data$1 = {
+            "pairs": "14>1,1e>2,u>2,2wt>1,1>1,1ge>1,1wp>1,1j>1,f>1,hm>1,1>1,u>1,u6>1,1>1,+5,28>1,w>1,1>1,+3,b8>1,1>1,+3,1>3,-1>-1,3>1,1>1,+2,1s>1,1>1,x>1,th>1,1>1,+2,db>1,1>1,+3,3>1,1>1,+2,14qm>1,1>1,+1,4q>1,1e>2,u>2,2>1,+1",
+            "canonical": "6f1>-6dx,6dy>-6dx,6ec>-6ed,6ee>-6ed,6ww>2jj,-2ji>2jj,14r4>-1e7l,1e7m>-1e7l,1e7m>-1e5c,1e5d>-1e5b,1e5c>-14qx,14qy>-14qx,14vn>-1ecg,1ech>-1ecg,1edu>-1ecg,1eci>-1ecg,1eda>-1ecg,1eci>-1ecg,1eci>-168q,168r>-168q,168s>-14ye,14yf>-14ye"
+          };
+          function parseCharacterMap(encodedString, includeReverse) {
+            var radix = 36;
+            var lastCode = 0;
+            var map3 = /* @__PURE__ */ new Map();
+            var reverseMap = includeReverse && /* @__PURE__ */ new Map();
+            var prevPair;
+            encodedString.split(",").forEach(function visit2(entry) {
+              if (entry.indexOf("+") !== -1) {
+                for (var i2 = +entry; i2--; ) {
+                  visit2(prevPair);
+                }
+              } else {
+                prevPair = entry;
+                var ref = entry.split(">");
+                var a = ref[0];
+                var b = ref[1];
+                a = String.fromCodePoint(lastCode += parseInt(a, radix));
+                b = String.fromCodePoint(lastCode += parseInt(b, radix));
+                map3.set(a, b);
+                includeReverse && reverseMap.set(b, a);
+              }
+            });
+            return { map: map3, reverseMap };
+          }
+          var openToClose, closeToOpen, canonical;
+          function parse$1() {
+            if (!openToClose) {
+              var ref = parseCharacterMap(data$1.pairs, true);
+              var map3 = ref.map;
+              var reverseMap = ref.reverseMap;
+              openToClose = map3;
+              closeToOpen = reverseMap;
+              canonical = parseCharacterMap(data$1.canonical, false).map;
+            }
+          }
+          function openingToClosingBracket(char) {
+            parse$1();
+            return openToClose.get(char) || null;
+          }
+          function closingToOpeningBracket(char) {
+            parse$1();
+            return closeToOpen.get(char) || null;
+          }
+          function getCanonicalBracket(char) {
+            parse$1();
+            return canonical.get(char) || null;
+          }
+          var TYPE_L = TYPES.L;
+          var TYPE_R = TYPES.R;
+          var TYPE_EN = TYPES.EN;
+          var TYPE_ES = TYPES.ES;
+          var TYPE_ET = TYPES.ET;
+          var TYPE_AN = TYPES.AN;
+          var TYPE_CS = TYPES.CS;
+          var TYPE_B = TYPES.B;
+          var TYPE_S = TYPES.S;
+          var TYPE_ON = TYPES.ON;
+          var TYPE_BN = TYPES.BN;
+          var TYPE_NSM = TYPES.NSM;
+          var TYPE_AL = TYPES.AL;
+          var TYPE_LRO = TYPES.LRO;
+          var TYPE_RLO = TYPES.RLO;
+          var TYPE_LRE = TYPES.LRE;
+          var TYPE_RLE = TYPES.RLE;
+          var TYPE_PDF = TYPES.PDF;
+          var TYPE_LRI = TYPES.LRI;
+          var TYPE_RLI = TYPES.RLI;
+          var TYPE_FSI = TYPES.FSI;
+          var TYPE_PDI = TYPES.PDI;
+          function getEmbeddingLevels(string4, baseDirection) {
+            var MAX_DEPTH = 125;
+            var charTypes = new Uint32Array(string4.length);
+            for (var i2 = 0; i2 < string4.length; i2++) {
+              charTypes[i2] = getBidiCharType(string4[i2]);
+            }
+            var charTypeCounts = /* @__PURE__ */ new Map();
+            function changeCharType(i3, type2) {
+              var oldType = charTypes[i3];
+              charTypes[i3] = type2;
+              charTypeCounts.set(oldType, charTypeCounts.get(oldType) - 1);
+              if (oldType & NEUTRAL_ISOLATE_TYPES) {
+                charTypeCounts.set(NEUTRAL_ISOLATE_TYPES, charTypeCounts.get(NEUTRAL_ISOLATE_TYPES) - 1);
+              }
+              charTypeCounts.set(type2, (charTypeCounts.get(type2) || 0) + 1);
+              if (type2 & NEUTRAL_ISOLATE_TYPES) {
+                charTypeCounts.set(NEUTRAL_ISOLATE_TYPES, (charTypeCounts.get(NEUTRAL_ISOLATE_TYPES) || 0) + 1);
+              }
+            }
+            var embedLevels = new Uint8Array(string4.length);
+            var isolationPairs = /* @__PURE__ */ new Map();
+            var paragraphs = [];
+            var paragraph = null;
+            for (var i$1 = 0; i$1 < string4.length; i$1++) {
+              if (!paragraph) {
+                paragraphs.push(paragraph = {
+                  start: i$1,
+                  end: string4.length - 1,
+                  // 3.3.1 P2-P3: Determine the paragraph level
+                  level: baseDirection === "rtl" ? 1 : baseDirection === "ltr" ? 0 : determineAutoEmbedLevel(i$1, false)
+                });
+              }
+              if (charTypes[i$1] & TYPE_B) {
+                paragraph.end = i$1;
+                paragraph = null;
+              }
+            }
+            var FORMATTING_TYPES = TYPE_RLE | TYPE_LRE | TYPE_RLO | TYPE_LRO | ISOLATE_INIT_TYPES | TYPE_PDI | TYPE_PDF | TYPE_B;
+            var nextEven = function(n) {
+              return n + (n & 1 ? 1 : 2);
+            };
+            var nextOdd = function(n) {
+              return n + (n & 1 ? 2 : 1);
+            };
+            for (var paraIdx = 0; paraIdx < paragraphs.length; paraIdx++) {
+              paragraph = paragraphs[paraIdx];
+              var statusStack = [{
+                _level: paragraph.level,
+                _override: 0,
+                //0=neutral, 1=L, 2=R
+                _isolate: 0
+                //bool
+              }];
+              var stackTop = void 0;
+              var overflowIsolateCount = 0;
+              var overflowEmbeddingCount = 0;
+              var validIsolateCount = 0;
+              charTypeCounts.clear();
+              for (var i$2 = paragraph.start; i$2 <= paragraph.end; i$2++) {
+                var charType = charTypes[i$2];
+                stackTop = statusStack[statusStack.length - 1];
+                charTypeCounts.set(charType, (charTypeCounts.get(charType) || 0) + 1);
+                if (charType & NEUTRAL_ISOLATE_TYPES) {
+                  charTypeCounts.set(NEUTRAL_ISOLATE_TYPES, (charTypeCounts.get(NEUTRAL_ISOLATE_TYPES) || 0) + 1);
+                }
+                if (charType & FORMATTING_TYPES) {
+                  if (charType & (TYPE_RLE | TYPE_LRE)) {
+                    embedLevels[i$2] = stackTop._level;
+                    var level = (charType === TYPE_RLE ? nextOdd : nextEven)(stackTop._level);
+                    if (level <= MAX_DEPTH && !overflowIsolateCount && !overflowEmbeddingCount) {
+                      statusStack.push({
+                        _level: level,
+                        _override: 0,
+                        _isolate: 0
+                      });
+                    } else if (!overflowIsolateCount) {
+                      overflowEmbeddingCount++;
+                    }
+                  } else if (charType & (TYPE_RLO | TYPE_LRO)) {
+                    embedLevels[i$2] = stackTop._level;
+                    var level$1 = (charType === TYPE_RLO ? nextOdd : nextEven)(stackTop._level);
+                    if (level$1 <= MAX_DEPTH && !overflowIsolateCount && !overflowEmbeddingCount) {
+                      statusStack.push({
+                        _level: level$1,
+                        _override: charType & TYPE_RLO ? TYPE_R : TYPE_L,
+                        _isolate: 0
+                      });
+                    } else if (!overflowIsolateCount) {
+                      overflowEmbeddingCount++;
+                    }
+                  } else if (charType & ISOLATE_INIT_TYPES) {
+                    if (charType & TYPE_FSI) {
+                      charType = determineAutoEmbedLevel(i$2 + 1, true) === 1 ? TYPE_RLI : TYPE_LRI;
+                    }
+                    embedLevels[i$2] = stackTop._level;
+                    if (stackTop._override) {
+                      changeCharType(i$2, stackTop._override);
+                    }
+                    var level$2 = (charType === TYPE_RLI ? nextOdd : nextEven)(stackTop._level);
+                    if (level$2 <= MAX_DEPTH && overflowIsolateCount === 0 && overflowEmbeddingCount === 0) {
+                      validIsolateCount++;
+                      statusStack.push({
+                        _level: level$2,
+                        _override: 0,
+                        _isolate: 1,
+                        _isolInitIndex: i$2
+                      });
+                    } else {
+                      overflowIsolateCount++;
+                    }
+                  } else if (charType & TYPE_PDI) {
+                    if (overflowIsolateCount > 0) {
+                      overflowIsolateCount--;
+                    } else if (validIsolateCount > 0) {
+                      overflowEmbeddingCount = 0;
+                      while (!statusStack[statusStack.length - 1]._isolate) {
+                        statusStack.pop();
+                      }
+                      var isolInitIndex = statusStack[statusStack.length - 1]._isolInitIndex;
+                      if (isolInitIndex != null) {
+                        isolationPairs.set(isolInitIndex, i$2);
+                        isolationPairs.set(i$2, isolInitIndex);
+                      }
+                      statusStack.pop();
+                      validIsolateCount--;
+                    }
+                    stackTop = statusStack[statusStack.length - 1];
+                    embedLevels[i$2] = stackTop._level;
+                    if (stackTop._override) {
+                      changeCharType(i$2, stackTop._override);
+                    }
+                  } else if (charType & TYPE_PDF) {
+                    if (overflowIsolateCount === 0) {
+                      if (overflowEmbeddingCount > 0) {
+                        overflowEmbeddingCount--;
+                      } else if (!stackTop._isolate && statusStack.length > 1) {
+                        statusStack.pop();
+                        stackTop = statusStack[statusStack.length - 1];
+                      }
+                    }
+                    embedLevels[i$2] = stackTop._level;
+                  } else if (charType & TYPE_B) {
+                    embedLevels[i$2] = paragraph.level;
+                  }
+                } else {
+                  embedLevels[i$2] = stackTop._level;
+                  if (stackTop._override && charType !== TYPE_BN) {
+                    changeCharType(i$2, stackTop._override);
+                  }
+                }
+              }
+              var levelRuns = [];
+              var currentRun = null;
+              for (var i$3 = paragraph.start; i$3 <= paragraph.end; i$3++) {
+                var charType$1 = charTypes[i$3];
+                if (!(charType$1 & BN_LIKE_TYPES)) {
+                  var lvl = embedLevels[i$3];
+                  var isIsolInit = charType$1 & ISOLATE_INIT_TYPES;
+                  var isPDI = charType$1 === TYPE_PDI;
+                  if (currentRun && lvl === currentRun._level) {
+                    currentRun._end = i$3;
+                    currentRun._endsWithIsolInit = isIsolInit;
+                  } else {
+                    levelRuns.push(currentRun = {
+                      _start: i$3,
+                      _end: i$3,
+                      _level: lvl,
+                      _startsWithPDI: isPDI,
+                      _endsWithIsolInit: isIsolInit
+                    });
+                  }
+                }
+              }
+              var isolatingRunSeqs = [];
+              for (var runIdx = 0; runIdx < levelRuns.length; runIdx++) {
+                var run = levelRuns[runIdx];
+                if (!run._startsWithPDI || run._startsWithPDI && !isolationPairs.has(run._start)) {
+                  var seqRuns = [currentRun = run];
+                  for (var pdiIndex = void 0; currentRun && currentRun._endsWithIsolInit && (pdiIndex = isolationPairs.get(currentRun._end)) != null; ) {
+                    for (var i$4 = runIdx + 1; i$4 < levelRuns.length; i$4++) {
+                      if (levelRuns[i$4]._start === pdiIndex) {
+                        seqRuns.push(currentRun = levelRuns[i$4]);
+                        break;
+                      }
+                    }
+                  }
+                  var seqIndices = [];
+                  for (var i$5 = 0; i$5 < seqRuns.length; i$5++) {
+                    var run$1 = seqRuns[i$5];
+                    for (var j = run$1._start; j <= run$1._end; j++) {
+                      seqIndices.push(j);
+                    }
+                  }
+                  var firstLevel = embedLevels[seqIndices[0]];
+                  var prevLevel = paragraph.level;
+                  for (var i$6 = seqIndices[0] - 1; i$6 >= 0; i$6--) {
+                    if (!(charTypes[i$6] & BN_LIKE_TYPES)) {
+                      prevLevel = embedLevels[i$6];
+                      break;
+                    }
+                  }
+                  var lastIndex = seqIndices[seqIndices.length - 1];
+                  var lastLevel = embedLevels[lastIndex];
+                  var nextLevel = paragraph.level;
+                  if (!(charTypes[lastIndex] & ISOLATE_INIT_TYPES)) {
+                    for (var i$7 = lastIndex + 1; i$7 <= paragraph.end; i$7++) {
+                      if (!(charTypes[i$7] & BN_LIKE_TYPES)) {
+                        nextLevel = embedLevels[i$7];
+                        break;
+                      }
+                    }
+                  }
+                  isolatingRunSeqs.push({
+                    _seqIndices: seqIndices,
+                    _sosType: Math.max(prevLevel, firstLevel) % 2 ? TYPE_R : TYPE_L,
+                    _eosType: Math.max(nextLevel, lastLevel) % 2 ? TYPE_R : TYPE_L
+                  });
+                }
+              }
+              for (var seqIdx = 0; seqIdx < isolatingRunSeqs.length; seqIdx++) {
+                var ref = isolatingRunSeqs[seqIdx];
+                var seqIndices$1 = ref._seqIndices;
+                var sosType = ref._sosType;
+                var eosType = ref._eosType;
+                var embedDirection = embedLevels[seqIndices$1[0]] & 1 ? TYPE_R : TYPE_L;
+                if (charTypeCounts.get(TYPE_NSM)) {
+                  for (var si = 0; si < seqIndices$1.length; si++) {
+                    var i$8 = seqIndices$1[si];
+                    if (charTypes[i$8] & TYPE_NSM) {
+                      var prevType = sosType;
+                      for (var sj = si - 1; sj >= 0; sj--) {
+                        if (!(charTypes[seqIndices$1[sj]] & BN_LIKE_TYPES)) {
+                          prevType = charTypes[seqIndices$1[sj]];
+                          break;
+                        }
+                      }
+                      changeCharType(i$8, prevType & (ISOLATE_INIT_TYPES | TYPE_PDI) ? TYPE_ON : prevType);
+                    }
+                  }
+                }
+                if (charTypeCounts.get(TYPE_EN)) {
+                  for (var si$1 = 0; si$1 < seqIndices$1.length; si$1++) {
+                    var i$9 = seqIndices$1[si$1];
+                    if (charTypes[i$9] & TYPE_EN) {
+                      for (var sj$1 = si$1 - 1; sj$1 >= -1; sj$1--) {
+                        var prevCharType = sj$1 === -1 ? sosType : charTypes[seqIndices$1[sj$1]];
+                        if (prevCharType & STRONG_TYPES) {
+                          if (prevCharType === TYPE_AL) {
+                            changeCharType(i$9, TYPE_AN);
+                          }
+                          break;
+                        }
+                      }
+                    }
+                  }
+                }
+                if (charTypeCounts.get(TYPE_AL)) {
+                  for (var si$2 = 0; si$2 < seqIndices$1.length; si$2++) {
+                    var i$10 = seqIndices$1[si$2];
+                    if (charTypes[i$10] & TYPE_AL) {
+                      changeCharType(i$10, TYPE_R);
+                    }
+                  }
+                }
+                if (charTypeCounts.get(TYPE_ES) || charTypeCounts.get(TYPE_CS)) {
+                  for (var si$3 = 1; si$3 < seqIndices$1.length - 1; si$3++) {
+                    var i$11 = seqIndices$1[si$3];
+                    if (charTypes[i$11] & (TYPE_ES | TYPE_CS)) {
+                      var prevType$1 = 0, nextType = 0;
+                      for (var sj$2 = si$3 - 1; sj$2 >= 0; sj$2--) {
+                        prevType$1 = charTypes[seqIndices$1[sj$2]];
+                        if (!(prevType$1 & BN_LIKE_TYPES)) {
+                          break;
+                        }
+                      }
+                      for (var sj$3 = si$3 + 1; sj$3 < seqIndices$1.length; sj$3++) {
+                        nextType = charTypes[seqIndices$1[sj$3]];
+                        if (!(nextType & BN_LIKE_TYPES)) {
+                          break;
+                        }
+                      }
+                      if (prevType$1 === nextType && (charTypes[i$11] === TYPE_ES ? prevType$1 === TYPE_EN : prevType$1 & (TYPE_EN | TYPE_AN))) {
+                        changeCharType(i$11, prevType$1);
+                      }
+                    }
+                  }
+                }
+                if (charTypeCounts.get(TYPE_EN)) {
+                  for (var si$4 = 0; si$4 < seqIndices$1.length; si$4++) {
+                    var i$12 = seqIndices$1[si$4];
+                    if (charTypes[i$12] & TYPE_EN) {
+                      for (var sj$4 = si$4 - 1; sj$4 >= 0 && charTypes[seqIndices$1[sj$4]] & (TYPE_ET | BN_LIKE_TYPES); sj$4--) {
+                        changeCharType(seqIndices$1[sj$4], TYPE_EN);
+                      }
+                      for (si$4++; si$4 < seqIndices$1.length && charTypes[seqIndices$1[si$4]] & (TYPE_ET | BN_LIKE_TYPES | TYPE_EN); si$4++) {
+                        if (charTypes[seqIndices$1[si$4]] !== TYPE_EN) {
+                          changeCharType(seqIndices$1[si$4], TYPE_EN);
+                        }
+                      }
+                    }
+                  }
+                }
+                if (charTypeCounts.get(TYPE_ET) || charTypeCounts.get(TYPE_ES) || charTypeCounts.get(TYPE_CS)) {
+                  for (var si$5 = 0; si$5 < seqIndices$1.length; si$5++) {
+                    var i$13 = seqIndices$1[si$5];
+                    if (charTypes[i$13] & (TYPE_ET | TYPE_ES | TYPE_CS)) {
+                      changeCharType(i$13, TYPE_ON);
+                      for (var sj$5 = si$5 - 1; sj$5 >= 0 && charTypes[seqIndices$1[sj$5]] & BN_LIKE_TYPES; sj$5--) {
+                        changeCharType(seqIndices$1[sj$5], TYPE_ON);
+                      }
+                      for (var sj$6 = si$5 + 1; sj$6 < seqIndices$1.length && charTypes[seqIndices$1[sj$6]] & BN_LIKE_TYPES; sj$6++) {
+                        changeCharType(seqIndices$1[sj$6], TYPE_ON);
+                      }
+                    }
+                  }
+                }
+                if (charTypeCounts.get(TYPE_EN)) {
+                  for (var si$6 = 0, prevStrongType = sosType; si$6 < seqIndices$1.length; si$6++) {
+                    var i$14 = seqIndices$1[si$6];
+                    var type = charTypes[i$14];
+                    if (type & TYPE_EN) {
+                      if (prevStrongType === TYPE_L) {
+                        changeCharType(i$14, TYPE_L);
+                      }
+                    } else if (type & STRONG_TYPES) {
+                      prevStrongType = type;
+                    }
+                  }
+                }
+                if (charTypeCounts.get(NEUTRAL_ISOLATE_TYPES)) {
+                  var R_TYPES_FOR_N_STEPS = TYPE_R | TYPE_EN | TYPE_AN;
+                  var STRONG_TYPES_FOR_N_STEPS = R_TYPES_FOR_N_STEPS | TYPE_L;
+                  var bracketPairs = [];
+                  {
+                    var openerStack = [];
+                    for (var si$7 = 0; si$7 < seqIndices$1.length; si$7++) {
+                      if (charTypes[seqIndices$1[si$7]] & NEUTRAL_ISOLATE_TYPES) {
+                        var char = string4[seqIndices$1[si$7]];
+                        var oppositeBracket = void 0;
+                        if (openingToClosingBracket(char) !== null) {
+                          if (openerStack.length < 63) {
+                            openerStack.push({ char, seqIndex: si$7 });
+                          } else {
+                            break;
+                          }
+                        } else if ((oppositeBracket = closingToOpeningBracket(char)) !== null) {
+                          for (var stackIdx = openerStack.length - 1; stackIdx >= 0; stackIdx--) {
+                            var stackChar = openerStack[stackIdx].char;
+                            if (stackChar === oppositeBracket || stackChar === closingToOpeningBracket(getCanonicalBracket(char)) || openingToClosingBracket(getCanonicalBracket(stackChar)) === char) {
+                              bracketPairs.push([openerStack[stackIdx].seqIndex, si$7]);
+                              openerStack.length = stackIdx;
+                              break;
+                            }
+                          }
+                        }
+                      }
+                    }
+                    bracketPairs.sort(function(a, b) {
+                      return a[0] - b[0];
+                    });
+                  }
+                  for (var pairIdx = 0; pairIdx < bracketPairs.length; pairIdx++) {
+                    var ref$1 = bracketPairs[pairIdx];
+                    var openSeqIdx = ref$1[0];
+                    var closeSeqIdx = ref$1[1];
+                    var foundStrongType = false;
+                    var useStrongType = 0;
+                    for (var si$8 = openSeqIdx + 1; si$8 < closeSeqIdx; si$8++) {
+                      var i$15 = seqIndices$1[si$8];
+                      if (charTypes[i$15] & STRONG_TYPES_FOR_N_STEPS) {
+                        foundStrongType = true;
+                        var lr = charTypes[i$15] & R_TYPES_FOR_N_STEPS ? TYPE_R : TYPE_L;
+                        if (lr === embedDirection) {
+                          useStrongType = lr;
+                          break;
+                        }
+                      }
+                    }
+                    if (foundStrongType && !useStrongType) {
+                      useStrongType = sosType;
+                      for (var si$9 = openSeqIdx - 1; si$9 >= 0; si$9--) {
+                        var i$16 = seqIndices$1[si$9];
+                        if (charTypes[i$16] & STRONG_TYPES_FOR_N_STEPS) {
+                          var lr$1 = charTypes[i$16] & R_TYPES_FOR_N_STEPS ? TYPE_R : TYPE_L;
+                          if (lr$1 !== embedDirection) {
+                            useStrongType = lr$1;
+                          } else {
+                            useStrongType = embedDirection;
+                          }
+                          break;
+                        }
+                      }
+                    }
+                    if (useStrongType) {
+                      charTypes[seqIndices$1[openSeqIdx]] = charTypes[seqIndices$1[closeSeqIdx]] = useStrongType;
+                      if (useStrongType !== embedDirection) {
+                        for (var si$10 = openSeqIdx + 1; si$10 < seqIndices$1.length; si$10++) {
+                          if (!(charTypes[seqIndices$1[si$10]] & BN_LIKE_TYPES)) {
+                            if (getBidiCharType(string4[seqIndices$1[si$10]]) & TYPE_NSM) {
+                              charTypes[seqIndices$1[si$10]] = useStrongType;
+                            }
+                            break;
+                          }
+                        }
+                      }
+                      if (useStrongType !== embedDirection) {
+                        for (var si$11 = closeSeqIdx + 1; si$11 < seqIndices$1.length; si$11++) {
+                          if (!(charTypes[seqIndices$1[si$11]] & BN_LIKE_TYPES)) {
+                            if (getBidiCharType(string4[seqIndices$1[si$11]]) & TYPE_NSM) {
+                              charTypes[seqIndices$1[si$11]] = useStrongType;
+                            }
+                            break;
+                          }
+                        }
+                      }
+                    }
+                  }
+                  for (var si$12 = 0; si$12 < seqIndices$1.length; si$12++) {
+                    if (charTypes[seqIndices$1[si$12]] & NEUTRAL_ISOLATE_TYPES) {
+                      var niRunStart = si$12, niRunEnd = si$12;
+                      var prevType$2 = sosType;
+                      for (var si2 = si$12 - 1; si2 >= 0; si2--) {
+                        if (charTypes[seqIndices$1[si2]] & BN_LIKE_TYPES) {
+                          niRunStart = si2;
+                        } else {
+                          prevType$2 = charTypes[seqIndices$1[si2]] & R_TYPES_FOR_N_STEPS ? TYPE_R : TYPE_L;
+                          break;
+                        }
+                      }
+                      var nextType$1 = eosType;
+                      for (var si2$1 = si$12 + 1; si2$1 < seqIndices$1.length; si2$1++) {
+                        if (charTypes[seqIndices$1[si2$1]] & (NEUTRAL_ISOLATE_TYPES | BN_LIKE_TYPES)) {
+                          niRunEnd = si2$1;
+                        } else {
+                          nextType$1 = charTypes[seqIndices$1[si2$1]] & R_TYPES_FOR_N_STEPS ? TYPE_R : TYPE_L;
+                          break;
+                        }
+                      }
+                      for (var sj$7 = niRunStart; sj$7 <= niRunEnd; sj$7++) {
+                        charTypes[seqIndices$1[sj$7]] = prevType$2 === nextType$1 ? prevType$2 : embedDirection;
+                      }
+                      si$12 = niRunEnd;
+                    }
+                  }
+                }
+              }
+              for (var i$17 = paragraph.start; i$17 <= paragraph.end; i$17++) {
+                var level$3 = embedLevels[i$17];
+                var type$1 = charTypes[i$17];
+                if (level$3 & 1) {
+                  if (type$1 & (TYPE_L | TYPE_EN | TYPE_AN)) {
+                    embedLevels[i$17]++;
+                  }
+                } else {
+                  if (type$1 & TYPE_R) {
+                    embedLevels[i$17]++;
+                  } else if (type$1 & (TYPE_AN | TYPE_EN)) {
+                    embedLevels[i$17] += 2;
+                  }
+                }
+                if (type$1 & BN_LIKE_TYPES) {
+                  embedLevels[i$17] = i$17 === 0 ? paragraph.level : embedLevels[i$17 - 1];
+                }
+                if (i$17 === paragraph.end || getBidiCharType(string4[i$17]) & (TYPE_S | TYPE_B)) {
+                  for (var j$1 = i$17; j$1 >= 0 && getBidiCharType(string4[j$1]) & TRAILING_TYPES; j$1--) {
+                    embedLevels[j$1] = paragraph.level;
+                  }
+                }
+              }
+            }
+            return {
+              levels: embedLevels,
+              paragraphs
+            };
+            function determineAutoEmbedLevel(start, isFSI) {
+              for (var i3 = start; i3 < string4.length; i3++) {
+                var charType2 = charTypes[i3];
+                if (charType2 & (TYPE_R | TYPE_AL)) {
+                  return 1;
+                }
+                if (charType2 & (TYPE_B | TYPE_L) || isFSI && charType2 === TYPE_PDI) {
+                  return 0;
+                }
+                if (charType2 & ISOLATE_INIT_TYPES) {
+                  var pdi = indexOfMatchingPDI(i3);
+                  i3 = pdi === -1 ? string4.length : pdi;
+                }
+              }
+              return 0;
+            }
+            function indexOfMatchingPDI(isolateStart) {
+              var isolationLevel = 1;
+              for (var i3 = isolateStart + 1; i3 < string4.length; i3++) {
+                var charType2 = charTypes[i3];
+                if (charType2 & TYPE_B) {
+                  break;
+                }
+                if (charType2 & TYPE_PDI) {
+                  if (--isolationLevel === 0) {
+                    return i3;
+                  }
+                } else if (charType2 & ISOLATE_INIT_TYPES) {
+                  isolationLevel++;
+                }
+              }
+              return -1;
+            }
+          }
+          var data = "14>1,j>2,t>2,u>2,1a>g,2v3>1,1>1,1ge>1,1wd>1,b>1,1j>1,f>1,ai>3,-2>3,+1,8>1k0,-1jq>1y7,-1y6>1hf,-1he>1h6,-1h5>1ha,-1h8>1qi,-1pu>1,6>3u,-3s>7,6>1,1>1,f>1,1>1,+2,3>1,1>1,+13,4>1,1>1,6>1eo,-1ee>1,3>1mg,-1me>1mk,-1mj>1mi,-1mg>1mi,-1md>1,1>1,+2,1>10k,-103>1,1>1,4>1,5>1,1>1,+10,3>1,1>8,-7>8,+1,-6>7,+1,a>1,1>1,u>1,u6>1,1>1,+5,26>1,1>1,2>1,2>2,8>1,7>1,4>1,1>1,+5,b8>1,1>1,+3,1>3,-2>1,2>1,1>1,+2,c>1,3>1,1>1,+2,h>1,3>1,a>1,1>1,2>1,3>1,1>1,d>1,f>1,3>1,1a>1,1>1,6>1,7>1,13>1,k>1,1>1,+19,4>1,1>1,+2,2>1,1>1,+18,m>1,a>1,1>1,lk>1,1>1,4>1,2>1,f>1,3>1,1>1,+3,db>1,1>1,+3,3>1,1>1,+2,14qm>1,1>1,+1,6>1,4j>1,j>2,t>2,u>2,2>1,+1";
+          var mirrorMap;
+          function parse6() {
+            if (!mirrorMap) {
+              var ref = parseCharacterMap(data, true);
+              var map3 = ref.map;
+              var reverseMap = ref.reverseMap;
+              reverseMap.forEach(function(value, key) {
+                map3.set(key, value);
+              });
+              mirrorMap = map3;
+            }
+          }
+          function getMirroredCharacter(char) {
+            parse6();
+            return mirrorMap.get(char) || null;
+          }
+          function getMirroredCharactersMap(string4, embeddingLevels, start, end) {
+            var strLen = string4.length;
+            start = Math.max(0, start == null ? 0 : +start);
+            end = Math.min(strLen - 1, end == null ? strLen - 1 : +end);
+            var map3 = /* @__PURE__ */ new Map();
+            for (var i2 = start; i2 <= end; i2++) {
+              if (embeddingLevels[i2] & 1) {
+                var mirror = getMirroredCharacter(string4[i2]);
+                if (mirror !== null) {
+                  map3.set(i2, mirror);
+                }
+              }
+            }
+            return map3;
+          }
+          function getReorderSegments(string4, embeddingLevelsResult, start, end) {
+            var strLen = string4.length;
+            start = Math.max(0, start == null ? 0 : +start);
+            end = Math.min(strLen - 1, end == null ? strLen - 1 : +end);
+            var segments2 = [];
+            embeddingLevelsResult.paragraphs.forEach(function(paragraph) {
+              var lineStart = Math.max(start, paragraph.start);
+              var lineEnd = Math.min(end, paragraph.end);
+              if (lineStart < lineEnd) {
+                var lineLevels = embeddingLevelsResult.levels.slice(lineStart, lineEnd + 1);
+                for (var i2 = lineEnd; i2 >= lineStart && getBidiCharType(string4[i2]) & TRAILING_TYPES; i2--) {
+                  lineLevels[i2] = paragraph.level;
+                }
+                var maxLevel = paragraph.level;
+                var minOddLevel = Infinity;
+                for (var i$1 = 0; i$1 < lineLevels.length; i$1++) {
+                  var level = lineLevels[i$1];
+                  if (level > maxLevel) {
+                    maxLevel = level;
+                  }
+                  if (level < minOddLevel) {
+                    minOddLevel = level | 1;
+                  }
+                }
+                for (var lvl = maxLevel; lvl >= minOddLevel; lvl--) {
+                  for (var i$2 = 0; i$2 < lineLevels.length; i$2++) {
+                    if (lineLevels[i$2] >= lvl) {
+                      var segStart = i$2;
+                      while (i$2 + 1 < lineLevels.length && lineLevels[i$2 + 1] >= lvl) {
+                        i$2++;
+                      }
+                      if (i$2 > segStart) {
+                        segments2.push([segStart + lineStart, i$2 + lineStart]);
+                      }
+                    }
+                  }
+                }
+              }
+            });
+            return segments2;
+          }
+          function getReorderedString(string4, embedLevelsResult, start, end) {
+            var indices = getReorderedIndices(string4, embedLevelsResult, start, end);
+            var chars3 = [].concat(string4);
+            indices.forEach(function(charIndex, i2) {
+              chars3[i2] = (embedLevelsResult.levels[charIndex] & 1 ? getMirroredCharacter(string4[charIndex]) : null) || string4[charIndex];
+            });
+            return chars3.join("");
+          }
+          function getReorderedIndices(string4, embedLevelsResult, start, end) {
+            var segments2 = getReorderSegments(string4, embedLevelsResult, start, end);
+            var indices = [];
+            for (var i2 = 0; i2 < string4.length; i2++) {
+              indices[i2] = i2;
+            }
+            segments2.forEach(function(ref) {
+              var start2 = ref[0];
+              var end2 = ref[1];
+              var slice = indices.slice(start2, end2 + 1);
+              for (var i3 = slice.length; i3--; ) {
+                indices[end2 - i3] = slice[i3];
+              }
+            });
+            return indices;
+          }
+          exports2.closingToOpeningBracket = closingToOpeningBracket;
+          exports2.getBidiCharType = getBidiCharType;
+          exports2.getBidiCharTypeName = getBidiCharTypeName;
+          exports2.getCanonicalBracket = getCanonicalBracket;
+          exports2.getEmbeddingLevels = getEmbeddingLevels;
+          exports2.getMirroredCharacter = getMirroredCharacter;
+          exports2.getMirroredCharactersMap = getMirroredCharactersMap;
+          exports2.getReorderSegments = getReorderSegments;
+          exports2.getReorderedIndices = getReorderedIndices;
+          exports2.getReorderedString = getReorderedString;
+          exports2.openingToClosingBracket = openingToClosingBracket;
+          Object.defineProperty(exports2, "__esModule", { value: true });
+          return exports2;
+        })({});
+        return bidi2;
+      }
+      return bidiFactory2;
+    }));
+  }
+});
+
+// ../../app/t/[template_id]/arabicShaping.ts
+function joiningType(cp) {
+  const forms = FORMS.get(cp);
+  if (forms) return forms.length === 4 ? "D" : forms.length === 2 ? "R" : "U";
+  if (cp === 1600 || cp === 8205) return "C";
+  if (cp === 8204) return "U";
+  return TRANSPARENT.test(String.fromCodePoint(cp)) ? "T" : "U";
+}
+function shapeArabic(text) {
+  const cps = Array.from(text, (ch) => ch.codePointAt(0) ?? 0);
+  if (!cps.some((cp) => FORMS.has(cp))) return text;
+  const types = cps.map(joiningType);
+  const prevOf = (i2) => {
+    let j = i2 - 1;
+    while (j >= 0 && types[j] === "T") j--;
+    return j;
+  };
+  const nextOf = (i2) => {
+    let j = i2 + 1;
+    while (j < cps.length && types[j] === "T") j++;
+    return j < cps.length ? j : -1;
+  };
+  const out = [];
+  for (let i2 = 0; i2 < cps.length; i2++) {
+    const cp = cps[i2];
+    const forms = FORMS.get(cp);
+    if (!forms) {
+      out.push(cp);
+      continue;
+    }
+    const p4 = prevOf(i2);
+    const n = nextOf(i2);
+    const joinPrev = joinsRight(types[i2]) && p4 >= 0 && joinsLeft(types[p4]);
+    const lig = cp === LAM && n >= 0 ? LAM_ALEF.get(cps[n]) : void 0;
+    if (lig) {
+      out.push(joinPrev ? lig[1] : lig[0]);
+      for (let k4 = i2 + 1; k4 < n; k4++) out.push(cps[k4]);
+      i2 = n;
+      continue;
+    }
+    const joinNext = joinsLeft(types[i2]) && n >= 0 && joinsRight(types[n]);
+    const form = forms.length === 4 ? joinPrev ? joinNext ? 3 : 1 : joinNext ? 2 : 0 : joinPrev && forms.length === 2 ? 1 : 0;
+    out.push(forms[form]);
+  }
+  return out.map((c2) => String.fromCodePoint(c2)).join("");
+}
+var FORMS, LAM, LAM_ALEF, TRANSPARENT, joinsLeft, joinsRight;
+var init_arabicShaping = __esm({
+  "../../app/t/[template_id]/arabicShaping.ts"() {
+    "use strict";
+    FORMS = /* @__PURE__ */ new Map([
+      [1569, [65152]],
+      // hamza (non-joining)
+      [1570, [65153, 65154]],
+      // alef with madda above
+      [1571, [65155, 65156]],
+      // alef with hamza above
+      [1572, [65157, 65158]],
+      // waw with hamza above
+      [1573, [65159, 65160]],
+      // alef with hamza below
+      [1574, [65161, 65162, 65163, 65164]],
+      // yeh with hamza above
+      [1575, [65165, 65166]],
+      // alef
+      [1576, [65167, 65168, 65169, 65170]],
+      // beh
+      [1577, [65171, 65172]],
+      // teh marbuta
+      [1578, [65173, 65174, 65175, 65176]],
+      // teh
+      [1579, [65177, 65178, 65179, 65180]],
+      // theh
+      [1580, [65181, 65182, 65183, 65184]],
+      // jeem
+      [1581, [65185, 65186, 65187, 65188]],
+      // hah
+      [1582, [65189, 65190, 65191, 65192]],
+      // khah
+      [1583, [65193, 65194]],
+      // dal
+      [1584, [65195, 65196]],
+      // thal
+      [1585, [65197, 65198]],
+      // reh
+      [1586, [65199, 65200]],
+      // zain
+      [1587, [65201, 65202, 65203, 65204]],
+      // seen
+      [1588, [65205, 65206, 65207, 65208]],
+      // sheen
+      [1589, [65209, 65210, 65211, 65212]],
+      // sad
+      [1590, [65213, 65214, 65215, 65216]],
+      // dad
+      [1591, [65217, 65218, 65219, 65220]],
+      // tah
+      [1592, [65221, 65222, 65223, 65224]],
+      // zah
+      [1593, [65225, 65226, 65227, 65228]],
+      // ain
+      [1594, [65229, 65230, 65231, 65232]],
+      // ghain
+      [1601, [65233, 65234, 65235, 65236]],
+      // feh
+      [1602, [65237, 65238, 65239, 65240]],
+      // qaf
+      [1603, [65241, 65242, 65243, 65244]],
+      // kaf
+      [1604, [65245, 65246, 65247, 65248]],
+      // lam
+      [1605, [65249, 65250, 65251, 65252]],
+      // meem
+      [1606, [65253, 65254, 65255, 65256]],
+      // noon
+      [1607, [65257, 65258, 65259, 65260]],
+      // heh
+      [1608, [65261, 65262]],
+      // waw
+      [1609, [65263, 65264, 64488, 64489]],
+      // alef maksura (init/medi in Forms-A)
+      [1610, [65265, 65266, 65267, 65268]],
+      // yeh
+      [1662, [64342, 64343, 64344, 64345]],
+      // peh
+      [1670, [64378, 64379, 64380, 64381]],
+      // tcheh
+      [1688, [64394, 64395]],
+      // jeh
+      [1705, [64398, 64399, 64400, 64401]],
+      // keheh
+      [1711, [64402, 64403, 64404, 64405]],
+      // gaf
+      [1740, [64508, 64509, 64510, 64511]]
+      // farsi yeh
+    ]);
+    LAM = 1604;
+    LAM_ALEF = /* @__PURE__ */ new Map([
+      [1570, [65269, 65270]],
+      [1571, [65271, 65272]],
+      [1573, [65273, 65274]],
+      [1575, [65275, 65276]]
+    ]);
+    TRANSPARENT = /[\p{Mn}\p{Me}\p{Cf}]/u;
+    joinsLeft = (j) => j === "D" || j === "C";
+    joinsRight = (j) => j === "D" || j === "R" || j === "C";
+  }
+});
+
+// ../../app/t/[template_id]/rtlStamp.ts
+var rtlStamp_exports = {};
+__export(rtlStamp_exports, {
+  shapeArabic: () => shapeArabic,
+  visualLine: () => visualLine,
+  visualLines: () => visualLines
+});
+function bmpStandIns(b, text) {
+  let out = "";
+  for (const ch of text) {
+    out += ch.length === 1 ? ch : (STAND_IN[b.getBidiCharTypeName(ch)] ?? "a").repeat(2);
+  }
+  return out;
+}
+function visualLines(text, lines, rtl) {
+  bidi ??= (0, import_bidi_js.default)();
+  const b = bidi;
+  const base = rtl ? 1 : 0;
+  const standIns = bmpStandIns(b, text);
+  const { levels } = b.getEmbeddingLevels(standIns, rtl ? "rtl" : "ltr");
+  const mirrored = b.getMirroredCharactersMap(standIns, levels);
+  let at = 0;
+  return lines.map((line) => {
+    const cells = [];
+    const from = at;
+    for (const ch of line) {
+      while (at < text.length && !text.startsWith(ch, at) && (text[at] === " " || text[at] === "\n")) {
+        at++;
+      }
+      if (!text.startsWith(ch, at)) {
+        at = from;
+        return visualLine(line, rtl);
+      }
+      cells.push({
+        ch: mirrored.get(at) ?? ch,
+        level: levels[at],
+        type: b.getBidiCharTypeName(standIns[at])
+      });
+      at += ch.length;
+    }
+    for (let k4 = cells.length - 1; k4 >= 0 && TRAILING.has(cells[k4].type); k4--) {
+      cells[k4].level = base;
+    }
+    return stripBidiControls(
+      reorder(cells, base).map((c2) => c2.ch).join("")
+    );
+  });
+}
+function visualLine(line, rtl) {
+  return visualLines(line, [line], rtl)[0] ?? "";
+}
+function reorder(cells, base) {
+  let max2 = base;
+  let minOdd = Infinity;
+  for (const c2 of cells) {
+    max2 = Math.max(max2, c2.level);
+    minOdd = Math.min(minOdd, c2.level | 1);
+  }
+  const out = cells.slice();
+  for (let lvl = max2; lvl >= minOdd; lvl--) {
+    for (let i2 = 0; i2 < out.length; i2++) {
+      if (out[i2].level < lvl) continue;
+      let j = i2;
+      while (j + 1 < out.length && out[j + 1].level >= lvl) j++;
+      const run = out.slice(i2, j + 1).reverse();
+      out.splice(i2, run.length, ...run);
+      i2 = j;
+    }
+  }
+  return out;
+}
+var import_bidi_js, bidi, STAND_IN, TRAILING;
+var init_rtlStamp = __esm({
+  "../../app/t/[template_id]/rtlStamp.ts"() {
+    "use strict";
+    import_bidi_js = __toESM(require_bidi());
+    init_bidiText();
+    init_arabicShaping();
+    STAND_IN = {
+      L: "a",
+      R: "\u05D0",
+      AL: "\u0627",
+      EN: "0",
+      AN: "\u0660",
+      ES: "+",
+      ET: "#",
+      CS: ",",
+      NSM: "\u0300",
+      BN: "\u200B",
+      WS: " ",
+      S: "	",
+      ON: "!"
+    };
+    TRAILING = /* @__PURE__ */ new Set([
+      "WS",
+      "S",
+      "B",
+      "LRI",
+      "RLI",
+      "FSI",
+      "PDI",
+      "BN",
+      "LRE",
+      "RLE",
+      "LRO",
+      "RLO",
+      "PDF"
+    ]);
+  }
+});
+
 // node_modules/@embedpdf/pdfium/dist/index.js
 var dist_exports = {};
 __export(dist_exports, {
@@ -99673,11 +100792,11 @@ var init_dist = __esm({
         var ENVIRONMENT_IS_SHELL = !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER;
         if (ENVIRONMENT_IS_NODE) {
           const { createRequire: createRequire3 } = await import("module");
-          let dirname5 = import.meta.url;
-          if (dirname5.startsWith("data:")) {
-            dirname5 = "/";
+          let dirname6 = import.meta.url;
+          if (dirname6.startsWith("data:")) {
+            dirname6 = "/";
           }
-          var require3 = createRequire3(dirname5);
+          var require3 = createRequire3(dirname6);
         }
         var moduleOverrides = Object.assign({}, Module);
         var thisProgram = "./this.program";
@@ -108640,8 +109759,8 @@ function handleArrayResult(result, final, index2) {
 }
 var $ZodArray = /* @__PURE__ */ $constructor("$ZodArray", (inst, def) => {
   $ZodType.init(inst, def);
-  const memo2 = globalConfig.memoizer;
-  memo2?.attach(inst);
+  const memo3 = globalConfig.memoizer;
+  memo3?.attach(inst);
   inst._zod.parse = (payload, ctx) => {
     const input2 = payload.value;
     if (!Array.isArray(input2)) {
@@ -108653,7 +109772,7 @@ var $ZodArray = /* @__PURE__ */ $constructor("$ZodArray", (inst, def) => {
       });
       return payload;
     }
-    payload.value = memo2 ? memo2.alloc(inst, payload, Array(input2.length), ctx) : Array(input2.length);
+    payload.value = memo3 ? memo3.alloc(inst, payload, Array(input2.length), ctx) : Array(input2.length);
     const proms = [];
     const abortEarly = ctx?.abortEarly;
     for (let i2 = 0; i2 < input2.length; i2++) {
@@ -108812,8 +109931,8 @@ var $ZodObject = /* @__PURE__ */ $constructor("$ZodObject", (inst, def) => {
   const isObject2 = isObject;
   const catchall = def.catchall;
   let value;
-  const memo2 = globalConfig.memoizer;
-  memo2?.attach(inst);
+  const memo3 = globalConfig.memoizer;
+  memo3?.attach(inst);
   inst._zod.parse = (payload, ctx) => {
     value ?? (value = _normalized.value);
     const input2 = payload.value;
@@ -108826,7 +109945,7 @@ var $ZodObject = /* @__PURE__ */ $constructor("$ZodObject", (inst, def) => {
       });
       return payload;
     }
-    payload.value = memo2 ? memo2.alloc(inst, payload, {}, ctx) : {};
+    payload.value = memo3 ? memo3.alloc(inst, payload, {}, ctx) : {};
     const proms = [];
     const shape = value.shape;
     const abortEarly = ctx?.abortEarly;
@@ -108859,11 +109978,11 @@ var $ZodObjectJIT = /* @__PURE__ */ $constructor("$ZodObjectJIT", (inst, def) =>
   $ZodObject.init(inst, def);
   const superParse = inst._zod.parse;
   const _normalized = cached(() => normalizeDef(def));
-  const memo2 = globalConfig.memoizer;
+  const memo3 = globalConfig.memoizer;
   const generateFastpass = (shape) => {
     const normalized = _normalized.value;
     const syms = normalized.symbolKeys;
-    const doc = new Doc(["payload", "ctx"], { shape, inst, memo: memo2, syms });
+    const doc = new Doc(["payload", "ctx"], { shape, inst, memo: memo3, syms });
     const parseStr = (k4) => `shape[${k4}]._zod.run({ value: input[${k4}], issues: [] }, ctx)`;
     const prefixStr = (id, k4) => `
           let ${id}_ab = false;
@@ -108883,7 +110002,7 @@ var $ZodObjectJIT = /* @__PURE__ */ $constructor("$ZodObjectJIT", (inst, def) =>
     for (const key of normalized.allKeys) {
       ids[key] = `key_${counter++}`;
     }
-    doc.write(memo2 ? `const newResult = memo.alloc(inst, payload, {}, ctx);` : `const newResult = {};`);
+    doc.write(memo3 ? `const newResult = memo.alloc(inst, payload, {}, ctx);` : `const newResult = {};`);
     for (const key of normalized.allKeys) {
       if (key === "__proto__")
         continue;
@@ -109317,8 +110436,8 @@ function handleIntersectionResults(result, left, right) {
 var $ZodTuple = /* @__PURE__ */ $constructor("$ZodTuple", (inst, def) => {
   $ZodType.init(inst, def);
   const items2 = def.items;
-  const memo2 = globalConfig.memoizer;
-  memo2?.attach(inst);
+  const memo3 = globalConfig.memoizer;
+  memo3?.attach(inst);
   inst._zod.parse = (payload, ctx) => {
     const input2 = payload.value;
     if (!Array.isArray(input2)) {
@@ -109330,7 +110449,7 @@ var $ZodTuple = /* @__PURE__ */ $constructor("$ZodTuple", (inst, def) => {
       });
       return payload;
     }
-    payload.value = memo2 ? memo2.alloc(inst, payload, [], ctx) : [];
+    payload.value = memo3 ? memo3.alloc(inst, payload, [], ctx) : [];
     const proms = [];
     const optinStart = getTupleOptStart(items2, "optin");
     const optoutStart = getTupleOptStart(items2, "optout");
@@ -109439,8 +110558,8 @@ function handleTupleResults(itemResults, final, items2, input2, optoutStart) {
 }
 var $ZodRecord = /* @__PURE__ */ $constructor("$ZodRecord", (inst, def) => {
   $ZodType.init(inst, def);
-  const memo2 = globalConfig.memoizer;
-  memo2?.attach(inst);
+  const memo3 = globalConfig.memoizer;
+  memo3?.attach(inst);
   inst._zod.parse = (payload, ctx) => {
     const input2 = payload.value;
     if (!isPlainObject(input2)) {
@@ -109455,7 +110574,7 @@ var $ZodRecord = /* @__PURE__ */ $constructor("$ZodRecord", (inst, def) => {
     const proms = [];
     const values2 = def.keyType._zod.values;
     if (values2 && !def.partial) {
-      payload.value = memo2 ? memo2.alloc(inst, payload, {}, ctx) : {};
+      payload.value = memo3 ? memo3.alloc(inst, payload, {}, ctx) : {};
       const recordKeys = /* @__PURE__ */ new Set();
       for (const key of values2) {
         if (typeof key === "string" || typeof key === "number" || typeof key === "symbol") {
@@ -109519,7 +110638,7 @@ var $ZodRecord = /* @__PURE__ */ $constructor("$ZodRecord", (inst, def) => {
         });
       }
     } else {
-      payload.value = memo2 ? memo2.alloc(inst, payload, {}, ctx) : {};
+      payload.value = memo3 ? memo3.alloc(inst, payload, {}, ctx) : {};
       let unrecognized;
       for (const key of Reflect.ownKeys(input2)) {
         if (key === "__proto__")
@@ -109594,8 +110713,8 @@ var $ZodRecord = /* @__PURE__ */ $constructor("$ZodRecord", (inst, def) => {
 });
 var $ZodMap = /* @__PURE__ */ $constructor("$ZodMap", (inst, def) => {
   $ZodType.init(inst, def);
-  const memo2 = globalConfig.memoizer;
-  memo2?.attach(inst);
+  const memo3 = globalConfig.memoizer;
+  memo3?.attach(inst);
   inst._zod.parse = (payload, ctx) => {
     const input2 = payload.value;
     if (!(input2 instanceof Map)) {
@@ -109608,7 +110727,7 @@ var $ZodMap = /* @__PURE__ */ $constructor("$ZodMap", (inst, def) => {
       return payload;
     }
     const proms = [];
-    payload.value = memo2 ? memo2.alloc(inst, payload, /* @__PURE__ */ new Map(), ctx) : /* @__PURE__ */ new Map();
+    payload.value = memo3 ? memo3.alloc(inst, payload, /* @__PURE__ */ new Map(), ctx) : /* @__PURE__ */ new Map();
     const abortEarly = ctx?.abortEarly;
     let seen = payload.issues.length;
     for (const [key, value] of input2) {
@@ -109664,8 +110783,8 @@ function handleMapResult(keyResult, valueResult, final, key, input2, inst, ctx)
 }
 var $ZodSet = /* @__PURE__ */ $constructor("$ZodSet", (inst, def) => {
   $ZodType.init(inst, def);
-  const memo2 = globalConfig.memoizer;
-  memo2?.attach(inst);
+  const memo3 = globalConfig.memoizer;
+  memo3?.attach(inst);
   inst._zod.parse = (payload, ctx) => {
     const input2 = payload.value;
     if (!(input2 instanceof Set)) {
@@ -109678,7 +110797,7 @@ var $ZodSet = /* @__PURE__ */ $constructor("$ZodSet", (inst, def) => {
       return payload;
     }
     const proms = [];
-    payload.value = memo2 ? memo2.alloc(inst, payload, /* @__PURE__ */ new Set(), ctx) : /* @__PURE__ */ new Set();
+    payload.value = memo3 ? memo3.alloc(inst, payload, /* @__PURE__ */ new Set(), ctx) : /* @__PURE__ */ new Set();
     const abortEarly = ctx?.abortEarly;
     let seen = payload.issues.length;
     for (const item of input2) {
@@ -134756,6 +135875,9 @@ function groupFormatOf(group) {
   return void 0;
 }
 
+// ../../app/t/[template_id]/agentValues.ts
+init_bidiText();
+
 // ../../app/t/[template_id]/fillKeys.ts
 function buildFieldById(fields) {
   const m = /* @__PURE__ */ new Map();
@@ -135090,6 +136212,163 @@ function buildMarks({
   return out;
 }
 
+// ../../app/t/[template_id]/fontRuns.ts
+function splitByCoverage(text, pick2, joinsPrevious) {
+  const runs = [];
+  let current;
+  let prevCp = -1;
+  for (const ch of Array.from(text)) {
+    const cp = ch.codePointAt(0) ?? 0;
+    if (current !== void 0 && joinsPrevious?.(cp, prevCp) === true) {
+      current.text += ch;
+      prevCp = cp;
+      continue;
+    }
+    const key = pick2(cp);
+    prevCp = cp;
+    if (current !== void 0 && current.key === key) {
+      current.text += ch;
+    } else {
+      current = { key, text: ch };
+      runs.push(current);
+    }
+  }
+  return runs;
+}
+function splitByDirection(text, dirOf) {
+  const out = [];
+  let cur;
+  for (const ch of Array.from(text)) {
+    const d = dirOf(ch.codePointAt(0) ?? 0);
+    if (cur === void 0 || d === "rtl" && cur.ltr || d === "ltr" && cur.rtl) {
+      cur = { text: "", rtl: false, ltr: false };
+      out.push(cur);
+    }
+    cur.text += ch;
+    if (d === "rtl") cur.rtl = true;
+    if (d === "ltr") cur.ltr = true;
+  }
+  return out.map(({ text: t, rtl }) => ({ text: t, rtl }));
+}
+var JP_FACE_SHA256 = "811055f9af5d0955fbf075c391ddfef287720593bbf48ff06d6812a7c2949f41";
+var JP_FACE_BYTES = 5793848;
+var JP_SCRIPT_RANGES = [
+  [11904, 12255],
+  // CJK Radicals Supplement + Kangxi Radicals
+  [12288, 12351],
+  // CJK Symbols and Punctuation
+  [12352, 12447],
+  // Hiragana
+  [12448, 12543],
+  // Katakana
+  [12784, 12799],
+  // Katakana Phonetic Extensions
+  [12800, 13055],
+  // Enclosed CJK Letters and Months
+  [13056, 13311],
+  // CJK Compatibility
+  [13312, 19903],
+  // CJK Unified Ideographs Extension A
+  [19968, 40959],
+  // CJK Unified Ideographs
+  [63744, 64255],
+  // CJK Compatibility Ideographs
+  [65072, 65103],
+  // CJK Compatibility Forms
+  [65280, 65519],
+  // Halfwidth and Fullwidth Forms
+  [131072, 173791],
+  // Extension B
+  [173824, 191471],
+  // Extensions C–F
+  [194560, 195103],
+  // CJK Compatibility Ideographs Supplement
+  [196608, 201551]
+  // Extension G
+];
+var JP_SYMBOL_RANGES = [
+  [8413, 8414],
+  // combining enclosing circle / square
+  [8458, 8458],
+  // ℊ script small g
+  [8978, 8978],
+  // ⌒ arc
+  [9001, 9002],
+  // 〈〉 angle brackets (Misc Technical)
+  [9136, 9164],
+  // ⎰⎱ ⎾–⏌ (Misc Technical)
+  [9178, 9179],
+  // ⏚⏛
+  [9322, 9397],
+  // ⑪–⑳ ⑴–⒇ ⒈–⒛ ⒜–⒵
+  [9424, 9449],
+  // ⓐ–ⓩ
+  [9451, 9471],
+  // ⓫–⓴ ⓵–⓾ ⓿
+  [9917, 9918],
+  // ⚽⚾
+  [10548, 10549],
+  // ⤴⤵
+  [10687, 10687],
+  // ⦿
+  [11157, 11157],
+  // ⮕
+  [11834, 11835],
+  // ⸺⸻ two- and three-em dash
+  [12272, 12283],
+  // Ideographic Description Characters
+  [12549, 12771],
+  // Bopomofo, Hangul Compatibility Jamo, Kanbun, CJK Strokes
+  [65040, 65049],
+  // Vertical Forms
+  [65104, 65131],
+  // Small Form Variants
+  [127232, 127404],
+  // Enclosed Alphanumeric Supplement (🄀–🆬)
+  [127488, 127569]
+  // Enclosed Ideographic Supplement (🈀–🉑)
+];
+var JP_FACE_RANGES = [
+  ...JP_SCRIPT_RANGES,
+  ...JP_SYMBOL_RANGES
+].sort((a, b) => a[0] - b[0]);
+function inRanges(ranges, cp) {
+  for (const [a, b] of ranges) {
+    if (cp < a) return false;
+    if (cp <= b) return true;
+  }
+  return false;
+}
+function inJpScriptRange(cp) {
+  return inRanges(JP_SCRIPT_RANGES, cp);
+}
+function inJpFaceRange(cp) {
+  return inRanges(JP_FACE_RANGES, cp);
+}
+function needsJpFace(text) {
+  for (const ch of text) {
+    if (inJpFaceRange(ch.codePointAt(0) ?? 0)) return true;
+  }
+  return false;
+}
+var JP_FACE_UNICODE_RANGE = JP_FACE_RANGES.map(
+  ([a, b]) => `U+${a.toString(16).toUpperCase()}-${b.toString(16).toUpperCase()}`
+).join(", ");
+function isJpJoiner(cp) {
+  return cp >= 65024 && cp <= 65039 || cp >= 917760 && cp <= 917999 || cp === 12441 || cp === 12442;
+}
+function joinsJpRun(cp, prevCp) {
+  return isJpJoiner(cp) && inJpFaceRange(prevCp);
+}
+function marksNeedJpFace(marksByPage) {
+  for (const marks of marksByPage.values()) {
+    for (const m of marks) {
+      if (m.text && needsJpFace(m.text)) return true;
+    }
+  }
+  return false;
+}
+
 // ../../app/t/[template_id]/normalizeSchema.ts
 function normalizeSigningRequirement(req) {
   if (req === "wet" || req === "certified" || req === "external") return "external";
@@ -135223,6 +136502,9 @@ function dataUrlToBytes(dataUrl) {
   return bytes;
 }
 
+// ../../app/t/[template_id]/stampPdf.ts
+init_bidiText();
+
 // ../../app/t/[template_id]/flattenForm.ts
 var ANNOT_FLAG_HIDDEN = 1 << 1;
 var ANNOT_FLAG_NOVIEW = 1 << 5;
@@ -135408,22 +136690,6 @@ function pruneStructTree(pdfDoc, pdfLib, removedRefs, removedStructParents) {
   pruneNumberTree(root.lookup(PDFName2.of("ParentTree")), 0);
 }
 
-// ../../app/t/[template_id]/fontRuns.ts
-function splitByCoverage(text, pick2) {
-  const runs = [];
-  let current;
-  for (const ch of Array.from(text)) {
-    const key = pick2(ch.codePointAt(0) ?? 0);
-    if (current !== void 0 && current.key === key) {
-      current.text += ch;
-    } else {
-      current = { key, text: ch };
-      runs.push(current);
-    }
-  }
-  return runs;
-}
-
 // ../../app/t/[template_id]/markGeometry.ts
 var MARK_STROKE = 0.16;
 var MARK_LINES = {
@@ -135462,6 +136728,7 @@ function classifyMark(symbol2) {
 }
 
 // ../../app/t/[template_id]/textFit.ts
+init_bidiText();
 var TEXT_PAD_PT = 4;
 var PAD_MAX_FRACTION = 0.18;
 function multilinePadPt(boxDimPt) {
@@ -135482,6 +136749,41 @@ function autoTextStartPt(boxHeightPt) {
 }
 var LINE_HEIGHT_FACTOR = 1.2;
 var MULTILINE_MIN_FONT_SIZE = 5;
+var NO_LINE_START = new Set(
+  Array.from(
+    "\uFF09\u300D\u300F\u3011\u3015\u3009\u300B\uFF5D\uFF3D\u3019\u3017\u301F\u2019\u201D\u301E\uFF63\uFF64\uFF61\uFF65\uFF70\uFF9E\uFF9F\uFF67\uFF68\uFF69\uFF6A\uFF6B\uFF6C\uFF6D\uFF6E\uFF6F\u3001\u3002\uFF0C\uFF0E\u30FB\uFF1A\uFF1B\uFF1F\uFF01\u30FC\u3005\u303B\u309D\u309E\u30FD\u30FE\u3041\u3043\u3045\u3047\u3049\u3063\u3083\u3085\u3087\u308E\u3095\u3096\u30A1\u30A3\u30A5\u30A7\u30A9\u30C3\u30E3\u30E5\u30E7\u30EE\u30F5\u30F6\u309B\u309C\u2025\u2026\u301C\uFF5E\u30A0\u3000\uFF05\u2030\xB0\u2032\u2033\u2103\u2109\uFFE0\xA2)]},.:;!?/-%"
+  ).map((ch) => ch.codePointAt(0) ?? 0)
+);
+var NO_LINE_END = new Set(
+  Array.from("\uFF08\u300C\u300E\u3010\u3014\u3008\u300A\uFF5B\uFF3B\u3018\u3016\u301D\u2018\u201C\uFF62([{\uFFE5\uFF04\uFFE1\uFFE6\xA5$\xA3\u20AC").map((ch) => ch.codePointAt(0) ?? 0)
+);
+function cannotStartLine(cp) {
+  return NO_LINE_START.has(cp) || cp >= 12784 && cp <= 12799 || // small katakana ㇰ-ㇿ
+  cp === 12441 || // combining voicing marks
+  cp === 12442 || cp >= 65024 && cp <= 65039 || // variation selectors
+  cp >= 917760 && cp <= 917999;
+}
+function cjkPieces(word) {
+  const chars3 = Array.from(word);
+  if (chars3.length < 2) return [word];
+  const pieces = [];
+  let piece = chars3[0];
+  let prev = chars3[0].codePointAt(0) ?? 0;
+  for (let i2 = 1; i2 < chars3.length; i2++) {
+    const cp = chars3[i2].codePointAt(0) ?? 0;
+    const breakable = (inJpScriptRange(prev) || inJpScriptRange(cp)) && !cannotStartLine(cp) && !NO_LINE_END.has(prev);
+    if (breakable) {
+      pieces.push(piece);
+      piece = chars3[i2];
+    } else {
+      piece += chars3[i2];
+    }
+    prev = cp;
+  }
+  pieces.push(piece);
+  return pieces;
+}
+var hangIdeoSpaces = (line) => line.replace(/\u3000+$/, "");
 function wrapLines(text, availWidth, size, measure) {
   const out = [];
   for (const para of text.split("\n")) {
@@ -135490,15 +136792,21 @@ function wrapLines(text, availWidth, size, measure) {
       continue;
     }
     let line = "";
-    for (const word of para.split(" ")) {
-      const trial = line === "" ? word : `${line} ${word}`;
-      if (line !== "" && measure(trial, size) > availWidth) {
-        out.push(line);
-        line = word;
-      } else {
-        line = trial;
-      }
-    }
+    const words = para.split(" ");
+    words.forEach((word, wi) => {
+      const pieces = cjkPieces(word);
+      pieces.forEach((piece, i2) => {
+        const sep = i2 === 0 ? " " : "";
+        const trial = line === "" ? piece : `${line}${sep}${piece}`;
+        const last2 = wi === words.length - 1 && i2 === pieces.length - 1;
+        if (line !== "" && measure(last2 ? trial : hangIdeoSpaces(trial), size) > availWidth) {
+          out.push(hangIdeoSpaces(line));
+          line = piece;
+        } else {
+          line = trial;
+        }
+      });
+    });
     out.push(line);
   }
   return out;
@@ -135575,6 +136883,7 @@ function layoutMultiline({
 async function embedStampFaces(pdfDoc, fontkit, fonts) {
   const interFont = await pdfDoc.embedFont(fonts.inter, { subset: true });
   const dejaFont = await pdfDoc.embedFont(fonts.deja, { subset: true });
+  const jpFont = fonts.jp ? await pdfDoc.embedFont(fonts.jp, { subset: true }) : void 0;
   const interKit = fontkit.create(new Uint8Array(fonts.inter));
   const covers = (cp) => {
     try {
@@ -135583,7 +136892,8 @@ async function embedStampFaces(pdfDoc, fontkit, fonts) {
       return false;
     }
   };
-  const splitRuns = (t) => splitByCoverage(t, (cp) => covers(cp) ? interFont : dejaFont).map((r) => ({
+  const pick2 = jpFont ? (cp) => inJpFaceRange(cp) ? jpFont : covers(cp) ? interFont : dejaFont : (cp) => covers(cp) ? interFont : dejaFont;
+  const splitRuns = (t) => (jpFont ? splitByCoverage(t, pick2, joinsJpRun) : splitByCoverage(t, pick2)).map((r) => ({
     font: r.key,
     text: r.text
   }));
@@ -135595,13 +136905,48 @@ async function embedStampFaces(pdfDoc, fontkit, fonts) {
       cx2 += r.font.widthOfTextAtSize(r.text, s);
     }
   };
+  const drawVisual = (page, t, x2, y, s, color) => {
+    let cx2 = x2;
+    for (const r of splitRuns(t)) {
+      for (const piece of splitByDirection(r.text, (cp) => fontkitDirection(interKit, cp))) {
+        const text = piece.rtl ? Array.from(piece.text).reverse().join("") : piece.text;
+        page.drawText(text, { x: cx2, y, size: s, font: r.font, color });
+        cx2 += r.font.widthOfTextAtSize(text, s);
+      }
+    }
+  };
   let dejaSet;
+  let jpSet;
   const hasGlyph = (cp) => {
     if (covers(cp)) return true;
     dejaSet ??= new Set(dejaFont.getCharacterSet());
-    return dejaSet.has(cp);
-  };
-  return { measure, draw, hasGlyph };
+    if (dejaSet.has(cp)) return true;
+    if (!jpFont) return false;
+    jpSet ??= new Set(jpFont.getCharacterSet());
+    return jpSet.has(cp);
+  };
+  return { measure, draw, drawVisual, hasGlyph };
+}
+var directionMemo = /* @__PURE__ */ new Map();
+function fontkitDirection(kit, cp) {
+  let d = directionMemo.get(cp);
+  if (d === void 0) {
+    const ch = String.fromCodePoint(cp);
+    d = kit.layout(`${ch}a`).direction === "rtl" ? "rtl" : kit.layout(`${ch}\u05D0`).direction === "rtl" ? "neutral" : "ltr";
+    directionMemo.set(cp, d);
+  }
+  return d;
+}
+var jpFacePromise;
+function loadJpStampFace() {
+  jpFacePromise ??= fetch("/fonts/NotoSansJP-Regular.ttf").then((r) => {
+    if (!r.ok) throw new Error("HTTP " + String(r.status));
+    return r.arrayBuffer();
+  }).catch(() => {
+    jpFacePromise = void 0;
+    throw new Error("Could not load the Japanese font.");
+  });
+  return jpFacePromise;
 }
 async function stampPdf({
   pdfBytes,
@@ -135636,7 +136981,13 @@ async function stampPdf({
       return r.arrayBuffer();
     })
   ]);
-  const faces = await embedStampFaces(pdfDoc, fontkit, { inter: interBytes, deja: dejaBytes });
+  const jp = marksNeedJpFace(marksByPage) ? fonts?.jp ?? await loadJpStampFace() : void 0;
+  const faces = await embedStampFaces(pdfDoc, fontkit, {
+    inter: interBytes,
+    deja: dejaBytes,
+    jp
+  });
+  const rtlLayer = marksNeedBidi(marksByPage) ? await Promise.resolve().then(() => (init_rtlStamp(), rtlStamp_exports)) : void 0;
   const pdfPages = pdfDoc.getPages();
   const INK = rgb3(0.1, 0.1, 0.1);
   const { measure } = faces;
@@ -135711,6 +137062,17 @@ async function stampPdf({
       return;
     }
     if (text === "") return;
+    const bidi2 = rtlLayer && needsBidi(text) ? rtlLayer : void 0;
+    const rtl = bidi2 !== void 0 && isRtlDominant(text);
+    const body = bidi2 ? bidi2.shapeArabic(text) : text;
+    const measureText = bidi2 ? (t, s) => measure(stripBidiControls(t), s) : measure;
+    const toDraw = (lines) => bidi2 ? bidi2.visualLines(body, lines, rtl) : lines;
+    const drawLine2 = bidi2 ? (t, x3, y2, s) => {
+      faces.drawVisual(page, t, x3, y2, s, INK);
+    } : (t, x3, y2, s) => {
+      drawMixed(page, t, x3, y2, s);
+    };
+    const anchorOf = (a) => bidiAnchor(a ?? DEFAULT_TEXT_ANCHOR, rtl);
     if (center) {
       const shape = classifyMark(text);
       if (shape) {
@@ -135719,15 +137081,22 @@ async function stampPdf({
       }
       let size2 = m.markFontSize != null ? m.checkbox ? m.markFontSize : Math.min(m.markFontSize, Math.min(h, w)) : m.checkbox ? Math.min(h, w) * CHECKBOX_AUTO_FILL : Math.min(Math.min(h, w) * 0.8, 16);
       size2 = Math.max(6, size2);
-      const tw2 = measure(text, size2);
-      drawMixed(page, text, x0 + (w - tw2) / 2, y0 + (h - size2 * 0.7) / 2, size2);
+      const tw2 = measureText(body, size2);
+      drawLine2(toDraw([body])[0], x0 + (w - tw2) / 2, y0 + (h - size2 * 0.7) / 2, size2);
       return;
     }
     if (m.multiline) {
       const start = m.fontSize ?? MULTILINE_DEFAULT_FONT_SIZE;
       const padX = multilinePadPt(w);
       const padY = multilinePadPt(h);
-      const { size: size2, lines } = m.autoFit === false ? { size: start, lines: wrapLines(text, w - 2 * padX, start, measure) } : fitWrapped(text, w - 2 * padX, h - 2 * padY, start, measure, MULTILINE_MIN_FONT_SIZE);
+      const { size: size2, lines } = m.autoFit === false ? { size: start, lines: wrapLines(body, w - 2 * padX, start, measureText) } : fitWrapped(
+        body,
+        w - 2 * padX,
+        h - 2 * padY,
+        start,
+        measureText,
+        MULTILINE_MIN_FONT_SIZE
+      );
       const placed = layoutMultiline({
         x0,
         y0,
@@ -135735,28 +137104,28 @@ async function stampPdf({
         h,
         size: size2,
         lines,
-        anchor: m.anchor ?? DEFAULT_TEXT_ANCHOR,
+        anchor: anchorOf(m.anchor),
         padX,
         padY,
-        measure
+        measure: measureText
+      });
+      const drawn = toDraw(lines);
+      placed.forEach((p4, i2) => {
+        if (p4.text !== "") drawLine2(drawn[i2], p4.x, p4.y, size2);
       });
-      for (const p4 of placed) {
-        if (p4.text === "") continue;
-        drawMixed(page, p4.text, p4.x, p4.y, size2);
-      }
       onPlacement?.({
         key: m.key,
         page: pageNum,
         multiline: true,
         size: size2,
         startSize: start,
-        fits: lines.length * size2 * LINE_HEIGHT_FACTOR <= h - 2 * padY + 0.01 && lines.every((l) => measure(l, size2) <= w - 2 * padX + 0.01)
+        fits: lines.length * size2 * LINE_HEIGHT_FACTOR <= h - 2 * padY + 0.01 && lines.every((l) => measureText(l, size2) <= w - 2 * padX + 0.01)
       });
       return;
     }
     const startPt = m.autoFit ? autoTextStartPt(h) : m.fontSize ?? DEFAULT_FONT_SIZE;
-    const size = fitFontSize(text, w - 2 * pad, startPt, measure);
-    const tw = measure(text, size);
+    const size = fitFontSize(body, w - 2 * pad, startPt, measureText);
+    const tw = measureText(body, size);
     const { x: x2, y } = anchorPdfXY({
       x0,
       y0,
@@ -135764,10 +137133,10 @@ async function stampPdf({
       h,
       tw,
       size,
-      anchor: m.anchor ?? DEFAULT_TEXT_ANCHOR,
+      anchor: anchorOf(m.anchor),
       pad
     });
-    drawMixed(page, text, x2, y, size);
+    drawLine2(toDraw([body])[0], x2, y, size);
     onPlacement?.({
       key: m.key,
       page: pageNum,
@@ -136834,6 +138203,7 @@ async function drawCheckPdf(stamped, entries, status, fonts, banner, tags, avoid
     const { default: fontkit } = await Promise.resolve().then(() => __toESM(require_fontkit_umd()));
     doc.registerFontkit(fontkit);
     const faces = await embedStampFaces(doc, fontkit, fonts);
+    const rtlLayer = wanted.some((h) => needsBidi(h.text)) ? await Promise.resolve().then(() => (init_rtlStamp(), rtlStamp_exports)) : void 0;
     const unreadable = /* @__PURE__ */ new Set();
     for (const h of wanted) {
       step("table headers", h.gid);
@@ -136848,34 +138218,44 @@ async function drawCheckPdf(stamped, entries, status, fonts, banner, tags, avoid
         const inside = w >= 40 && ht >= HEAD + 1;
         const room = inside ? w - 1 : prefix === "R" ? Math.min(120, cx2 - 1) : Math.max(2 * w, 30);
         const chars3 = Array.from(
-          `${prefix}: ${h.text}`,
+          h.text,
           (ch) => faces.hasGlyph(ch.codePointAt(0) ?? 0) ? ch : "?"
         );
-        if (chars3.join("") !== `${prefix}: ${h.text}` && !unreadable.has(h.gid)) {
+        if (chars3.join("") !== h.text && !unreadable.has(h.gid)) {
           unreadable.add(h.gid);
           notes.push(
             `${h.gid}: the check copy cannot draw some header characters (shown as "?"); the legend's header_rows / header_cols hold the full text`
           );
         }
-        const cut = (n) => `${chars3.slice(0, n).join("")}\u2026`;
-        let text = chars3.join("");
-        if (chars3.length > 4 && faces.measure(text, HEAD) > room) {
-          let lo = 3;
+        const bidi2 = rtlLayer && needsBidi(h.text) ? rtlLayer : void 0;
+        const rtl = stampsRtl(h.text);
+        const lead = rtl ? `\u2066${prefix}:\u2069 ` : `${prefix}: `;
+        const shaped = (t) => bidi2 ? bidi2.shapeArabic(t) : t;
+        const width = (t) => faces.measure(bidi2 ? stripBidiControls(bidi2.shapeArabic(t)) : t, HEAD);
+        const cut = (n) => `${lead}${chars3.slice(0, n).join("")}\u2026`;
+        let text = `${lead}${chars3.join("")}`;
+        if (chars3.length > 1 && width(text) > room) {
+          let lo = 0;
           let hi = chars3.length - 2;
           while (lo < hi) {
             const mid = Math.ceil((lo + hi) / 2);
-            if (faces.measure(cut(mid), HEAD) <= room) lo = mid;
+            if (width(cut(mid)) <= room) lo = mid;
             else hi = mid - 1;
           }
           text = cut(lo);
         }
-        const tw = faces.measure(text, HEAD);
-        const x2 = inside ? cx2 + 0.6 : prefix === "R" ? cx2 - tw - 0.8 : cx2;
+        const body = shaped(text);
+        const tw = width(text);
+        const x2 = inside ? rtl ? cx2 + w - 0.6 - tw : cx2 + 0.6 : prefix === "R" ? cx2 - tw - 0.8 : cx2;
         const y = inside ? top - HEAD - 0.4 - h.below : prefix === "R" ? top - ht / 2 - HEAD / 2 : top + 0.6;
         heads.push({
           head: h,
           draw: () => {
-            faces.draw(page, text, x2, y, HEAD, headColor);
+            if (bidi2) {
+              faces.drawVisual(page, bidi2.visualLine(body, rtl), x2, y, HEAD, headColor);
+            } else {
+              faces.draw(page, text, x2, y, HEAD, headColor);
+            }
           }
         });
         const taken = placedTags.get(cell.field.page) ?? [];
@@ -137024,6 +138404,14 @@ async function drawCheckPdf(stamped, entries, status, fonts, banner, tags, avoid
   step("save");
   return { pdf: await doc.save(), notes };
 }
+var UnsupportedScriptError = class extends Error {
+  ids;
+  constructor(ids) {
+    super(`These values need a Japanese font that wasn't provided: ${ids.join(", ")}`);
+    this.name = "UnsupportedScriptError";
+    this.ids = ids;
+  }
+};
 async function fillAgentPdf(a) {
   if (!isRecord(a.render)) throw new TypeError("render must be the template's schema object");
   const schema = normalizeSchema(a.render);
@@ -137035,6 +138423,13 @@ async function fillAgentPdf(a) {
     values: m.values,
     rowCounts: m.rowCounts
   });
+  if (!a.fonts.jp && marksNeedJpFace(marksByPage)) {
+    const ids = /* @__PURE__ */ new Set();
+    for (const marks of marksByPage.values()) {
+      for (const mk of marks) if (needsJpFace(mk.text)) ids.add(ownerOf(mk.key, m.keyIds));
+    }
+    throw new UnsupportedScriptError([...ids]);
+  }
   const placements = [];
   const pdf = await stampPdf({
     pdfBytes: a.pdfBytes,
@@ -137860,8 +139255,8 @@ async function estimateAnalyze(e4) {
 
 // src/fill.ts
 import { randomBytes as randomBytes2 } from "node:crypto";
-import { promises as fsp2, readFileSync as readFileSync3, statSync } from "node:fs";
-import { basename, dirname as dirname4, isAbsolute as isAbsolute2, join as join5, relative, resolve as resolve2 } from "node:path";
+import { promises as fsp3, readFileSync as readFileSync3, statSync } from "node:fs";
+import { basename, dirname as dirname5, isAbsolute as isAbsolute2, join as join6, relative, resolve as resolve2 } from "node:path";
 
 // src/config.ts
 import { homedir } from "node:os";
@@ -137979,10 +139374,193 @@ function loadFonts(dir = defaultFontsDir()) {
   }
 }
 
+// src/jpFont.ts
+import { createHash as createHash2 } from "node:crypto";
+import { promises as fsp2 } from "node:fs";
+import { dirname as dirname3, join as join4 } from "node:path";
+
+// src/version.ts
+var VERSION = true ? "0.2.4" : "0.0.0-dev";
+var USER_AGENT = `fenfill-mcp/${VERSION}`;
+
+// src/jpFont.ts
+var DEFAULT_JP_FONT_URL = "https://fenfill.com/fonts/NotoSansJP-Regular.ttf";
+var JP_FONT_FILE = "NotoSansJP-Regular.ttf";
+var JP_FONT_TIMEOUT_MS = 3e4;
+var IS_WIN2 = process.platform === "win32";
+var JpFontError = class extends Error {
+  reason;
+  status;
+  constructor(reason, message, status) {
+    super(message);
+    this.name = "JpFontError";
+    this.reason = reason;
+    this.status = status;
+  }
+};
+function jpFontPath(cacheDir) {
+  return join4(cacheDir, "fonts", JP_FONT_FILE);
+}
+var sha256 = (b) => createHash2("sha256").update(b).digest("hex");
+var memo2 = /* @__PURE__ */ new Map();
+function ensureJpFace(o) {
+  const url2 = o.url ?? DEFAULT_JP_FONT_URL;
+  const key = `${o.cacheDir}\0${url2}`;
+  const hit = memo2.get(key);
+  if (hit) return hit;
+  const p4 = load({ ...o, url: url2 }).catch((e4) => {
+    memo2.delete(key);
+    throw e4;
+  });
+  memo2.set(key, p4);
+  return p4;
+}
+async function load(o) {
+  const path = jpFontPath(o.cacheDir);
+  try {
+    const buf = await fsp2.readFile(path);
+    if (sha256(buf) === JP_FACE_SHA256) return toArrayBuffer(buf);
+    await fsp2.rm(path, { force: true });
+  } catch {
+  }
+  const bytes = await download(o);
+  if (bytes.byteLength !== JP_FACE_BYTES || sha256(bytes) !== JP_FACE_SHA256) {
+    throw new JpFontError("hash_mismatch", "The downloaded font doesn't match its pinned sha256.");
+  }
+  try {
+    await writeFont(path, bytes);
+  } catch (e4) {
+    log("warn", "could not cache the Japanese font; using it for this session only", {
+      error: errText(e4)
+    });
+  }
+  return toArrayBuffer(bytes);
+}
+async function download(o) {
+  const fetchImpl = o.fetchImpl ?? fetch;
+  const ctl = new AbortController();
+  let timedOut = false;
+  const timer = setTimeout(() => {
+    timedOut = true;
+    ctl.abort();
+  }, o.timeoutMs ?? JP_FONT_TIMEOUT_MS);
+  try {
+    let res;
+    try {
+      res = await fetchImpl(o.url, {
+        method: "GET",
+        headers: { "User-Agent": USER_AGENT },
+        redirect: "follow",
+        signal: ctl.signal
+      });
+    } catch (e4) {
+      if (timedOut) throw new JpFontError("timeout", "The font download timed out.");
+      throw new JpFontError("network", `The font download failed: ${errText(e4)}`);
+    }
+    if (!res.ok) {
+      throw new JpFontError(
+        "http_status",
+        `The font download returned HTTP ${res.status}.`,
+        res.status
+      );
+    }
+    if (!sameHttpsHost(o.url, res)) {
+      await res.body?.cancel().catch(() => void 0);
+      throw new JpFontError("http_status", "The font download was redirected to another host.");
+    }
+    const declared = Number(res.headers.get("content-length") ?? NaN);
+    if (Number.isFinite(declared) && declared !== JP_FACE_BYTES) {
+      ctl.abort();
+      if (declared > JP_FACE_BYTES) {
+        throw new JpFontError("too_large", "The font download is larger than expected.");
+      }
+      throw new JpFontError(
+        "hash_mismatch",
+        "The downloaded font doesn't match its pinned sha256."
+      );
+    }
+    try {
+      return await readCapped(res, ctl);
+    } catch (e4) {
+      if (e4 instanceof JpFontError) throw e4;
+      if (timedOut) throw new JpFontError("timeout", "The font download timed out.");
+      throw new JpFontError("network", `The font download failed: ${errText(e4)}`);
+    }
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function sameHttpsHost(requested, res) {
+  if (!res.url) return !res.redirected;
+  try {
+    const a = new URL(requested);
+    const b = new URL(res.url);
+    return b.protocol === "https:" && b.host === a.host;
+  } catch {
+    return false;
+  }
+}
+async function readCapped(res, ctl) {
+  const tooLarge = () => {
+    ctl.abort();
+    return new JpFontError("too_large", "The font download is larger than expected.");
+  };
+  if (!res.body) {
+    const b = new Uint8Array(await res.arrayBuffer());
+    if (b.byteLength > JP_FACE_BYTES) throw tooLarge();
+    return b;
+  }
+  const reader = res.body.getReader();
+  const chunks = [];
+  let total = 0;
+  for (; ; ) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    total += value.byteLength;
+    if (total > JP_FACE_BYTES) {
+      await reader.cancel().catch(() => void 0);
+      throw tooLarge();
+    }
+    chunks.push(value);
+  }
+  const out = new Uint8Array(total);
+  let off = 0;
+  for (const c2 of chunks) {
+    out.set(c2, off);
+    off += c2.byteLength;
+  }
+  return out;
+}
+async function writeFont(path, bytes) {
+  const dir = dirname3(path);
+  await fsp2.mkdir(dir, { recursive: true, mode: 448 });
+  if (!IS_WIN2) await fsp2.chmod(dir, 448);
+  await writeFileAtomic(path, bytes, 384);
+}
+function errText(e4) {
+  const cause = e4 instanceof Error && e4.cause instanceof Error ? ` (${e4.cause.message})` : "";
+  return e4 instanceof Error ? `${e4.message}${cause}` : String(e4);
+}
+function jpFontReason(e4) {
+  if (!(e4 instanceof JpFontError)) return errText(e4);
+  switch (e4.reason) {
+    case "network":
+      return "network error";
+    case "timeout":
+      return "the download timed out";
+    case "http_status":
+      return `HTTP ${String(e4.status)}`;
+    case "hash_mismatch":
+      return "the file didn't match its pinned checksum";
+    case "too_large":
+      return "the download was larger than expected";
+  }
+}
+
 // src/render.ts
 import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
 import { createRequire as createRequire2 } from "node:module";
-import { dirname as dirname3, join as join4 } from "node:path";
+import { dirname as dirname4, join as join5 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 import { deflateSync } from "node:zlib";
 var DEFAULT_DPI = 110;
@@ -137991,8 +139569,8 @@ var MIN_DPI = 36;
 var MAX_SIDE_PX = 3e3;
 var loading = null;
 function wasmPath() {
-  const here = dirname3(fileURLToPath2(import.meta.url));
-  const bundled = join4(here, "pdfium.wasm");
+  const here = dirname4(fileURLToPath2(import.meta.url));
+  const bundled = join5(here, "pdfium.wasm");
   if (existsSync2(bundled)) return bundled;
   const req = createRequire2(import.meta.url);
   return req.resolve("@embedpdf/pdfium/pdfium.wasm");
@@ -138266,14 +139844,10 @@ function encodePng2(r) {
   );
 }
 
-// src/version.ts
-var VERSION = true ? "0.2.3" : "0.0.0-dev";
-var USER_AGENT = `fenfill-mcp/${VERSION}`;
-
 // src/fill.ts
 var MAX_INPUT_BYTES = 512 * 1024 * 1024;
 var MAX_IMAGE_BYTES2 = 5 * 1024 * 1024;
-var IS_WIN2 = process.platform === "win32";
+var IS_WIN3 = process.platform === "win32";
 var OUTPUT_TAGS = { [MCP_OUTPUT_TAG]: `fenfill-mcp/${VERSION}` };
 var LOGO_SENTINEL = "fenfill-mcp:logo";
 function absPath(p4, what) {
@@ -138289,7 +139863,7 @@ async function readInputPdf(path) {
   const abs2 = absPath(path, "path");
   let st;
   try {
-    st = await fsp2.stat(abs2);
+    st = await fsp3.stat(abs2);
   } catch {
     throw new ToolError("file_not_found", "No file at that path.", {
       hint: "Check the path (it must be absolute or start with ~/)."
@@ -138297,7 +139871,7 @@ async function readInputPdf(path) {
   }
   if (!st.isFile()) throw new ToolError("not_a_file", "That path is not a file.");
   if (st.size > MAX_INPUT_BYTES) throw new ToolError("file_too_large", "The file is too large.");
-  const bytes = new Uint8Array(await fsp2.readFile(abs2));
+  const bytes = new Uint8Array(await fsp3.readFile(abs2));
   const head = Buffer.from(bytes.subarray(0, 1024)).toString("latin1");
   if (!head.includes("%PDF-")) {
     throw new ToolError("not_pdf", "The file is not a PDF.", { hint: "Pass a PDF file." });
@@ -138316,13 +139890,13 @@ async function caseInsensitiveAt(dir) {
   const swapped = swapCase(dir);
   if (swapped !== dir) {
     try {
-      const [a, b] = await Promise.all([fsp2.stat(dir), fsp2.stat(swapped)]);
+      const [a, b] = await Promise.all([fsp3.stat(dir), fsp3.stat(swapped)]);
       return a.dev === b.dev && a.ino === b.ino;
     } catch {
       return false;
     }
   }
-  return process.platform === "darwin" || IS_WIN2;
+  return process.platform === "darwin" || IS_WIN3;
 }
 function isInside(child, parent) {
   const rel2 = relative(parent, child);
@@ -138333,20 +139907,20 @@ async function resolveOutputPath(outputPath, opts) {
   if (!out.toLowerCase().endsWith(".pdf")) {
     throw new ToolError("invalid_output_path", "output_path must end in .pdf.");
   }
-  const dir = dirname4(out);
+  const dir = dirname5(out);
   let realDir;
   try {
-    realDir = await fsp2.realpath(dir);
-    if (!(await fsp2.stat(realDir)).isDirectory()) throw new Error("not a dir");
+    realDir = await fsp3.realpath(dir);
+    if (!(await fsp3.stat(realDir)).isDirectory()) throw new Error("not a dir");
   } catch {
     throw new ToolError("invalid_output_path", "The output folder doesn't exist.", {
       hint: "Create the folder first, or pick an existing one."
     });
   }
-  const realOut = join5(realDir, basename(out));
+  const realOut = join6(realDir, basename(out));
   let realCache = resolve2(opts.cacheRoot);
   try {
-    realCache = await fsp2.realpath(realCache);
+    realCache = await fsp3.realpath(realCache);
   } catch {
   }
   const ci = await caseInsensitiveAt(realDir);
@@ -138358,7 +139932,7 @@ async function resolveOutputPath(outputPath, opts) {
   }
   let existing = null;
   try {
-    existing = await fsp2.stat(out);
+    existing = await fsp3.stat(out);
   } catch {
     existing = null;
   }
@@ -138367,12 +139941,12 @@ async function resolveOutputPath(outputPath, opts) {
       hint: "Write the filled PDF to a new file; the blank form stays untouched."
     });
     if (existing) {
-      const input2 = await fsp2.stat(opts.inputAbs);
+      const input2 = await fsp3.stat(opts.inputAbs);
       if (existing.dev === input2.dev && existing.ino === input2.ino && input2.ino !== 0) throw same();
     }
     let realIn = opts.inputAbs;
     try {
-      realIn = await fsp2.realpath(opts.inputAbs);
+      realIn = await fsp3.realpath(opts.inputAbs);
     } catch {
     }
     if (fold(realOut) === fold(realIn)) throw same();
@@ -138390,36 +139964,36 @@ async function resolveOutputPath(outputPath, opts) {
   return out;
 }
 async function writeOutputAtomic(out, pdf, overwrite) {
-  const tmp = join5(dirname4(out), `.${basename(out)}.${randomBytes2(6).toString("hex")}.tmp`);
+  const tmp = join6(dirname5(out), `.${basename(out)}.${randomBytes2(6).toString("hex")}.tmp`);
   let fh = null;
   const exists = () => new ToolError("output_exists", "A file already exists at output_path.", {
     hint: "Pick a new file name, or pass overwrite=true to replace it."
   });
   try {
-    fh = await fsp2.open(tmp, "wx", 384);
+    fh = await fsp3.open(tmp, "wx", 384);
     await fh.writeFile(pdf);
     await fh.sync();
     await fh.close();
     fh = null;
     if (overwrite) {
-      await fsp2.rename(tmp, out);
+      await fsp3.rename(tmp, out);
     } else {
       try {
-        await fsp2.link(tmp, out);
-        await fsp2.rm(tmp, { force: true });
+        await fsp3.link(tmp, out);
+        await fsp3.rm(tmp, { force: true });
       } catch (e4) {
         if (e4.code === "EEXIST") throw exists();
-        if (await fsp2.stat(out).then(
+        if (await fsp3.stat(out).then(
           () => true,
           () => false
         ))
           throw exists();
-        await fsp2.rename(tmp, out);
+        await fsp3.rename(tmp, out);
       }
     }
   } catch (e4) {
     if (fh) await fh.close().catch(() => void 0);
-    await fsp2.rm(tmp, { force: true }).catch(() => void 0);
+    await fsp3.rm(tmp, { force: true }).catch(() => void 0);
     if (e4 instanceof ToolError) throw e4;
     throw new ToolError("write_failed", "Couldn't write the output PDF.", {
       hint: "Check that the folder is writable.",
@@ -138435,6 +140009,36 @@ function loadImage(p4) {
   if (st.size > MAX_IMAGE_BYTES2) throw new Error("The signature image is over 5 MB.");
   return new Uint8Array(readFileSync3(abs2));
 }
+function unsupportedScriptError(e4, why) {
+  const where = "The check covers the whole document, so preview_page refuses even when these values are on another page.";
+  return new ToolError(
+    "unsupported_script",
+    `Japanese characters need the Noto Sans JP font, which couldn't be loaded (fields: ${e4.ids.join(", ")}).`,
+    {
+      hint: why ? `Couldn't download the Japanese font (${why.text}); connect to the internet once and retry, or pre-seed ${why.path} (from ${DEFAULT_JP_FONT_URL}). ${where}` : `The Japanese font isn't available to this call. ${where} Drop or replace those values, or fill this form at fenfill.com.`,
+      details: { ids: e4.ids, ...why ? { reason: why.reason } : {} }
+    }
+  );
+}
+async function fillWithJpFace(args, jp) {
+  try {
+    return await fillAgentPdf(args);
+  } catch (e4) {
+    if (!(e4 instanceof UnsupportedScriptError)) throw e4;
+    if (!jp) throw unsupportedScriptError(e4);
+    let face;
+    try {
+      face = await jp.load();
+    } catch (fe) {
+      throw unsupportedScriptError(e4, {
+        reason: fe instanceof JpFontError ? fe.reason : "error",
+        text: jpFontReason(fe),
+        path: jp.path
+      });
+    }
+    return await fillAgentPdf({ ...args, fonts: { ...args.fonts, jp: face } });
+  }
+}
 function isPasswordError(e4) {
   return e4 instanceof Error && /password/i.test(e4.message);
 }
@@ -138464,19 +140068,23 @@ async function stampAndWrite(a) {
   const printed = a.checkAbs ? await printedBoxes(a.pdfBytes, pages) : void 0;
   let res;
   try {
-    res = await fillAgentPdf({
-      pdfBytes: toArrayBuffer(a.pdfBytes),
-      render: a.render,
-      input: a.agentInput,
-      fonts: a.fonts,
-      branding: a.branding,
-      logoBytes: a.logoBytes,
-      loadImage,
-      infoTags: OUTPUT_TAGS,
-      check: !!a.checkAbs,
-      checkPrinted: printed
-    });
+    res = await fillWithJpFace(
+      {
+        pdfBytes: toArrayBuffer(a.pdfBytes),
+        render: a.render,
+        input: a.agentInput,
+        fonts: a.fonts,
+        branding: a.branding,
+        logoBytes: a.logoBytes,
+        loadImage,
+        infoTags: OUTPUT_TAGS,
+        check: !!a.checkAbs,
+        checkPrinted: printed
+      },
+      a.jpFace
+    );
   } catch (e4) {
+    if (e4 instanceof UnsupportedScriptError) throw unsupportedScriptError(e4);
     if (isPasswordError(e4)) throw passwordError();
     if (isFillForbiddenError(e4)) throw fillForbiddenError();
     throw e4;
@@ -139807,11 +141415,11 @@ function inPrintedFormat(digits2, fmt3) {
   let i2 = 0;
   return cells.map((c2) => isLetter(c2) ? d[i2++] : c2).join("");
 }
-var LETTER = "[\\p{Lu}\\p{Ll}\\p{Lt}\\p{Lm}\\p{M}]";
-var HAS_LETTER = new RegExp(LETTER, "u");
+var LETTER2 = "[\\p{Lu}\\p{Ll}\\p{Lt}\\p{Lm}\\p{M}]";
+var HAS_LETTER = new RegExp(LETTER2, "u");
 var DIGIT = "\\p{Nd}";
-var ENDS = [new RegExp(`${LETTER}$`, "u"), new RegExp(`${DIGIT}$`, "u")];
-var STARTS = [new RegExp(`^${LETTER}`, "u"), new RegExp(`^${DIGIT}`, "u")];
+var ENDS = [new RegExp(`${LETTER2}$`, "u"), new RegExp(`${DIGIT}$`, "u")];
+var STARTS = [new RegExp(`^${LETTER2}`, "u"), new RegExp(`^${DIGIT}`, "u")];
 var runsOn = (left, right) => ENDS.some((end, i2) => end.test(left) && STARTS[i2].test(right));
 function holds(n, v) {
   if (v.includes(" ") || !HAS_LETTER.test(v)) return true;
@@ -140994,13 +142602,37 @@ function tableIssues(d, g) {
     if (ids.some((id) => d.field.get(id)?.type !== "checkbox"))
       at("a checkbox_matrix cell isn't a checkbox");
   } else {
-    for (let i2 = 0; i2 < lineCount(v, v.axis); i2++) {
-      const keys = new Set(lineFields(d, v, v.axis, i2).map(typeKey));
-      if (keys.size > 1) at(`${axisWord(v.axis)} ${String(i2)} mixes types`);
-    }
+    for (const i2 of mixedLines(d, g)) at(`${axisWord(v.axis)} ${String(i2)} mixes types`);
   }
   return out;
 }
+function mixedLines(d, g) {
+  return mixedLineCells(d, g).map((l) => l.index);
+}
+function mixedLineCells(d, g) {
+  const grid = g.grid;
+  if (!Array.isArray(grid) || grid.some((r) => !Array.isArray(r))) return [];
+  const rows = grid.length;
+  const v = {
+    g,
+    grid,
+    rows,
+    cols: rows ? grid[0].length : 0,
+    axis: g.orientation === "row" ? "row" : "col",
+    format: formatOf(g)
+  };
+  if (v.format === "checkbox_matrix") return [];
+  const out = [];
+  for (let i2 = 0; i2 < lineCount(v, v.axis); i2++) {
+    const cells = lineFields(d, v, v.axis, i2);
+    const keys = new Set(cells.map(typeKey));
+    if (keys.size > 1) out.push({ index: i2, ids: cells.map((f3) => f3.id), keys: [...keys] });
+  }
+  return out;
+}
+function lineWord(g) {
+  return axisWord(g.orientation === "row" ? "row" : "col");
+}
 
 // src/validate.ts
 var MAX_ID = 200;
@@ -141771,7 +143403,7 @@ function applyOne(d, op, warnings, opts) {
         added: gid,
         members: readingMembers(d, g).map((m) => m.id),
         section: sectionOf(d, page, gid),
-        ...op.kind === "comb" ? { comb: gid } : {}
+        ...op.kind === "comb" ? { comb: gid } : { batchOrder: { id: gid, ids: fs.map((f3) => f3.id) } }
       };
     }
     case "ungroup": {
@@ -141795,15 +143427,22 @@ function applyOne(d, op, warnings, opts) {
       if (op.options.every((o) => typeof o === "string")) {
         if (op.options.length !== opts2.length) {
           return bad(
-            `this group has ${String(opts2.length)} options; pass that many labels (in the order the options are listed), or [{id, label}] pairs. Add an option with add_option, or remove one with remove_option.`
+            `this group has ${String(opts2.length)} options; pass that many labels (they go in the order of the ids of this call's group op that made it, else in reading order, as get_template lists them), or [{id, label}] pairs. Add an option with add_option, or remove one with remove_option.`
           );
         }
-        const byId = buildFieldById(d.s.fields);
-        const ordered = resolveMembers(g, byId);
-        ordered.forEach((f3, i2) => {
-          const live = d.field.get(f3.id);
+        const reading = readingMembers(d, g).map((m) => m.id);
+        const given = d.batchGroups?.get(g.id);
+        const current = new Set(opts2.map((m) => m.id));
+        const order = given && given.length === current.size && given.every((id) => current.has(id)) ? given : reading;
+        order.forEach((id, i2) => {
+          const live = d.field.get(id);
           if (live) live.label = op.options[i2].trim();
         });
+        if (order.some((id, i2) => id !== reading[i2])) {
+          warnings.push(
+            `options_order_differs_from_reading_order: group ${g.id}'s labels follow the ids order of its group op (${order.join(", ")}), not reading order (${reading.join(", ")}); check them, or pass [{id, label}]`
+          );
+        }
       } else {
         for (const o of op.options) {
           if (!isRec2(o) || typeof o.id !== "string" || typeof o.label !== "string") {
@@ -141815,7 +143454,13 @@ function applyOne(d, op, warnings, opts) {
           f3.label = o.label.trim();
         }
       }
-      return { touched: [g.id] };
+      return {
+        touched: [g.id],
+        options: readingMembers(d, g).map((m) => ({
+          id: m.id,
+          label: typeof m.label === "string" ? m.label : ""
+        }))
+      };
     }
     case "add_option": {
       const g = needGroup(d, op.id);
@@ -141945,7 +143590,7 @@ function applyOne(d, op, warnings, opts) {
     case "set_headers":
       return table(setHeaders(d, raw, warnings));
     case "reorder":
-      return reorder(d, raw, warnings);
+      return reorder2(d, raw, warnings);
     case "set_section":
       return setSection(d, raw);
     case "set_section_title":
@@ -141954,7 +143599,7 @@ function applyOne(d, op, warnings, opts) {
       return bad(`unknown op "${String(op.op)}"; ops: ${OP_NAMES.join(", ")}`);
   }
 }
-function reorder(d, op, warnings) {
+function reorder2(d, op, warnings) {
   const page = pageOf(d, op.page);
   if (!Array.isArray(op.ids) || op.ids.length === 0)
     return bad("ids must list the entries to order");
@@ -142361,6 +144006,7 @@ function applyPass(render, ops, excluded, screen, opts) {
   const told = [];
   const confirmed = [];
   const refs = /* @__PURE__ */ new Map();
+  const batchGroups = /* @__PURE__ */ new Map();
   let applied = 0;
   ops.forEach((raw, i2) => {
     const skip = excluded.get(i2);
@@ -142371,6 +144017,7 @@ function applyPass(render, ops, excluded, screen, opts) {
     const draft = structuredClone(cur);
     const d2 = index(draft);
     d2.refs = refs;
+    d2.batchGroups = batchGroups;
     const w = [];
     try {
       const given = isRec2(raw) ? raw.ref : void 0;
@@ -142384,12 +144031,42 @@ function applyPass(render, ops, excluded, screen, opts) {
         bad(
           "ref names what an op adds (add, group, add_option, comb_add_cell\u2026); this op adds nothing"
         );
-      const issues = touchedIssues(d2, r.touched, r.tables);
+      let issues = touchedIssues(d2, r.touched, r.tables);
+      if (issues.length) {
+        const before = index(cur);
+        const had = new Set(
+          touchedIssues(
+            before,
+            r.touched.filter((id) => before.field.has(id) || before.group.has(id)),
+            (r.tables ?? []).filter((id) => before.group.has(id))
+          ).map((x2) => `${x2.path} ${x2.reason}`)
+        );
+        const stillMixed = (x2) => {
+          const m = / (\d+) mixes types$/.exec(x2.reason);
+          const g = d2.group.get(x2.id ?? "");
+          const was = before.group.get(x2.id ?? "");
+          if (!m || !g || !was) return false;
+          const now = mixedLineCells(d2, g).find((l) => l.index === Number(m[1]));
+          return !!now && mixedLineCells(before, was).some(
+            (l) => now.ids.some((id) => l.ids.includes(id)) && now.keys.every((k4) => l.keys.includes(k4))
+          );
+        };
+        issues = issues.filter((x2) => !had.has(`${x2.path} ${x2.reason}`) && !stillMixed(x2));
+      }
       if (issues.length) {
         bad(
           issues.slice(0, 5).map((x2) => `${x2.path} ${x2.reason}`).join("; ")
         );
       }
+      for (const id of r.tables ?? []) {
+        const g = d2.group.get(id);
+        const mixed = g ? mixedLines(d2, g) : [];
+        if (!g || !mixed.length) continue;
+        const word = lineWord(g);
+        w.push(
+          `table ${id}: ${mixed.map((n) => `${word} ${String(n)}`).join(", ")} still store${mixed.length === 1 ? "s" : ""} mixed types; fill, print and get_template use one type per ${word} (its first typed cell's), so set_column_type or set_format a cell of each to settle them`
+        );
+      }
       let vouched = [];
       if (screen) {
         const changed = changedWording(cur, draft);
@@ -142426,11 +144103,13 @@ function applyPass(render, ops, excluded, screen, opts) {
         ...r.order ? { order: r.order } : {},
         ...r.section !== void 0 ? { section: r.section } : {},
         ...r.members ? { members: r.members } : {},
+        ...r.options ? { options: r.options } : {},
         ...noop ? { noop: true } : {}
       });
       cur = draft;
       applied++;
       if (typeof ref === "string" && r.added) refs.set(ref, r.added);
+      if (r.batchOrder) batchGroups.set(r.batchOrder.id, r.batchOrder.ids);
       confirmed.push(...vouched);
       counts[name] = (counts[name] ?? 0) + 1;
       if (r.added) added.push({ op_index: i2, id: r.added });
@@ -142547,7 +144226,7 @@ function describeWording(wording, name = (id) => id) {
 }
 
 // src/snap.ts
-import { createHash as createHash2 } from "node:crypto";
+import { createHash as createHash3 } from "node:crypto";
 
 // src/rules.ts
 var INK_DELTA = 45;
@@ -142881,7 +144560,7 @@ function snapOnRules(rules, box, mode) {
   return line ? { box: toBox(line) } : { none: "no underline under the box" };
 }
 async function prepareSnapper(pdf, pages) {
-  const hash2 = createHash2("sha256").update(pdf).digest("hex");
+  const hash2 = createHash3("sha256").update(pdf).digest("hex");
   const ready = /* @__PURE__ */ new Map();
   for (const p4 of pages) ready.set(p4, await pageRules(pdf, hash2, p4));
   return (page, box, mode) => {
@@ -143554,23 +145233,27 @@ async function previewPage(a) {
   const printed = overlay === "full" ? await printedBoxes(a.pdfBytes, [a.page]) : void 0;
   let res;
   try {
-    res = await fillAgentPdf({
-      pdfBytes: toArrayBuffer(a.pdfBytes),
-      render: a.render,
-      input: a.values,
-      fonts: a.fonts,
-      branding: null,
-      logoBytes: null,
-      loadImage,
-      // "none" shows the stamped PDF itself: no check copy is built, so none can fail.
-      check: overlay !== "none",
-      // preview_page's JSON carries the colour key; the banner would only
-      // cover the top of page 1.
-      checkBanner: false,
-      checkTags: overlay === "full",
-      checkPrinted: printed
-    });
+    res = await fillWithJpFace(
+      {
+        pdfBytes: toArrayBuffer(a.pdfBytes),
+        render: a.render,
+        input: a.values,
+        fonts: a.fonts,
+        branding: null,
+        logoBytes: null,
+        loadImage,
+        // "none" shows the stamped PDF itself: no check copy is built, so none can fail.
+        check: overlay !== "none",
+        // preview_page's JSON carries the colour key; the banner would only
+        // cover the top of page 1.
+        checkBanner: false,
+        checkTags: overlay === "full",
+        checkPrinted: printed
+      },
+      a.jpFace
+    );
   } catch (e4) {
+    if (e4 instanceof UnsupportedScriptError) throw unsupportedScriptError(e4);
     if (isPasswordError(e4)) throw passwordError();
     if (isFillForbiddenError(e4)) throw fillForbiddenError();
     throw e4;
@@ -144088,8 +145771,8 @@ async function refreshTemplateAnalyses(deps, tid, after, requested, analyzed, wh
 }
 
 // src/sweep.ts
-import { promises as fsp3 } from "node:fs";
-import { join as join6 } from "node:path";
+import { promises as fsp4 } from "node:fs";
+import { join as join7 } from "node:path";
 var HOUR = 60 * 60 * 1e3;
 var DAY = 24 * HOUR;
 var SWEEP_INTERVAL_MS = DAY;
@@ -144099,14 +145782,14 @@ var OUTPUT_MARKER_MS = 365 * DAY;
 var LEFTOVER_MS = DAY;
 async function names(dir) {
   try {
-    return await fsp3.readdir(dir);
+    return await fsp4.readdir(dir);
   } catch {
     return [];
   }
 }
 async function ageMs(path, now) {
   try {
-    const st = await fsp3.stat(path);
+    const st = await fsp4.stat(path);
     return st.isFile() ? now - st.mtimeMs : null;
   } catch {
     return null;
@@ -144115,11 +145798,11 @@ async function ageMs(path, now) {
 async function dropIfOld(path, now, maxAgeMs) {
   const age = await ageMs(path, now);
   if (age === null || age <= maxAgeMs) return false;
-  await fsp3.rm(path, { force: true });
+  await fsp4.rm(path, { force: true });
   return true;
 }
 async function rmdirIfEmpty(dir) {
-  if ((await names(dir)).length === 0) await fsp3.rmdir(dir).catch(() => void 0);
+  if ((await names(dir)).length === 0) await fsp4.rmdir(dir).catch(() => void 0);
 }
 async function each(items2, fn5) {
   for (const n of items2) await fn5(n).catch(() => void 0);
@@ -144134,27 +145817,27 @@ async function sweepCache(cache3, now) {
     ["templates", "blank.pdf"],
     ["account", "logo.bin"]
   ]) {
-    await each(await names(join6(root, sub)), async (id) => {
-      const d = join6(root, sub, id);
-      count(await dropIfOld(join6(d, file2), now, ASSET_TTL_MS));
+    await each(await names(join7(root, sub)), async (id) => {
+      const d = join7(root, sub, id);
+      count(await dropIfOld(join7(d, file2), now, ASSET_TTL_MS));
       await each(await names(d), async (n) => {
-        if (n.startsWith(".")) count(await dropIfOld(join6(d, n), now, LEFTOVER_MS));
+        if (n.startsWith(".")) count(await dropIfOld(join7(d, n), now, LEFTOVER_MS));
       });
       await rmdirIfEmpty(d);
     });
   }
-  await each(await names(join6(root, "forms")), async (sha) => {
-    const d = join6(root, "forms", sha);
+  await each(await names(join7(root, "forms")), async (sha) => {
+    const d = join7(root, "forms", sha);
     await each(await names(d), async (n) => {
       const max2 = n.startsWith(".") ? LEFTOVER_MS : FORM_UNUSED_MS;
-      count(await dropIfOld(join6(d, n), now, max2));
+      count(await dropIfOld(join7(d, n), now, max2));
     });
     await rmdirIfEmpty(d);
   });
-  const pendDir = join6(root, "pending");
+  const pendDir = join7(root, "pending");
   await each(await names(pendDir), async (n) => {
     if (n.startsWith(".")) {
-      count(await dropIfOld(join6(pendDir, n), now, LEFTOVER_MS));
+      count(await dropIfOld(join7(pendDir, n), now, LEFTOVER_MS));
       return;
     }
     const t = /^t-([A-Za-z0-9_-]{1,64})\.([0-9a-f]{16})\.json$/.exec(n);
@@ -144172,12 +145855,15 @@ async function sweepCache(cache3, now) {
     if (p4.entry && holderAlive(p4.entry)) return;
     count(await cache3.removePending(m[1], m[2], { stamp: p4.stamp }));
   });
-  await each(await names(join6(root, "edits")), async (n) => {
+  await each(await names(join7(root, "edits")), async (n) => {
     const max2 = n.startsWith(".") ? LEFTOVER_MS : FORM_UNUSED_MS;
-    count(await dropIfOld(join6(root, "edits", n), now, max2));
+    count(await dropIfOld(join7(root, "edits", n), now, max2));
+  });
+  await each(await names(join7(root, "fonts")), async (n) => {
+    if (n.startsWith(".")) count(await dropIfOld(join7(root, "fonts", n), now, LEFTOVER_MS));
   });
-  await each(await names(join6(root, "outputs")), async (n) => {
-    count(await dropIfOld(join6(root, "outputs", n), now, OUTPUT_MARKER_MS));
+  await each(await names(join7(root, "outputs")), async (n) => {
+    count(await dropIfOld(join7(root, "outputs", n), now, OUTPUT_MARKER_MS));
   });
   return removed;
 }
@@ -144355,6 +146041,10 @@ function createFenfillServer(opts = {}) {
     await sleepTimer3(ms, void 0, { signal });
   });
   const cache3 = new Cache2(cacheDirFromEnv(env), now);
+  const jpFace = {
+    load: () => ensureJpFace({ cacheDir: cache3.root, fetchImpl: opts.fontFetchImpl, url: opts.jpFontUrl }),
+    path: jpFontPath(cache3.root)
+  };
   const stop = new AbortController();
   const owner = randomBytes5(8).toString("hex");
   LIVE_OWNERS.add(owner);
@@ -144557,7 +146247,7 @@ function createFenfillServer(opts = {}) {
     "fill_form",
     {
       title: "Fill an analyzed PDF locally",
-      description: `Fill a PDF you analyzed with analyze_form and write a new, flattened PDF. Runs entirely on this machine: no network, and the values never leave it. ${VALUE_SHAPES} Returns filled/skipped counts and warnings, including text shrunk hard or running past its box and filled boxes that overlap; pass check_pdf to see the result.`,
+      description: `Fill a PDF you analyzed with analyze_form and write a new, flattened PDF. Runs entirely on this machine and the values never leave it; the only network use is a one-time download of the public Japanese font from fenfill.com, the first time a value needs it (it carries no form data). ${VALUE_SHAPES} Returns filled/skipped counts and warnings, including text shrunk hard or running past its box and filled boxes that overlap; pass check_pdf to see the result.`,
       inputSchema: {
         path: external_exports.string().min(1).max(4096).describe("The same blank PDF you passed to analyze_form."),
         values: VALUES,
@@ -144594,6 +146284,7 @@ function createFenfillServer(opts = {}) {
         render,
         agentInput: answers,
         fonts: loadFonts(opts.fontsDir),
+        jpFace,
         branding: null,
         logoBytes: null,
         outputAbs,
@@ -144668,6 +146359,7 @@ function createFenfillServer(opts = {}) {
           render,
           agentInput: answers,
           fonts: loadFonts(opts.fontsDir),
+          jpFace,
           branding,
           logoBytes: logo ? toArrayBuffer(logo) : null,
           outputAbs,
@@ -144795,7 +146487,7 @@ function createFenfillServer(opts = {}) {
     "preview_page",
     {
       title: "Preview a page with its field boxes",
-      description: `Render one page as a PNG with every field box outlined (green filled, orange warning, red skipped, grey empty) and tagged with its id prefix, plus a legend: tag \u2192 id, type, label, box (page fractions, top-left origin, as edit_template uses), format and font_pt; options, table cells (row, col), table_rows columns and (in a crop) comb cells with their own boxes. placement_warnings ([] = checked, clean) covers every box shown: text much larger than its neighbours', a box over printed text (not on scans; a pale hint at its left edge is a placement_note), a box past its ruled cell, an option box on the wrong side of its caption. Use it as a read-only placement audit. values (see that parameter) stamp test values. overlay: "outline" drops the tags, "none" shows only the stamped page (e.g. after check_copy_failed). crop + zoom magnify a region; legend: "changed" lists only what changed since your last preview of the page (moved_into: fields now inside a table or group). It renders the local working copy (edit_template) when one exists, else the saved or analyzed version (edited: true/false). Rendered on this machine: nothing is written to disk and the values are never sent anywhere.`,
+      description: `Render one page as a PNG with every field box outlined (green filled, orange warning, red skipped, grey empty) and tagged with its id prefix, plus a legend: tag \u2192 id, type, label, box (page fractions, top-left origin), format and font_pt; options, table cells (row, col), table_rows columns and (in a crop) comb cells with their own boxes. placement_warnings ([] = checked, clean) covers every box shown: text much larger than its neighbours', a box over printed text (not on scans; a pale hint at its left edge is a placement_note), a box past its ruled cell, an option box on the wrong side of its caption. Read-only audit; values stamp test values. overlay: "outline" drops the tags, "none" shows only the stamped page (e.g. after check_copy_failed). crop + zoom magnify a region; legend: "changed" lists only what changed since your last preview of the page (moved_into: fields now in a table or group). Renders the edit_template working copy if any, else the saved or analyzed version (edited: true/false). Local: nothing is written to disk, values are never sent; the sole network use is a one-time download of fenfill.com's public Japanese font when a value first needs it (no form data).`,
       inputSchema: {
         path: TARGET_PATH,
         template_id: TARGET_TEMPLATE,
@@ -144857,6 +146549,7 @@ function createFenfillServer(opts = {}) {
           values: answers,
           dpi: args.dpi,
           fonts: loadFonts(opts.fontsDir),
+          jpFace,
           crop: args.crop,
           zoom: args.zoom,
           overlay: args.overlay
@@ -144943,7 +146636,7 @@ function createFenfillServer(opts = {}) {
         path: TARGET_PATH,
         template_id: TARGET_TEMPLATE,
         ops: external_exports.array(external_exports.record(external_exports.string(), external_exports.unknown())).max(MAX_OPS).optional().describe(
-          `Edit ops, applied in order (max ${String(MAX_OPS)}), each all-or-nothing; a box only has to lie on the page after the whole batch (so move then resize is fine). Fields: set_box {id, x, y, w, h, snap?} (absolute top-left + size; a group scales its members); move {id, dx, dy} or {id, x, y, snap?} (new top-left); resize {id, w, h}; add {page, type: text|multiline|date|checkbox|signature, box: {x, y, w, h}, label, description?, placeholder?, required?, section_id?, snap?} (diff_summary.added gives the new id, diff_summary.ops the section it landed in: without section_id, that of the nearest field at or above it); snap: "underline" fits the box onto the printed rule under it, "cell" into the ruled box around it, "answer" into that cell's blank part below (or after) its printed caption (read from the page on this machine; a miss keeps your box and warns); relabel {id, label}; retype {id, type} (a radio/multiselect group: radio|multiselect); delete {id}; set_format {id, format: {...}} (font_size, text_anchor, variant, date_format: DD/MM/YYYY|MM/DD/YYYY|YYYY-MM-DD|DD.MM.YYYY|DD-MM-YYYY; null removes a key; on a table cell it applies to the cell's whole column/row; a comb group: cell_type char|integer|date, or date_format with one D/M/Y letter per cell, e.g. DDMMYYYY, which makes it a date comb; diff_summary.ops shows the comb's cell_type, date_format and max_length); set_required {id, required}; set_description {id, description}; set_placeholder {id, placeholder} (null clears); set_autofill {id, autofill: a browser token (name, given-name, family-name, email, tel, street-address, postal-code, bday, \u2026) or null}. Groups: group {ids, kind: "choice"|"comb", label, multiple?} (standalone fields on one page; choice turns them into checkbox options; the members keep their ids, and diff_summary.ops lists them in reading order with the group's section; the group stands where its earliest member stood); ungroup {id}; set_options {id, options: ["label", \u2026] in listed order, or [{id, label}]}; add_option {id: group, label, box, index?} and remove_option {id: group, option} keep the group's id. Combs in one op: add {type: "comb", page, label, cells: N (box cut into N equal cells) | [{x, y, w, h}, \u2026] (each printed cell's box, for cells split by separators), box?, cell_type?, date_format?, section_id?} (its cells have no label); retype {id, type: "comb", cells, cell_type?, date_format?} turns a text/date field into a comb over its box, keeping label, section, order and required; comb_add_cell {id: comb, box, date_format?} and comb_remove_cell {id: cell, date_format?} (a date comb needs its new date_format, one letter per cell); group {kind: "comb"} takes cell_type and date_format too, and set_format on a comb's cell applies to its comb. Refs: any op that adds something takes ref: "name", and later ops of the same call write "$name" for its id (set_format {id: "$dob", \u2026}). Tables: group {kind: "table", label, cells: [[id|null, \u2026], \u2026] (rows \xD7 columns) or ids (laid out from their boxes), header_cols?, header_rows?, orientation?: "col"|"row" (the axis whose lines carry the types; default col), format?: classic|expandable|checkbox_matrix}; table_insert {id, axis: "row"|"col", index, box?: {y, h} for a row / {x, w} for a column (default: one pitch past the edge, or centred in the gap), header?, type?}; table_delete {id, axis, index, keep_cells?}; table_add_cell {id, row, col, box?} (fills an empty slot); table_adopt {id, field, row, col} (moves a loose field into an empty slot); set_column_type {id, index, type: text|number|currency|date|checkbox, date_format?} (index along the typed axis); set_orientation {id, orientation} (resets every cell to text); set_header {id, axis, index, text}; set_headers {id, axis, texts: [...], start?} (several at once). Order: reorder {page, ids} moves those top-level entries together, in that order, to where whichever of them is listed first now stands (not ids[0]'s place); every other entry keeps its relative order (stamps order; geometry no longer decides). A partial list moves only what it names: to put B right after A, list both; chained partial reorders are simplest replaced by one with the page's whole list. diff_summary.ops shows the order now listed. A section is listed as one run where its first entry stands, so entries of different sections never stand together: set_section {ids, section_id | null} moves fields or groups of one page to another of its sections (get_template shows each section's section_id; null = no section), and set_section_title {page, section_id, title} renames one. A reorder whose ids cannot come out as asked and that would change nothing in the listing is rejected. Every cell of one column (or row, when orientation is row) has one type.`
+          `Edit ops, applied in order (max ${String(MAX_OPS)}), each all-or-nothing; a box only has to lie on the page after the whole batch (so move then resize is fine). Fields: set_box {id, x, y, w, h, snap?} (absolute top-left + size; a group scales its members); move {id, dx, dy} or {id, x, y, snap?} (new top-left); resize {id, w, h}; add {page, type: text|multiline|date|checkbox|signature, box: {x, y, w, h}, label, description?, placeholder?, required?, section_id?, snap?} (diff_summary.added gives the new id, diff_summary.ops the section it landed in: without section_id, that of the nearest field at or above it); snap: "underline" fits the box onto the printed rule under it, "cell" into the ruled box around it, "answer" into that cell's blank part below (or after) its printed caption (read from the page on this machine; a miss keeps your box and warns); relabel {id, label}; retype {id, type} (a radio/multiselect group: radio|multiselect); delete {id}; set_format {id, format: {...}} (font_size, text_anchor, variant, date_format: DD/MM/YYYY|MM/DD/YYYY|YYYY-MM-DD|DD.MM.YYYY|DD-MM-YYYY; null removes a key; on a table cell it applies to the cell's whole column/row; a comb group: cell_type char|integer|date, or date_format with one D/M/Y letter per cell, e.g. DDMMYYYY, which makes it a date comb; diff_summary.ops shows the comb's cell_type, date_format and max_length); set_required {id, required}; set_description {id, description}; set_placeholder {id, placeholder} (null clears); set_autofill {id, autofill: a browser token (name, given-name, family-name, email, tel, street-address, postal-code, bday, \u2026) or null}. Groups: group {ids, kind: "choice"|"comb", label, multiple?} (standalone fields on one page; choice turns them into checkbox options; the members keep their ids, and diff_summary.ops lists them in reading order with the group's section; the group stands where its earliest member stood); ungroup {id}; set_options {id, options: [{id, label}] (recommended) or ["label", \u2026]: plain labels go to the options in the order of the ids of a group op earlier in the same call, else in reading order (as get_template lists them); diff_summary.ops shows each option's label}; add_option {id: group, label, box, index?} and remove_option {id: group, option} keep the group's id. Combs in one op: add {type: "comb", page, label, cells: N (box cut into N equal cells) | [{x, y, w, h}, \u2026] (each printed cell's box, for cells split by separators), box?, cell_type?, date_format?, section_id?} (its cells have no label); retype {id, type: "comb", cells, cell_type?, date_format?} turns a text/date field into a comb over its box, keeping label, section, order and required; comb_add_cell {id: comb, box, date_format?} and comb_remove_cell {id: cell, date_format?} (a date comb needs its new date_format, one letter per cell); group {kind: "comb"} takes cell_type and date_format too, and set_format on a comb's cell applies to its comb. Refs: any op that adds something takes ref: "name", and later ops of the same call write "$name" for its id (set_format {id: "$dob", \u2026}). Tables: group {kind: "table", label, cells: [[id|null, \u2026], \u2026] (rows \xD7 columns) or ids (laid out from their boxes), header_cols?, header_rows?, orientation?: "col"|"row" (the axis whose lines carry the types; default col), format?: classic|expandable|checkbox_matrix}; table_insert {id, axis: "row"|"col", index, box?: {y, h} for a row / {x, w} for a column (default: one pitch past the edge, or centred in the gap), header?, type?}; table_delete {id, axis, index, keep_cells?}; table_add_cell {id, row, col, box?} (fills an empty slot); table_adopt {id, field, row, col} (moves a loose field into an empty slot); set_column_type {id, index, type: text|number|currency|date|checkbox, date_format?} (index along the typed axis); set_orientation {id, orientation} (resets every cell to text); set_header {id, axis, index, text}; set_headers {id, axis, texts: [...], start?} (several at once). Order: reorder {page, ids} moves those top-level entries together, in that order, to where whichever of them is listed first now stands (not ids[0]'s place); every other entry keeps its relative order (stamps order; geometry no longer decides). A partial list moves only what it names: to put B right after A, list both; chained partial reorders are simplest replaced by one with the page's whole list. diff_summary.ops shows the order now listed. A section is listed as one run where its first entry stands, so entries of different sections never stand together: set_section {ids, section_id | null} moves fields or groups of one page to another of its sections (get_template shows each section's section_id; null = no section), and set_section_title {page, section_id, title} renames one. A reorder whose ids cannot come out as asked and that would change nothing in the listing is rejected. Every cell of one column (or row, when orientation is row) has one type.`
         ),
         discard: external_exports.boolean().optional().describe(
           "Drop the local working copy first (any ops then apply to fenfill's version). ops may be left out with it."