parseman 0.48.0 → 0.49.0

package/dist/plugin/index.js

@@ -3422,6 +3422,7 @@ function choice(...args) {
     },
     parse(input, pos, ctx) {
       const expected = [];
+      let expectedAt = pos;
       if (disjoint) {
         const code = pos < input.length ? input.codePointAt(pos) : -1;
         let idx = code >= 0 && code < 128 ? asciiDispatch[code] : -1;
@@ -3479,7 +3480,12 @@ function choice(...args) {
         const result = parsers[i].parse(input, pos, ctx);
         if (!result.ok) {
           rollbackTrivia(ctx, mark);
-          expected.push(...result.expected);
+          const at = result.span.start;
+          if (at > expectedAt) {
+            expectedAt = at;
+            expected.length = 0;
+          }
+          if (at === expectedAt) expected.push(...result.expected);
           if (result.committed) return { ok: false, expected, span: result.span, committed: true };
           continue;
         }
@@ -3490,6 +3496,9 @@ function choice(...args) {
         }
         return result;
       }
+      if (expected.length === 0) {
+        for (const parser2 of parsers) expected.push(...deriveExpected(parser2));
+      }
       return { ok: false, expected, span: { start: pos, end: pos } };
     }
   };
@@ -5181,24 +5190,43 @@ function choiceNode(arms, classes, armExpected, choiceExpected) {
   };
   for (let i = arms.length - 1; i >= 0; i--) {
     const arm = arms[i], cls = classes[i], staticExpected = armExpected[i], next = tail;
-    tail = (input, pos, ctx, lead2, acc) => {
+    tail = (input, pos, ctx, lead2, acc, best) => {
       if (cls !== void 0 && !classHas(cls, lead2)) {
-        return next(input, pos, ctx, lead2, appendExpected(acc, staticExpected));
+        return next(
+          input,
+          pos,
+          ctx,
+          lead2,
+          best === pos ? appendExpected(acc, staticExpected) : acc,
+          best
+        );
       }
       ctx._fc = false;
       const end = arm.run(input, pos, ctx);
       if (end >= 0) return end;
-      const nextAcc = appendExpected(acc, ctx._fx);
+      const at = ctx._fe ?? pos;
+      if (at > best) {
+        best = at;
+        acc = void 0;
+      }
+      const nextAcc = at === best ? appendExpected(acc, ctx._fx) : acc;
       if (committed(ctx)) {
         if (nextAcc !== void 0) ctx._fx = nextAcc;
         return -1;
       }
-      return next(input, pos, ctx, lead2, nextAcc);
+      return next(input, pos, ctx, lead2, nextAcc, best);
     };
   }
   return {
     match: matchTail,
-    run: (input, pos, ctx) => tail(input, pos, ctx, pos < input.length ? input.codePointAt(pos) : -1, void 0)
+    run: (input, pos, ctx) => tail(
+      input,
+      pos,
+      ctx,
+      pos < input.length ? input.codePointAt(pos) : -1,
+      void 0,
+      pos
+    )
   };
 }
 function notNode(body, failure) {
@@ -9289,9 +9317,11 @@ ${catchCases}
 ctx._fc=false
 {const v=${arm}(input,pos,ctx)
 if(v!==FAIL)return v}
-acc=${catchName}(${i},prev,acc)
+if(best===pos)acc=${catchName}(${i},prev,acc)
 prev=${i + 1}
-acc=_accSet(ctx._fx,acc)
+{const at=ctx._fe??pos
+if(at>best){best=at;acc=undefined}
+if(at===best)acc=_accSet(ctx._fx,acc)}
 if(ctx._fc===true){if(acc!==undefined)ctx._fx=acc;return FAIL}
 ${emitRollback(p, L.buf, sinks)}
 }`;
@@ -9300,19 +9330,22 @@ ${emitRollback(p, L.buf, sinks)}
 ctx._fc=false
 {const v=${arm}(input,pos,ctx)
 if(v!==FAIL)return v}
-acc=_accSet(ctx._fx,acc)
+{const at=ctx._fe??pos
+if(at>best){best=at;acc=undefined}
+if(at===best)acc=_accSet(ctx._fx,acc)}
 if(ctx._fc===true){if(acc!==undefined)ctx._fx=acc;return FAIL}
 ${emitRollback(p, L.buf, sinks)}
-}else acc=_accSet(${expected[i]},acc)`).join("\n");
+}else if(best===pos)acc=_accSet(${expected[i]},acc)`).join("\n");
           return `${head}
 const c=lead(input,pos)
 ${emitMark(p, L.buf, sinks)}
 let acc
+let best=pos
 ${maskable ? `if(c<128){
 const bits=${maskName}[c<0?128:c]
 let prev=0
 ${maskArms}
-acc=${catchName}(${n},prev,acc)
+if(best===pos)acc=${catchName}(${n},prev,acc)
 ctx._fe=pos;ctx._fx=acc??${choiceFx}
 return FAIL
 }
@@ -10431,14 +10464,19 @@ function assemble(t, prog, cfg) {
     };
   }
   function maskedChoiceBlock(start, a0, a1, a2, a3, through, next, total, choiceFx) {
-    return (input, pos, ctx, bits, need, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot, acc, prev) => {
+    return (input, pos, ctx, bits, need, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot, acc, prev, best) => {
       if ((bits & 1 << start) !== 0) {
         ctx._fc = false;
         const v = a0(input, pos, ctx);
         if (v !== FAIL) return v;
-        acc = through(start, prev, acc);
+        if (best === pos) acc = through(start, prev, acc);
         prev = start + 1;
-        acc = accSet(ctx._fx, acc);
+        const at = ctx._fe ?? pos;
+        if (at > best) {
+          best = at;
+          acc = void 0;
+        }
+        if (at === best) acc = accSet(ctx._fx, acc);
         if (committed3(ctx)) {
           if (acc !== void 0) ctx._fx = acc;
           return FAIL;
@@ -10449,9 +10487,14 @@ function assemble(t, prog, cfg) {
         ctx._fc = false;
         const v = a1(input, pos, ctx);
         if (v !== FAIL) return v;
-        acc = through(start + 1, prev, acc);
+        if (best === pos) acc = through(start + 1, prev, acc);
         prev = start + 2;
-        acc = accSet(ctx._fx, acc);
+        const at = ctx._fe ?? pos;
+        if (at > best) {
+          best = at;
+          acc = void 0;
+        }
+        if (at === best) acc = accSet(ctx._fx, acc);
         if (committed3(ctx)) {
           if (acc !== void 0) ctx._fx = acc;
           return FAIL;
@@ -10462,9 +10505,14 @@ function assemble(t, prog, cfg) {
         ctx._fc = false;
         const v = a2(input, pos, ctx);
         if (v !== FAIL) return v;
-        acc = through(start + 2, prev, acc);
+        if (best === pos) acc = through(start + 2, prev, acc);
         prev = start + 3;
-        acc = accSet(ctx._fx, acc);
+        const at = ctx._fe ?? pos;
+        if (at > best) {
+          best = at;
+          acc = void 0;
+        }
+        if (at === best) acc = accSet(ctx._fx, acc);
         if (committed3(ctx)) {
           if (acc !== void 0) ctx._fx = acc;
           return FAIL;
@@ -10475,9 +10523,14 @@ function assemble(t, prog, cfg) {
         ctx._fc = false;
         const v = a3(input, pos, ctx);
         if (v !== FAIL) return v;
-        acc = through(start + 3, prev, acc);
+        if (best === pos) acc = through(start + 3, prev, acc);
         prev = start + 4;
-        acc = accSet(ctx._fx, acc);
+        const at = ctx._fe ?? pos;
+        if (at > best) {
+          best = at;
+          acc = void 0;
+        }
+        if (at === best) acc = accSet(ctx._fx, acc);
         if (committed3(ctx)) {
           if (acc !== void 0) ctx._fx = acc;
           return FAIL;
@@ -10485,23 +10538,28 @@ function assemble(t, prog, cfg) {
         if (need) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
       }
       if (next !== void 0) {
-        return next(input, pos, ctx, bits, need, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot, acc, prev);
+        return next(input, pos, ctx, bits, need, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot, acc, prev, best);
       }
-      acc = through(total, prev, acc);
+      if (best === pos) acc = through(total, prev, acc);
       ctx._fe = pos;
       ctx._fx = acc ?? choiceFx;
       return FAIL;
     };
   }
   function generalChoiceBlock(start, a0, a1, a2, a3, g0, g1, g2, g3, through, next, total, choiceFx) {
-    return (input, pos, ctx, c, need, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot, acc, prev) => {
+    return (input, pos, ctx, c, need, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot, acc, prev, best) => {
       if (g0 === null || classHas2(g0, c)) {
         ctx._fc = false;
         const v = a0(input, pos, ctx);
         if (v !== FAIL) return v;
-        acc = through(start, prev, acc);
+        if (best === pos) acc = through(start, prev, acc);
         prev = start + 1;
-        acc = accSet(ctx._fx, acc);
+        const at = ctx._fe ?? pos;
+        if (at > best) {
+          best = at;
+          acc = void 0;
+        }
+        if (at === best) acc = accSet(ctx._fx, acc);
         if (committed3(ctx)) {
           if (acc !== void 0) ctx._fx = acc;
           return FAIL;
@@ -10512,9 +10570,14 @@ function assemble(t, prog, cfg) {
         ctx._fc = false;
         const v = a1(input, pos, ctx);
         if (v !== FAIL) return v;
-        acc = through(start + 1, prev, acc);
+        if (best === pos) acc = through(start + 1, prev, acc);
         prev = start + 2;
-        acc = accSet(ctx._fx, acc);
+        const at = ctx._fe ?? pos;
+        if (at > best) {
+          best = at;
+          acc = void 0;
+        }
+        if (at === best) acc = accSet(ctx._fx, acc);
         if (committed3(ctx)) {
           if (acc !== void 0) ctx._fx = acc;
           return FAIL;
@@ -10525,9 +10588,14 @@ function assemble(t, prog, cfg) {
         ctx._fc = false;
         const v = a2(input, pos, ctx);
         if (v !== FAIL) return v;
-        acc = through(start + 2, prev, acc);
+        if (best === pos) acc = through(start + 2, prev, acc);
         prev = start + 3;
-        acc = accSet(ctx._fx, acc);
+        const at = ctx._fe ?? pos;
+        if (at > best) {
+          best = at;
+          acc = void 0;
+        }
+        if (at === best) acc = accSet(ctx._fx, acc);
         if (committed3(ctx)) {
           if (acc !== void 0) ctx._fx = acc;
           return FAIL;
@@ -10538,9 +10606,14 @@ function assemble(t, prog, cfg) {
         ctx._fc = false;
         const v = a3(input, pos, ctx);
         if (v !== FAIL) return v;
-        acc = through(start + 3, prev, acc);
+        if (best === pos) acc = through(start + 3, prev, acc);
         prev = start + 4;
-        acc = accSet(ctx._fx, acc);
+        const at = ctx._fe ?? pos;
+        if (at > best) {
+          best = at;
+          acc = void 0;
+        }
+        if (at === best) acc = accSet(ctx._fx, acc);
         if (committed3(ctx)) {
           if (acc !== void 0) ctx._fx = acc;
           return FAIL;
@@ -10548,9 +10621,9 @@ function assemble(t, prog, cfg) {
         if (need) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
       }
       if (next !== void 0) {
-        return next(input, pos, ctx, c, need, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot, acc, prev);
+        return next(input, pos, ctx, c, need, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot, acc, prev, best);
       }
-      acc = through(total, prev, acc);
+      if (best === pos) acc = through(total, prev, acc);
       ctx._fe = pos;
       ctx._fx = acc ?? choiceFx;
       return FAIL;
@@ -11906,6 +11979,7 @@ function assemble(t, prog, cfg) {
             const mLog = need ? ctx._triviaLog?.length ?? 0 : 0;
             const mRoot = need ? ctx._rootTriviaLog?.length ?? 0 : 0;
             let acc;
+            let best = pos;
             if (c < 128) {
               const bits = mask[c < 0 ? 128 : c];
               let prev = 0;
@@ -11914,7 +11988,12 @@ function assemble(t, prog, cfg) {
                 const v = a0(input, pos, ctx);
                 if (v !== FAIL) return v;
                 prev = 1;
-                acc = accSet(ctx._fx, acc);
+                const at = ctx._fe ?? pos;
+                if (at > best) {
+                  best = at;
+                  acc = void 0;
+                }
+                if (at === best) acc = accSet(ctx._fx, acc);
                 if (committed3(ctx)) {
                   if (acc !== void 0) ctx._fx = acc;
                   return FAIL;
@@ -11925,9 +12004,14 @@ function assemble(t, prog, cfg) {
                 ctx._fc = false;
                 const v = a1(input, pos, ctx);
                 if (v !== FAIL) return v;
-                if (prev < 1) acc = accSet(e0, acc);
+                if (best === pos && prev < 1) acc = accSet(e0, acc);
                 prev = 2;
-                acc = accSet(ctx._fx, acc);
+                const at = ctx._fe ?? pos;
+                if (at > best) {
+                  best = at;
+                  acc = void 0;
+                }
+                if (at === best) acc = accSet(ctx._fx, acc);
                 if (committed3(ctx)) {
                   if (acc !== void 0) ctx._fx = acc;
                   return FAIL;
@@ -11938,19 +12022,24 @@ function assemble(t, prog, cfg) {
                 ctx._fc = false;
                 const v = a2(input, pos, ctx);
                 if (v !== FAIL) return v;
-                if (prev < 1) acc = accSet(e0, acc);
-                if (prev < 2) acc = accSet(e1, acc);
+                if (best === pos && prev < 1) acc = accSet(e0, acc);
+                if (best === pos && prev < 2) acc = accSet(e1, acc);
                 prev = 3;
-                acc = accSet(ctx._fx, acc);
+                const at = ctx._fe ?? pos;
+                if (at > best) {
+                  best = at;
+                  acc = void 0;
+                }
+                if (at === best) acc = accSet(ctx._fx, acc);
                 if (committed3(ctx)) {
                   if (acc !== void 0) ctx._fx = acc;
                   return FAIL;
                 }
                 if (need) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
               }
-              if (prev < 1) acc = accSet(e0, acc);
-              if (prev < 2) acc = accSet(e1, acc);
-              if (n === 3 && prev < 3) acc = accSet(e2, acc);
+              if (best === pos && prev < 1) acc = accSet(e0, acc);
+              if (best === pos && prev < 2) acc = accSet(e1, acc);
+              if (best === pos && n === 3 && prev < 3) acc = accSet(e2, acc);
               ctx._fe = pos;
               ctx._fx = acc ?? choiceFx;
               return FAIL;
@@ -11959,36 +12048,51 @@ function assemble(t, prog, cfg) {
               ctx._fc = false;
               const v = a0(input, pos, ctx);
               if (v !== FAIL) return v;
-              acc = accSet(ctx._fx, acc);
+              const at = ctx._fe ?? pos;
+              if (at > best) {
+                best = at;
+                acc = void 0;
+              }
+              if (at === best) acc = accSet(ctx._fx, acc);
               if (committed3(ctx)) {
                 if (acc !== void 0) ctx._fx = acc;
                 return FAIL;
               }
               if (need) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
-            } else acc = accSet(e0, acc);
+            } else if (best === pos) acc = accSet(e0, acc);
             if (g1 === null || classHas2(g1, c)) {
               ctx._fc = false;
               const v = a1(input, pos, ctx);
               if (v !== FAIL) return v;
-              acc = accSet(ctx._fx, acc);
+              const at = ctx._fe ?? pos;
+              if (at > best) {
+                best = at;
+                acc = void 0;
+              }
+              if (at === best) acc = accSet(ctx._fx, acc);
               if (committed3(ctx)) {
                 if (acc !== void 0) ctx._fx = acc;
                 return FAIL;
               }
               if (need) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
-            } else acc = accSet(e1, acc);
+            } else if (best === pos) acc = accSet(e1, acc);
             if (n === 3) {
               if (g2 === null || classHas2(g2, c)) {
                 ctx._fc = false;
                 const v = a2(input, pos, ctx);
                 if (v !== FAIL) return v;
-                acc = accSet(ctx._fx, acc);
+                const at = ctx._fe ?? pos;
+                if (at > best) {
+                  best = at;
+                  acc = void 0;
+                }
+                if (at === best) acc = accSet(ctx._fx, acc);
                 if (committed3(ctx)) {
                   if (acc !== void 0) ctx._fx = acc;
                   return FAIL;
                 }
                 if (need) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
-              } else acc = accSet(e2, acc);
+              } else if (best === pos) acc = accSet(e2, acc);
             }
             ctx._fe = pos;
             ctx._fx = acc ?? choiceFx;
@@ -12086,7 +12190,8 @@ function assemble(t, prog, cfg) {
                 mLog,
                 mRoot,
                 void 0,
-                0
+                0,
+                pos
               );
             }
             return general(
@@ -12103,7 +12208,8 @@ function assemble(t, prog, cfg) {
               mLog,
               mRoot,
               void 0,
-              0
+              0,
+              pos
             );
           };
         }
@@ -12131,7 +12237,8 @@ function assemble(t, prog, cfg) {
             mLog,
             mRoot,
             void 0,
-            0
+            0,
+            pos
           );
         };
       }
@@ -14916,7 +15023,7 @@ function evalRuleMapIR(ir) {
     l._def.fnSrc = src;
     return l;
   };
-  const _nd = (type, child, src, opts, staticError, sigSrc) => {
+  const _nd = (type, child, src, opts, staticError, sigSrc, buildImports) => {
     if (staticError !== void 0 && staticError.length > 0) {
       throw new Error(`IR direct node builder for ${type} must be macro-static and self-contained; unsupported binding(s): ${staticError.join(", ")}`);
     }
@@ -14926,6 +15033,7 @@ function evalRuleMapIR(ir) {
     n._def.buildSrc = src;
     if (staticError !== void 0) n._def.buildStaticError = staticError;
     if (sigSrc !== void 0) n._def.buildSigSrc = sigSrc;
+    if (buildImports !== void 0) n._def.buildImports = buildImports;
     return n;
   };
   const _gch = (items) => {
@@ -15317,11 +15425,12 @@ ${outerDecls.map((d) => "  " + d).join("\n")}
         }
         if (def.buildSrc !== void 0) {
           const tail = [];
-          if (def.buildStaticError !== void 0 || def.buildSigSrc !== void 0) {
+          if (def.buildStaticError !== void 0 || def.buildSigSrc !== void 0 || def.buildImports !== void 0) {
             if (!opts) tail.push("undefined");
             tail.push(def.buildStaticError === void 0 ? "undefined" : JSON.stringify(def.buildStaticError));
           }
-          if (def.buildSigSrc !== void 0) tail.push(JSON.stringify(def.buildSigSrc));
+          if (def.buildSigSrc !== void 0 || def.buildImports !== void 0) tail.push(def.buildSigSrc === void 0 ? "undefined" : JSON.stringify(def.buildSigSrc));
+          if (def.buildImports !== void 0) tail.push(JSON.stringify(def.buildImports));
           const trailing = tail.length > 0 ? `, ${tail.join(", ")}` : "";
           return `_nd(${JSON.stringify(def.type)}, ${kid(def.parser)}, ${JSON.stringify(def.buildSrc)}${opts}${trailing})`;
         }
@@ -15468,7 +15577,7 @@ function compileRuleMap(ruleMap, opts = {}) {
 }
 
 // src/version.ts
-var PARSEMAN_VERSION = "0.48.0";
+var PARSEMAN_VERSION = "0.49.0";
 
 // src/compiler/compile-linkable-table.ts
 function isLocal(rule) {
@@ -15661,7 +15770,17 @@ var STATIC_BUILDER_GLOBALS = /* @__PURE__ */ new Set([
   "Infinity",
   "parseFloat",
   "parseInt",
-  "undefined"
+  "undefined",
+  // Frozen intrinsic error constructors. Reducers pervasively `throw new TypeError(…)`;
+  // once the statement walker walks a `throw` argument these surface as free names, and
+  // refusing them would re-refuse the very productions the block-body lift clears. They
+  // carry no closure state, so admitting them cannot make an unanalyzable builder
+  // analyzable by accident. A MODULE-SCOPE custom error stays a free name (rescued by
+  // provenance or refused) — unchanged.
+  "Error",
+  "TypeError",
+  "RangeError",
+  "SyntaxError"
 ]);
 function astArray(value) {
   return Array.isArray(value) ? value : [];
@@ -15674,31 +15793,42 @@ function unwrapCallbackExpression(node2) {
   while (current?.type === "ParenthesizedExpression") current = astChild(current.expression) ?? void 0;
   return current;
 }
-function directBuilderUnsupportedBindings(src) {
+function directBuilderBindings(src) {
   let init;
   try {
     const parsed = parseSync("parseman-direct-builder.ts", `const _direct = (${src})`);
-    if (parsed.errors.length > 0) return ["invalid callback source"];
+    if (parsed.errors.length > 0) return { structural: ["invalid callback source"], free: [] };
     const program = parsed.program;
-    const statement = program.body?.[0];
-    const declaration = statement?.declarations?.[0];
+    const statementNode = program.body?.[0];
+    const declaration = statementNode?.declarations?.[0];
     init = unwrapCallbackExpression(declaration?.init);
   } catch {
-    return ["invalid callback source"];
+    return { structural: ["invalid callback source"], free: [] };
   }
-  if (init?.type !== "ArrowFunctionExpression" || !Array.isArray(init.params)) return ["unsupported callback shape"];
+  if (init === void 0) return { structural: ["unsupported callback shape"], free: [] };
+  const isCallable = init.type === "ArrowFunctionExpression" || init.type === "FunctionExpression" || init.type === "FunctionDeclaration";
+  if (!isCallable || !Array.isArray(init.params)) return { structural: ["unsupported callback shape"], free: [] };
+  if (init.async === true || init.generator === true) return { structural: ["unsupported callback shape"], free: [] };
   const allowed = new Set(STATIC_BUILDER_GLOBALS);
   for (const param of init.params) {
-    if (param.type !== "Identifier" || typeof param.name !== "string") return ["unsupported parameter pattern"];
+    if (param.type !== "Identifier" || typeof param.name !== "string") return { structural: ["unsupported parameter pattern"], free: [] };
     allowed.add(param.name);
   }
-  const unsupported = /* @__PURE__ */ new Set();
+  const selfName = astChild(init.id);
+  if (selfName?.type === "Identifier" && typeof selfName.name === "string") allowed.add(selfName.name);
+  const structural = /* @__PURE__ */ new Set();
+  const free = /* @__PURE__ */ new Set();
   const reportUnsupportedNode = (ast) => {
-    unsupported.add(`unsupported ${ast.type}`);
+    structural.add(`unsupported ${ast.type}`);
   };
   const read = (ast, allowedNames) => {
     if (typeof ast.name === "string" && allowedNames.has(ast.name)) return;
-    unsupported.add(typeof ast.name === "string" ? ast.name : "identifier");
+    if (ast.name === "arguments") {
+      structural.add("unsupported arguments");
+      return;
+    }
+    if (typeof ast.name === "string") free.add(ast.name);
+    else structural.add("unsupported identifier");
   };
   const expression = (node2, allowedNames) => {
     const ast = astChild(node2);
@@ -15775,8 +15905,9 @@ function directBuilderUnsupportedBindings(src) {
           }
           nested.add(param.name);
         }
-        if (astChild(ast.body)?.type === "BlockStatement") {
-          reportUnsupportedNode(astChild(ast.body));
+        const nestedBody = astChild(ast.body);
+        if (nestedBody?.type === "BlockStatement") {
+          statement(nestedBody, nested);
           return;
         }
         expression(ast.body, nested);
@@ -15787,9 +15918,70 @@ function directBuilderUnsupportedBindings(src) {
         return;
     }
   };
-  if (astChild(init.body)?.type === "BlockStatement") unsupported.add("unsupported BlockStatement");
+  const statement = (node2, names) => {
+    const ast = astChild(node2);
+    if (!ast) return;
+    switch (ast.type) {
+      case "VariableDeclaration":
+        for (const d of astArray(ast.declarations)) {
+          expression(d.init, names);
+          const idAst = astChild(d.id);
+          if (idAst?.type === "Identifier" && typeof idAst.name === "string") names.add(idAst.name);
+          else reportUnsupportedNode(idAst ?? ast);
+        }
+        return;
+      case "ReturnStatement":
+        expression(ast.argument, names);
+        return;
+      case "ExpressionStatement":
+        expression(ast.expression, names);
+        return;
+      case "ThrowStatement":
+        expression(ast.argument, names);
+        return;
+      case "IfStatement":
+        expression(ast.test, names);
+        statement(ast.consequent, new Set(names));
+        if (ast.alternate) statement(ast.alternate, new Set(names));
+        return;
+      case "ForStatement": {
+        const inner = new Set(names);
+        if (ast.init) {
+          const initAst = astChild(ast.init);
+          if (initAst?.type === "VariableDeclaration") statement(initAst, inner);
+          else expression(initAst, inner);
+        }
+        if (ast.test) expression(ast.test, inner);
+        if (ast.update) expression(ast.update, inner);
+        statement(ast.body, inner);
+        return;
+      }
+      case "ForOfStatement":
+      case "ForInStatement": {
+        const inner = new Set(names);
+        statement(ast.left, inner);
+        expression(ast.right, names);
+        statement(ast.body, inner);
+        return;
+      }
+      case "BlockStatement": {
+        const inner = new Set(names);
+        for (const s of astArray(ast.body)) statement(s, inner);
+        return;
+      }
+      case "BreakStatement":
+      case "ContinueStatement":
+      case "EmptyStatement":
+        return;
+      default:
+        reportUnsupportedNode(ast);
+        return;
+    }
+  };
+  const bodyAst = astChild(init.body);
+  if (bodyAst?.type === "BlockStatement") statement(bodyAst, allowed);
   else expression(init.body, allowed);
-  return [...unsupported];
+  return { structural: [...structural], free: [...free] };
 }
 
 // src/plugin/evaluator.ts
@@ -15844,6 +16036,10 @@ function setReducerResolver(r, entrySource = null) {
   _reducers = r;
   _entrySource = entrySource;
 }
+var _builderImports = null;
+function setBuilderImportResolver(r) {
+  _builderImports = r;
+}
 function isWordFactory(v) {
   return !!v && typeof v === "object" && v.tag === "wordFactory";
 }
@@ -16230,8 +16426,21 @@ function exprToCombi(node2, scope, code, mfs) {
           if (combi._def.buildArity === void 0 && resolved.arity !== null) combi._def.buildArity = resolved.arity;
           if (resolved.reason !== void 0) combi._def.buildArityUnresolved = resolved.reason;
         }
-        const staticError = directBuilderUnsupportedBindings(buildSrc);
+        const analysisSrc = combi._def.buildSigSrc ?? buildSrc;
+        const report = directBuilderBindings(analysisSrc);
+        const isInlineBuilder = combi._def.buildSigSrc === void 0;
+        const carriedImports = [];
+        const unresolved = [];
+        if (isInlineBuilder) {
+          for (const name of report.free) {
+            const prov = _builderImports?.(name) ?? null;
+            if (prov) carriedImports.push({ local: name, source: prov.source, imported: prov.imported });
+            else unresolved.push(name);
+          }
+        }
+        const staticError = [...report.structural, ...unresolved];
         if (staticError.length > 0) combi._def.buildStaticError = staticError;
+        if (carriedImports.length > 0) combi._def.buildImports = carriedImports;
       }
       return combi;
     } catch {
@@ -17625,6 +17834,7 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
     return transformMacroImpl(code, id, moduleAliases, warnUnloweredRegex, recovery, grammarCoverage);
   } finally {
     setReducerResolver(null);
+    setBuilderImportResolver(null);
     for (const d of unwindDegradationCapture(depth)) console.warn(formatDegradation(d));
   }
 }
@@ -17690,6 +17900,7 @@ function transformMacroImpl(code, id, moduleAliases, warnUnloweredRegex, recover
   }
   const reducerResolver = createReducerResolver(id, body, code);
   setReducerResolver(reducerResolver, code);
+  setBuilderImportResolver((name) => importBindings.get(name) ?? null);
   const topLevelFunction = (moduleBody, name) => {
     for (const st of moduleBody) {
       const decl = st.type === "ExportNamedDeclaration" ? st.declaration : st;
@@ -17793,6 +18004,48 @@ function transformMacroImpl(code, id, moduleAliases, warnUnloweredRegex, recover
   let anyUnresolved = false;
   let keepMacroImport = false;
   let usedTableRuntime = false;
+  const pendingBuilderImports = /* @__PURE__ */ new Map();
+  const collectBuilderImports = (ruleMap) => {
+    const seen = /* @__PURE__ */ new Set();
+    const walk = (v) => {
+      if (v === null || typeof v !== "object" || seen.has(v)) return;
+      seen.add(v);
+      const def = v._def;
+      for (const bi of def?.buildImports ?? []) {
+        let m = pendingBuilderImports.get(bi.source);
+        if (!m) {
+          m = /* @__PURE__ */ new Map();
+          pendingBuilderImports.set(bi.source, m);
+        }
+        m.set(bi.local, bi.imported);
+      }
+      if (def?.tag === "lazy" && v._ruleName === void 0 && typeof def.thunk === "function") {
+        let target = null;
+        try {
+          target = def.thunk();
+        } catch {
+        }
+        walk(target);
+      }
+      for (const child of Object.values(v)) {
+        if (Array.isArray(child)) {
+          for (const c of child) walk(c);
+        } else walk(child);
+      }
+    };
+    for (const [, rule] of ruleMap) {
+      walk(rule);
+      const def = rule._def;
+      if (def?.tag === "lazy" && typeof def.thunk === "function") {
+        let body2 = null;
+        try {
+          body2 = def.thunk();
+        } catch {
+        }
+        walk(body2);
+      }
+    }
+  };
   const exportedFactories = [];
   let runtimeComposeFallback = false;
   let ruleMapHolderCounter = 0;
@@ -18096,6 +18349,7 @@ function transformMacroImpl(code, id, moduleAliases, warnUnloweredRegex, recover
     const merged = mergedCarriedRules(carried);
     if (merged !== null) {
       if (composing) applyComposingTrivia(merged.rules, composing);
+      collectBuilderImports(merged.rules);
       const refusals = [];
       const compiled = compileRuleMap(merged.rules, {
         ...composing ? { trivia: composing } : {},
@@ -18543,6 +18797,45 @@ ${which}
     ms.prepend(`import { tableRules } from ${JSON.stringify(TABLE_RUNTIME_SPECIFIER)}
 `);
   }
+  if (applied.length > 0 && pendingBuilderImports.size > 0) {
+    const boundLocally = /* @__PURE__ */ new Set();
+    for (const stmt of body) {
+      if (stmt.type === "ImportDeclaration") {
+        for (const sp of stmt.specifiers) boundLocally.add(sp.local.name);
+        continue;
+      }
+      const decl = stmt.type === "ExportNamedDeclaration" ? stmt.declaration : stmt;
+      if (decl?.type === "FunctionDeclaration" || decl?.type === "ClassDeclaration") {
+        const n = decl.id?.name;
+        if (n) boundLocally.add(n);
+        continue;
+      }
+      const vd = unwrapVd(stmt);
+      for (const d of vd?.declarations ?? []) {
+        const n = d.id.name;
+        if (n) boundLocally.add(n);
+      }
+    }
+    const emitted = /* @__PURE__ */ new Set();
+    for (const [source, locals] of pendingBuilderImports) {
+      const needed = [];
+      for (const [local, imported] of locals) {
+        const own = importBindings.get(local);
+        if (own && own.source === source && own.imported === imported) continue;
+        if (boundLocally.has(local) || emitted.has(local)) {
+          throw new Error(
+            `${id} \u2014 parseman will not emit this module: a fused builder needs \`${imported}\` from ${JSON.stringify(source)} bound as \`${local}\`, but this module already binds \`${local}\` to something else. The inlined builder source names \`${local}\` verbatim, so the import cannot be aliased; rename the conflicting local binding so the builder's import can be re-emitted.`
+          );
+        }
+        emitted.add(local);
+        needed.push([local, imported]);
+      }
+      if (needed.length === 0) continue;
+      const specs = needed.map(([local, imported]) => imported === local ? local : `${imported} as ${local}`);
+      ms.prepend(`import { ${specs.join(", ")} } from ${JSON.stringify(source)}
+`);
+    }
+  }
   if (applied.length > 0) {
     ms.prepend(
       `// Generated by parseman v${PARSEMAN_VERSION} \u2014 DO NOT EDIT.
@@ -18567,6 +18860,7 @@ ${free.map(where).join("\n")}${cause}`
     }
   }
   setReducerResolver(null);
+  setBuilderImportResolver(null);
   const degradations = endDegradationCapture();
   if (degradations.length > 0) {
     const lines = formatDegradations(degradations);