parseman 0.12.0 → 0.14.0

package/dist/combinators/expect.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"expect.d.ts","sourceRoot":"","sources":["../../src/combinators/expect.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAyC,UAAU,EAAE,MAAM,aAAa,CAAA;AAEhG,YAAY,EAAE,UAAU,EAAE,CAAA;AAE1B;;;;;;;;;;;;;GAaG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,GAAG,MAAM,EAAE,CAoB/D;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,UAAU,CAAC,CAAC,GAAG,UAAU,CAAC,CAmB/F"}
+{"version":3,"file":"expect.d.ts","sourceRoot":"","sources":["../../src/combinators/expect.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAyC,UAAU,EAAE,MAAM,aAAa,CAAA;AAEhG,YAAY,EAAE,UAAU,EAAE,CAAA;AAE1B;;;;;;;;;;;;;GAaG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,GAAG,MAAM,EAAE,CA2B/D;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,UAAU,CAAC,CAAC,GAAG,UAAU,CAAC,CAmB/F"}

package/dist/combinators/node.d.ts

@@ -33,5 +33,5 @@ export type BuildNode<N> = (children: ReadonlyArray<unknown>, rawChildren: Reado
 export type NodeOptions = {
     collapse?: boolean;
 };
-export declare function node<N>(type: string, combinator: Combinator<unknown>, build: BuildNode<N>, opts?: NodeOptions): Combinator<N>;
+export declare function node<N>(type: string, combinator: Combinator<unknown>, build?: BuildNode<N>, opts?: NodeOptions): Combinator<N>;
 //# sourceMappingURL=node.d.ts.map

package/dist/combinators/node.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../../src/combinators/node.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAoD,MAAM,aAAa,CAAA;AAI/F;;;;;;;;;;;;;;;GAeG;AACH,MAAM,MAAM,SAAS,CAAC,CAAC,IAAI,CACzB,QAAQ,EAAE,aAAa,CAAC,OAAO,CAAC,EAChC,WAAW,EAAE,aAAa,CAAC,OAAO,CAAC,EACnC,IAAI,EAAE;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,EACpC,SAAS,EAAE,SAAS,MAAM,EAAE,EAC5B,KAAK,EAAE,OAAO,KACX,CAAC,CAAA;AAEN;;;;;;;;;;GAUG;AACH,MAAM,MAAM,WAAW,GAAG;IAAE,QAAQ,CAAC,EAAE,OAAO,CAAA;CAAE,CAAA;AAShD,wBAAgB,IAAI,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,UAAU,CAAC,OAAO,CAAC,EAAE,KAAK,EAAE,SAAS,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,EAAE,WAAW,GAAG,UAAU,CAAC,CAAC,CAAC,CA8C7H"}
+{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../../src/combinators/node.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAoD,MAAM,aAAa,CAAA;AAI/F;;;;;;;;;;;;;;;GAeG;AACH,MAAM,MAAM,SAAS,CAAC,CAAC,IAAI,CACzB,QAAQ,EAAE,aAAa,CAAC,OAAO,CAAC,EAChC,WAAW,EAAE,aAAa,CAAC,OAAO,CAAC,EACnC,IAAI,EAAE;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,EACpC,SAAS,EAAE,SAAS,MAAM,EAAE,EAC5B,KAAK,EAAE,OAAO,KACX,CAAC,CAAA;AAEN;;;;;;;;;;GAUG;AACH,MAAM,MAAM,WAAW,GAAG;IAAE,QAAQ,CAAC,EAAE,OAAO,CAAA;CAAE,CAAA;AAShD,wBAAgB,IAAI,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,UAAU,CAAC,OAAO,CAAC,EAAE,KAAK,CAAC,EAAE,SAAS,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,EAAE,WAAW,GAAG,UAAU,CAAC,CAAC,CAAC,CAmD9H"}

package/dist/combinators/parser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../../src/combinators/parser.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AAG7C;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,KAAK,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC,EACjE,OAAO,EAAE,CAAC,IAAI,EAAE,GAAG,KAAK,CAAC,GACxB,CAAC,CAmCH"}
+{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../../src/combinators/parser.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AAG7C;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,KAAK,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC,EACjE,OAAO,EAAE,CAAC,IAAI,EAAE,GAAG,KAAK,CAAC,GACxB,CAAC,CAwCH"}

package/dist/combinators/regex-analyze.d.ts

@@ -0,0 +1,6 @@
+import type { FirstSet } from '../types.ts';
+export declare function firstSetFromRegex(pattern: string): {
+    firstSet: FirstSet;
+    canMatchNewline: boolean;
+};
+//# sourceMappingURL=regex-analyze.d.ts.map

package/dist/combinators/regex-analyze.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"regex-analyze.d.ts","sourceRoot":"","sources":["../../src/combinators/regex-analyze.ts"],"names":[],"mappings":"AAmBA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAA;AAG3C,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG;IAAE,QAAQ,EAAE,QAAQ,CAAC;IAAC,eAAe,EAAE,OAAO,CAAA;CAAE,CAOnG"}

package/dist/combinators/regex.d.ts

@@ -1,3 +1,18 @@
-import type { Combinator } from '../types.ts';
+import type { Combinator, FirstSet } from '../types.ts';
+/**
+ * Computes a regex terminal's first-set (for choice-dispatch fast paths). The
+ * only implementation — `firstSetFromRegex` in `./regex-analyze.ts` — is backed
+ * by `regexp-tree` (~264 KB) and is registered by the interpreter/library entry
+ * (`index.ts`) via `registerRegexAnalyzer`. It is injected rather than imported
+ * so that consumers who ship only compiled grammars (or import `regex` directly
+ * from this subpath) never pull `regexp-tree` into their bundle. When no
+ * analyzer is registered, `regex()` uses the permissive `PERMISSIVE_FIRST_SET`
+ * below — this only disables the dispatch fast paths, never changing matches.
+ */
+export type RegexFirstSetAnalyzer = (pattern: string) => {
+    firstSet: FirstSet;
+    canMatchNewline: boolean;
+};
+export declare function registerRegexAnalyzer(analyzer: RegexFirstSetAnalyzer): void;
 export declare function regex(pattern: string | RegExp, flags?: string): Combinator<string>;
 //# sourceMappingURL=regex.d.ts.map

package/dist/combinators/regex.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"regex.d.ts","sourceRoot":"","sources":["../../src/combinators/regex.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAmD,MAAM,aAAa,CAAA;AA6H9F,wBAAgB,KAAK,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,KAAK,SAAK,GAAG,UAAU,CAAC,MAAM,CAAC,CA0B9E"}
+{"version":3,"file":"regex.d.ts","sourceRoot":"","sources":["../../src/combinators/regex.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAyC,QAAQ,EAAE,MAAM,aAAa,CAAA;AAK9F;;;;;;;;;GASG;AACH,MAAM,MAAM,qBAAqB,GAAG,CAAC,OAAO,EAAE,MAAM,KAAK;IAAE,QAAQ,EAAE,QAAQ,CAAC;IAAC,eAAe,EAAE,OAAO,CAAA;CAAE,CAAA;AAIzG,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,qBAAqB,GAAG,IAAI,CAE3E;AAQD,wBAAgB,KAAK,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,KAAK,SAAK,GAAG,UAAU,CAAC,MAAM,CAAC,CAyB9E"}

package/dist/compiler/build-arity.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"build-arity.d.ts","sourceRoot":"","sources":["../../src/compiler/build-arity.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAE5C;;;;;;;;;;GAUG;AAEH,KAAK,OAAO,GAAG,OAAO,CAAC,SAAS,EAAE;IAAE,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC,CAAA;AAkBlD;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAuB9D;AAED,sFAAsF;AACtF,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAKtD;AAED,sFAAsF;AACtF,wBAAgB,eAAe,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAKrD"}
+{"version":3,"file":"build-arity.d.ts","sourceRoot":"","sources":["../../src/compiler/build-arity.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAE5C;;;;;;;;;;GAUG;AAEH,KAAK,OAAO,GAAG,OAAO,CAAC,SAAS,EAAE;IAAE,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC,CAAA;AAkBlD;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAuB9D;AAED,sFAAsF;AACtF,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAMtD;AAED,sFAAsF;AACtF,wBAAgB,eAAe,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAMrD"}

package/dist/compiler/codegen.d.ts

@@ -31,6 +31,15 @@ export type CompiledParser<T> = {
      */
     inlineExpression: string | null;
 };
+/**
+ * Dependency manifest for the linkable form: for each rule in the map, the set
+ * of OTHER rule names its body references (by name). A referenced rule is a
+ * boundary — we record the edge and do NOT descend into it (its own deps are its
+ * own entry). Used by the linker for à la carte dep-closure selection and the
+ * compose-time name-closure check (every referenced name must resolve in the
+ * final set). Self-references are included (a recursive rule depends on itself).
+ */
+export declare function ruleDependencies(ruleMap: ReadonlyArray<readonly [string, Combinator<unknown>]>): Map<string, string[]>;
 /**
  * Compile a combinator tree into an optimized parse function at runtime.
  *
@@ -74,4 +83,40 @@ export declare function compileRuleMap(ruleMap: ReadonlyArray<readonly [string,
     keys: string[];
     replacement: string;
 } | null;
+/**
+ * The linkable form of a rule map (RULE_ABI_PLAN §3): the same compiled rule
+ * bodies as `compileRuleMap`, but returned as **splice-able pieces** under a
+ * namespace `ns` so multiple independently-compiled maps fuse into one scope
+ * (see `fuseRules`). `ns` MUST be non-empty and unique per artifact (the caller
+ * derives it — module identity in the macro, a counter in `compile()`).
+ *
+ *   prelude  — namespaced hoisted decls (regexes, expected, `_mf`/`_build`, and
+ *              private `_pf` helper fns). Sentinels / `_EMPTY_TL` / `_collator`
+ *              are NOT here — they are SHARED, emitted once by the linker.
+ *   ruleFns  — name → `function _r_<Name>(…) { … }` source (the composition
+ *              surface; siblings call these by name).
+ *   wrappers — name → public `(input,pos,ctx) => ParseResult` wrapper source.
+ *   deps     — name → referenced rule names (from `ruleDependencies`).
+ *
+ * Returns null on the same "can't inline" conditions as `compileRuleMap`.
+ */
+export type LinkablePieces = {
+    ns: string;
+    keys: string[];
+    prelude: string[];
+    ruleFns: Map<string, string>;
+    wrappers: Map<string, string>;
+    deps: Map<string, string[]>;
+    needsEmptyTl: boolean;
+    needsCollator: boolean;
+    /**
+     * Transform (`_mf`) / build (`_build`) callback FUNCTIONS, injected into the
+     * fused scope via `_env` when their SOURCE isn't available (runtime `compile()`
+     * mode). Empty when the callbacks were inlined from source (macro mode). Keyed
+     * for `_env` as `<ns>mf` / `<ns>build`.
+     */
+    mfFns: ReadonlyArray<(...args: unknown[]) => unknown>;
+    buildFns: ReadonlyArray<(...args: unknown[]) => unknown>;
+};
+export declare function compileLinkable(ruleMapArg: ReadonlyArray<readonly [string, Combinator<unknown>]>, ns: string): LinkablePieces | null;
 //# sourceMappingURL=codegen.d.ts.map

package/dist/compiler/codegen.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"codegen.d.ts","sourceRoot":"","sources":["../../src/compiler/codegen.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,KAAK,EAAE,UAAU,EAAuB,WAAW,EAAE,YAAY,EAAE,UAAU,EAAkB,MAAM,aAAa,CAAA;AA0azH,wBAAgB,oBAAoB,CAAC,EAAE,EAAE,OAAO,GAAG,IAAI,CAA0B;AA83CjF,MAAM,MAAM,cAAc,CAAC,CAAC,IAAI;IAC9B,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,WAAW,CAAC,CAAC,CAAC,CAAA;IAClD,kGAAkG;IAClG,gBAAgB,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,YAAY,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,WAAW,CAAC,CAAC,CAAC,CAAA;IAChF;;;;OAIG;IACH,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,WAAW,CAAC,CAAC,CAAC,GAAG;QAAE,MAAM,EAAE,UAAU,EAAE,CAAA;KAAE,CAAA;IACvF,iEAAiE;IACjE,MAAM,EAAE,MAAM,CAAA;IACd;;;;;;OAMG;IACH,gBAAgB,EAAE,MAAM,GAAG,IAAI,CAAA;CAChC,CAAA;AAoJD;;;;;;;;GAQG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC,EAAE,YAAY,CAAC,EAAE,MAAM,EAAE,GAAG,cAAc,CAAC,CAAC,CAAC,CA6GhG;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,cAAc,CAC5B,OAAO,EAAE,aAAa,CAAC,SAAS,CAAC,MAAM,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC,GAC7D;IAAE,IAAI,EAAE,MAAM,EAAE,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAgFhD"}
+{"version":3,"file":"codegen.d.ts","sourceRoot":"","sources":["../../src/compiler/codegen.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,KAAK,EAAE,UAAU,EAAuB,WAAW,EAAE,YAAY,EAAE,UAAU,EAAkB,MAAM,aAAa,CAAA;AAodzH,wBAAgB,oBAAoB,CAAC,EAAE,EAAE,OAAO,GAAG,IAAI,CAA0B;AAwiDjF,MAAM,MAAM,cAAc,CAAC,CAAC,IAAI;IAC9B,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,WAAW,CAAC,CAAC,CAAC,CAAA;IAClD,kGAAkG;IAClG,gBAAgB,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,YAAY,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,WAAW,CAAC,CAAC,CAAC,CAAA;IAChF;;;;OAIG;IACH,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,WAAW,CAAC,CAAC,CAAC,GAAG;QAAE,MAAM,EAAE,UAAU,EAAE,CAAA;KAAE,CAAA;IACvF,iEAAiE;IACjE,MAAM,EAAE,MAAM,CAAA;IACd;;;;;;OAMG;IACH,gBAAgB,EAAE,MAAM,GAAG,IAAI,CAAA;CAChC,CAAA;AAoJD;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,aAAa,CAAC,SAAS,CAAC,MAAM,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC,GAC7D,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CA+BvB;AAED;;;;;;;;GAQG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC,EAAE,YAAY,CAAC,EAAE,MAAM,EAAE,GAAG,cAAc,CAAC,CAAC,CAAC,CA8GhG;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,cAAc,CAC5B,OAAO,EAAE,aAAa,CAAC,SAAS,CAAC,MAAM,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC,GAC7D;IAAE,IAAI,EAAE,MAAM,EAAE,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CA+FhD;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B,EAAE,EAAE,MAAM,CAAA;IACV,IAAI,EAAE,MAAM,EAAE,CAAA;IACd,OAAO,EAAE,MAAM,EAAE,CAAA;IACjB,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC5B,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC7B,IAAI,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAA;IAC3B,YAAY,EAAE,OAAO,CAAA;IACrB,aAAa,EAAE,OAAO,CAAA;IACtB;;;;;OAKG;IACH,KAAK,EAAE,aAAa,CAAC,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC,CAAA;IACrD,QAAQ,EAAE,aAAa,CAAC,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC,CAAA;CACzD,CAAA;AAED,wBAAgB,eAAe,CAC7B,UAAU,EAAE,aAAa,CAAC,SAAS,CAAC,MAAM,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC,EACjE,EAAE,EAAE,MAAM,GACT,cAAc,GAAG,IAAI,CAwJvB"}

package/dist/compiler/inline-build.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"inline-build.d.ts","sourceRoot":"","sources":["../../src/compiler/inline-build.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAiB5C;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,OAAO,CAAC,SAAS,EAAE;IAAE,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC,GAAG,MAAM,GAAG,IAAI,CAS5F;AAED,gFAAgF;AAChF,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,MAAM,EACd,GAAG,EAAE,MAAM,GACV,MAAM,CAER"}
+{"version":3,"file":"inline-build.d.ts","sourceRoot":"","sources":["../../src/compiler/inline-build.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAiB5C;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,OAAO,CAAC,SAAS,EAAE;IAAE,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC,GAAG,MAAM,GAAG,IAAI,CAU5F;AAED,gFAAgF;AAChF,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,MAAM,EACd,GAAG,EAAE,MAAM,GACV,MAAM,CAER"}

package/dist/compiler/linker.d.ts

@@ -0,0 +1,44 @@
+import type { LinkablePieces } from './codegen.ts';
+import type { Combinator } from '../types.ts';
+export declare function linkable(rulesMap: Record<string, Combinator<unknown>>, ns?: string): LinkablePieces;
+/**
+ * A generic positioned-CST build host (RULE_ABI_PLAN §7). Pass as `ctx.build`
+ * (or `parseDoc(..., { build: cstBuildHost })`) to make ANY linkable/fused
+ * grammar produce a uniform CST — `{ _tag:'node', type, span, state, children }`
+ * — instead of its own eval-AST builders. This is the host the linter and IDE
+ * drivers use; the eval driver leaves `ctx.build` unset (grammar's own builders).
+ */
+export declare function cstBuildHost(type: string, children: ReadonlyArray<unknown>, _rawChildren: ReadonlyArray<unknown>, span: {
+    start: number;
+    end: number;
+}, _triviaLog?: readonly number[], state?: unknown): unknown;
+export type FusedRule = (input: string, pos: number, ctx: Record<string, unknown>) => {
+    ok: boolean;
+    value?: unknown;
+    span: {
+        start: number;
+        end: number;
+    };
+};
+/**
+ * Restrict a grammar/artifact to `names` plus their transitive rule-dependency
+ * closure (à la carte selection) — e.g. Jess taking parts of Less and parts of
+ * Sass: `compose([pick(less, ['MixinCall']), pick(sass, ['EachFor']), css])`. A
+ * picked rule pulls in every rule name it references, so the result is always
+ * self-consistent within the artifact. Accepts a grammar (`rules()` result) or a
+ * compiled artifact; returns an artifact for `compose()`.
+ */
+export declare function pick(grammar: LinkablePieces | Record<string, Combinator<unknown>>, names: string[]): LinkablePieces;
+/** Fuse at RUNTIME (via `new Function`) — used by `compose()` when not compiled
+ * by the macro (like `compile()`). The macro path uses `emitFusedSource` instead. */
+export declare function fuseRules(pieces: LinkablePieces[]): Record<string, FusedRule>;
+/**
+ * Fuse at BUILD time — emit the fused closure as a self-contained SOURCE
+ * expression (`(() => { … })()`), with **no `new Function`**. This is what the
+ * macro splices in for a `compose([...])` call, so macro output stays eval-free.
+ * Requires every callback to be inlined from source (macro mode); throws if any
+ * artifact carries runtime-only callback functions.
+ */
+export declare function emitFusedSource(pieces: LinkablePieces[]): string;
+export declare function compose(items: Array<LinkablePieces | Record<string, unknown>>): Record<string, FusedRule>;
+//# sourceMappingURL=linker.d.ts.map

package/dist/compiler/linker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"linker.d.ts","sourceRoot":"","sources":["../../src/compiler/linker.ts"],"names":[],"mappings":"AAqBA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA;AAClD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AAa7C,wBAAgB,QAAQ,CACtB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC,EAC7C,EAAE,CAAC,EAAE,MAAM,GACV,cAAc,CAIhB;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAC1B,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,aAAa,CAAC,OAAO,CAAC,EAChC,YAAY,EAAE,aAAa,CAAC,OAAO,CAAC,EACpC,IAAI,EAAE;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,EACpC,UAAU,CAAC,EAAE,SAAS,MAAM,EAAE,EAC9B,KAAK,CAAC,EAAE,OAAO,GACd,OAAO,CAIT;AAED,MAAM,MAAM,SAAS,GAAG,CACtB,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KACzB;IAAE,EAAE,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,OAAO,CAAC;IAAC,IAAI,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,CAAA;CAAE,CAAA;AAE3E;;;;;;;GAOG;AACH,wBAAgB,IAAI,CAClB,OAAO,EAAE,cAAc,GAAG,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC,EAC7D,KAAK,EAAE,MAAM,EAAE,GACd,cAAc,CA2BhB;AA+CD;qFACqF;AACrF,wBAAgB,SAAS,CAAC,MAAM,EAAE,cAAc,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAI7E;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,cAAc,EAAE,GAAG,MAAM,CAMhE;AA8BD,wBAAgB,OAAO,CACrB,KAAK,EAAE,KAAK,CAAC,cAAc,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACrD,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAK3B"}

package/dist/compiler/scannable-run.d.ts

@@ -7,6 +7,13 @@
  *   [X]+ / [X]*            → run while the char ∈ X                (chars)
  *   <lit>[^X]*             → consume <lit>, run until char ∈ X     (until)
  *   <open>(?:…)*<close>    → consume <open>, run to <close> literal (delimited)
+ *   x?<lit><[X]*>…         → a general linear chain of lit/run     (seq)
+ *
+ * `seq` is the CATEGORY generalization: any chain of literal segments (required
+ * or optional `x?`) and char-class runs (positive/negated, `?`/`*`/`+`). It
+ * subsumes CSS/Less `-?ident`, `--custom`, `@-?keyword`, `[^…]+`, `::?`, etc.
+ * without hardcoding a single byte — lowered only when a greedy one-pass scan
+ * provably equals the engine's backtracking (see `seqIsUnambiguous`).
  *
  * A `oneOrMore(choice(a, b, …))` where every arm is one of these compiles to a
  * single char-dispatch loop with one branch per arm — any count/order, because
@@ -14,6 +21,40 @@
  * (whitespace + comments) is just the value-discarded instance of this; nothing
  * here is trivia-specific.
  */
+/**
+ * One segment of a `seq` shape. A `seq` is the general category "a fixed linear
+ * chain of literals and char-class runs" — no alternation, no groups, no
+ * backtracking. It subsumes every CSS/Less token that is "(optional prefix)?
+ * literal* char-run* …" without hardcoding any particular byte:
+ *
+ *   lit   — a run of fixed code points, optionally present (`x?`) or required.
+ *   run   — a char-class run: positive/negated ranges, min 0/1, bounded to one
+ *           char (`[x]`, `[x]?`) or unbounded (`[x]*`, `[x]+`).
+ *   group — a non-capturing sub-pattern `(?:…)` (§8f), quantified the same way
+ *           as `run` (`min`/`unbounded`). `inner` is any already-recognized
+ *           `ScanShape` for the group's body (so a group can itself contain
+ *           `seq`/`chars`/`alt`/… — including a nested alternation via §8e).
+ *           Only used when `groupInnerSafe(inner)` holds (see that function).
+ *
+ * We only lower a `seq` when greedy left-to-right scanning provably equals the
+ * regex engine's backtracking match (see `seqIsUnambiguous`).
+ */
+export type SeqPart = {
+    part: 'lit';
+    cps: number[];
+    optional: boolean;
+} | {
+    part: 'run';
+    ranges: Array<[number, number]>;
+    negated: boolean;
+    min: 0 | 1;
+    unbounded: boolean;
+} | {
+    part: 'group';
+    inner: ScanShape;
+    min: 0 | 1;
+    unbounded: boolean;
+};
 export type ScanShape = {
     kind: 'chars';
     ranges: Array<[number, number]>;
@@ -35,13 +76,49 @@ export type ScanShape = {
     quote: number;
     excluded: Array<[number, number]>;
     escLineTerm: boolean;
+} | {
+    kind: 'seq';
+    parts: SeqPart[];
+} | {
+    kind: 'litFold';
+    open: number[];
+} | {
+    kind: 'lookahead';
+    inner: ScanShape;
+    ranges: Array<[number, number]>;
+    classNegated: boolean;
+    negative: boolean;
+} | {
+    kind: 'alt';
+    arms: ScanShape[];
+    disjoint: boolean;
+    firsts: Array<CharSet | null>;
 };
 /** Backslash (`\`) code point — the escape lead char in string shapes. */
 export declare const BACKSLASH = 92;
+/**
+ * `\s`'s code-point set per the spec's `WhiteSpace` + `LineTerminator`
+ * productions — TAB/LF/VT/FF/CR, SPACE, NBSP, and the Unicode `Zs` space
+ * separators. This set is fixed regardless of the `u` flag (unlike `\d`/`\w`,
+ * which are ASCII-only without `u` but widen with it), so it's always safe to
+ * lower to a fixed range scan.
+ */
+export declare const SPACE_RANGES: Array<[number, number]>;
+export declare function parseClassRanges(body: string): Array<[number, number]> | null;
+type CharSet = {
+    ranges: Array<[number, number]>;
+    negated: boolean;
+};
 /**
  * Recognize one scannable arm from its regex source, or null if it isn't one of
- * the structural shapes. Order matters: char-class run, ident, string, then
- * open-until-terminator, then delimited.
+ * the structural shapes. Top-level alternation (§8e) is tried FIRST — `|` has
+ * the lowest precedence in regex, so splitting on it happens before anything
+ * else, with each arm then recursively re-entering this same function (so an
+ * arm's own trailing lookahead, or its own nested `(?:…)`-wrapped alternation,
+ * is still recognized). Failing that: char-class run, ident, string, then
+ * open-until-terminator, delimited, and finally the general linear `seq` chain.
+ * A trailing `(?!class)`/`(?=class)` is peeled off next (§8b) and re-wraps
+ * whatever shape the remaining base recognizes as.
  */
 export declare function parseScanShape(source: string): ScanShape | null;
 /**
@@ -95,4 +172,5 @@ export declare function scanBranch(shape: ScanShape, mint: Mint): string;
  * kindIndex] trivia chunk. Same completion semantics as scanBranch.
  */
 export declare function scanBranchLabeled(shape: ScanShape, kindIndex: number, mint: Mint): string;
+export {};
 //# sourceMappingURL=scannable-run.d.ts.map

package/dist/compiler/scannable-run.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scannable-run.d.ts","sourceRoot":"","sources":["../../src/compiler/scannable-run.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,MAAM,MAAM,SAAS,GACjB;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAAC,MAAM,EAAE,OAAO,CAAA;CAAE,GACnE;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,IAAI,EAAE,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAAC,IAAI,EAAE,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;CAAE,GAC/E;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,IAAI,EAAE,MAAM,EAAE,CAAC;IAAC,IAAI,EAAE,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;CAAE,GAChE;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,IAAI,EAAE,MAAM,EAAE,CAAC;IAAC,KAAK,EAAE,MAAM,EAAE,CAAA;CAAE,GAKtD;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAAC,WAAW,EAAE,OAAO,CAAA;CAAE,CAAA;AAE9F,0EAA0E;AAC1E,eAAO,MAAM,SAAS,KAAK,CAAA;AA2H3B;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CA4C/D;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CAGlF;AAED,eAAO,MAAM,SAAS,SAAU,MAAM,UAAU,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,KAAG,MAGzD,CAAA;AAEjB,8FAA8F;AAC9F,eAAO,MAAM,OAAO,SAAU,MAAM,OAAO,MAAM,EAAE,aAAa,MAAM,KAAG,MAOxD,CAAA;AAEjB,8EAA8E;AAC9E,eAAO,MAAM,gBAAgB,YAAI,EAAE,EAAE,EAAE,EAAE,IAAI,EAAE,IAAI,CAAU,CAAA;AAE7D,0FAA0F;AAC1F,wBAAgB,cAAc,CAC5B,KAAK,EAAE,OAAO,CAAC,SAAS,EAAE;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,CAAC,GAC5C,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAIzB;AAED,sEAAsE;AACtE,MAAM,MAAM,IAAI,GAAG,CAAC,MAAM,CAAC,EAAE,MAAM,KAAK,MAAM,CAAA;AAE9C;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,UAAU,GAAG;IAAE,KAAK,EAAE,MAAM,EAAE,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAAA;AAKrE,wBAAgB,cAAc,CAC5B,KAAK,EAAE,SAAS,EAChB,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,IAAI,EACV,GAAG,EAAE,MAAM,EACX,SAAS,CAAC,EAAE,MAAM,GACjB,UAAU,CAgHZ;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,IAAI,GAAG,MAAM,CAG/D;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,GAAG,MAAM,CAazF"}
+{"version":3,"file":"scannable-run.d.ts","sourceRoot":"","sources":["../../src/compiler/scannable-run.ts"],"names":[],"mappings":"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"}

package/dist/cst/offset-model.d.ts

@@ -0,0 +1,119 @@
+import type { Span } from '../types.ts';
+/**
+ * Trivia-offset-inference model.
+ *
+ * The premise (see docs): most trivia carries nothing that isn't already implied
+ * by the source offsets of the tokens around it. A gap between a slot ending at
+ * 100 and the next starting at 103 IS three characters of trivia — known without
+ * storing anything. So we store only the slot boundaries (which the tree already
+ * has) and reconstruct trivia from them:
+ *
+ *   - exact printing: slice the source between two slots (`gapText`);
+ *   - inference: widths / indents / alignment / blank-lines are subtraction;
+ *   - positional queries: binary search over the sorted slot array (O(log n)),
+ *     collapsing the old double-indexed before/after maps into one index.
+ *
+ * A "slot" is a leaf token's source span. Trivia lives in the GAPS between
+ * consecutive slots (plus the leading gap before the first slot and the trailing
+ * gap after the last). Gaps are fully determined by the sorted slot list, so
+ * there is no separate trivia store for whitespace at all.
+ */
+/** A leaf token's source span — the anchor points; trivia is between them. */
+export type Slot = {
+    readonly start: number;
+    readonly end: number;
+};
+/** A trivia region between two slots (or a document boundary). Half-open `[start, end)`. */
+export type Gap = {
+    readonly start: number;
+    readonly end: number;
+};
+/**
+ * A positional index over an ordered set of slots (leaf spans) within a source
+ * of length `docEnd`. Answers "what trivia is before/after/around this offset"
+ * by binary search, and reconstructs the exact trivia text by slicing `source`.
+ *
+ * Slots must be non-overlapping. They are sorted by `start` on construction;
+ * out-of-order or overlapping input throws (the caller's spans are wrong).
+ */
+export declare class OffsetIndex {
+    /** Slot starts, sorted ascending. Parallel to `_ends`. */
+    private readonly _starts;
+    private readonly _ends;
+    readonly count: number;
+    readonly docStart: number;
+    readonly docEnd: number;
+    constructor(slots: readonly Slot[], docStart?: number, docEnd?: number);
+    /** The slot at index `i` (0-based, source order), or undefined. */
+    slot(i: number): Slot | undefined;
+    /**
+     * Index of the gap that CONTAINS `offset`, in `[0, count]`. Gap `i` spans
+     * `[endOf(i-1), startOf(i))` where `endOf(-1)=docStart` and `startOf(count)=docEnd`.
+     * An offset that lands inside a slot returns that slot's TRAILING gap index
+     * (i.e. the gap after it) — callers querying at slot boundaries get the
+     * intuitive answer via `gapBefore`/`gapAfter`.
+     */
+    gapIndexAt(offset: number): number;
+    /** The gap at index `i` in `[0, count]`. */
+    gap(i: number): Gap | undefined;
+    /**
+     * The trivia gap immediately BEFORE `offset` (`[prevSlotEnd, offset)`), where
+     * `prevSlotEnd` is the end of the last slot ending at or before `offset` (or
+     * `docStart`). For a real slot start this is the gap preceding that slot; for an
+     * adjacent slot the gap is empty and agrees with `gapAfter` on the same seam.
+     */
+    gapBefore(offset: number): Gap | undefined;
+    /**
+     * The trivia gap immediately AFTER `offset` (`[offset, nextSlotStart)`), where
+     * `nextSlotStart` is the least slot start at or after `offset` (or `docEnd`).
+     */
+    gapAfter(offset: number): Gap | undefined;
+    /** Least slot start `>= offset`, else `docEnd`. */
+    private _ceilStart;
+    /** Is this gap empty (adjacent slots, no trivia)? */
+    isEmpty(gap: Gap): boolean;
+}
+/** Exact trivia text of a gap: `source.slice(gap.start, gap.end)`. */
+export declare function gapText(source: string, gap: Gap): string;
+/** Count of line breaks (`\n`, with `\r\n` counted once) within a gap. */
+export declare function lineBreaksIn(source: string, gap: Gap): number;
+/** Blank lines in a gap = breaks - 1 (a single break is just a line end, not a blank line). */
+export declare function blankLinesIn(source: string, gap: Gap): number;
+/**
+ * Offset just after the last line break in the gap (the start of the final
+ * line's indent), or `gap.start` if the gap has no break. This is the ONE
+ * non-inferable position; every indent quantity derives from it by subtraction.
+ */
+export declare function lineStartWithin(source: string, gap: Gap): number;
+/**
+ * Indent width of the line the NEXT slot sits on: `nextStart - lineStart`.
+ * `nextStart` is `gap.end` (the following slot's start). Zero if the gap has no
+ * line break (the next slot is on the same line).
+ */
+export declare function indentWidth(source: string, gap: Gap): number;
+/** True if the final line's indent mixes tabs and spaces (the one case width can't capture). */
+export declare function indentMixed(source: string, gap: Gap): boolean;
+/** Comment spans within a gap (absolute offsets), tokenized by `comment`. */
+export declare function commentsIn(source: string, gap: Gap, comment: RegExp): Span[];
+/**
+ * Does the gap carry anything a normalizing printer must preserve? True if it
+ * contains a comment or a line break; a pure inline-whitespace gap returns false
+ * and needs no record at all (the printer re-derives canonical spacing).
+ */
+export declare function gapIsSignificant(source: string, gap: Gap, comment?: RegExp): boolean;
+/**
+ * Collect the leaf-token spans of a CST in source order. Nodes/errors (which
+ * carry `children`) are descended into; only childless spanned items (terminals)
+ * become slots. Node spans are skipped — they overlap their children and would
+ * double-cover the gaps.
+ */
+export declare function collectLeafSlots(root: unknown): Slot[];
+/**
+ * Build an `OffsetIndex` directly from a parseman CST root and its source. This
+ * is the drop-in replacement for the double-indexed `buildTriviaIndex`: the same
+ * before/after trivia is recovered by `gapBefore`/`gapAfter` + `gapText`, and it
+ * additionally supports arbitrary positional queries and inference — with nothing
+ * stored per whitespace gap.
+ */
+export declare function buildOffsetIndex(root: unknown, input?: string): OffsetIndex;
+//# sourceMappingURL=offset-model.d.ts.map

package/dist/cst/offset-model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"offset-model.d.ts","sourceRoot":"","sources":["../../src/cst/offset-model.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,aAAa,CAAA;AAEvC;;;;;;;;;;;;;;;;;;GAkBG;AAEH,8EAA8E;AAC9E,MAAM,MAAM,IAAI,GAAG;IAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAAA;AAEnE,4FAA4F;AAC5F,MAAM,MAAM,GAAG,GAAG;IAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAAA;AAqBlE;;;;;;;GAOG;AACH,qBAAa,WAAW;IACtB,0DAA0D;IAC1D,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAU;IAClC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAU;IAChC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IAEvB,YAAY,KAAK,EAAE,SAAS,IAAI,EAAE,EAAE,QAAQ,SAAI,EAAE,MAAM,CAAC,EAAE,MAAM,EAqBhE;IAED,mEAAmE;IACnE,IAAI,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAGhC;IAED;;;;;;OAMG;IACH,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAUjC;IAED,4CAA4C;IAC5C,GAAG,CAAC,CAAC,EAAE,MAAM,GAAG,GAAG,GAAG,SAAS,CAK9B;IAED;;;;;OAKG;IACH,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,GAAG,GAAG,SAAS,CAIzC;IAED;;;OAGG;IACH,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,GAAG,GAAG,SAAS,CAExC;IAED,mDAAmD;IACnD,OAAO,CAAC,UAAU;IAgBlB,qDAAqD;IACrD,OAAO,CAAC,GAAG,EAAE,GAAG,GAAG,OAAO,CAEzB;CACF;AAYD,sEAAsE;AACtE,wBAAgB,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,GAAG,GAAG,MAAM,CAExD;AAED,0EAA0E;AAC1E,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,GAAG,GAAG,MAAM,CAQ7D;AAED,+FAA+F;AAC/F,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,GAAG,GAAG,MAAM,CAE7D;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,GAAG,GAAG,MAAM,CAMhE;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,GAAG,GAAG,MAAM,CAI5D;AAED,gGAAgG;AAChG,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,GAAG,GAAG,OAAO,CAU7D;AAED,6EAA6E;AAC7E,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,GAAG,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,EAAE,CAW5E;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,GAAG,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAKpF;AAcD;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,EAAE,CAYtD;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,SAAK,GAAG,WAAW,CAEvE"}

package/dist/cst/relative-spans.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Relative span model for incremental edits.
+ *
+ * Absolute source offsets are simple but fragile: an insertion at offset `at`
+ * shifts EVERY downstream offset, so a whole-tree renumber is O(nodes-after-edit).
+ * Storing each node's span RELATIVE to its parent's start makes edits local: an
+ * insertion inside child k of a node only changes
+ *   (a) child k's relative end,
+ *   (b) the relative start of siblings after k,
+ * and leaves the *children* of those shifted siblings untouched — they move with
+ * their parent for free. So the mutation count is O(depth + trailing siblings),
+ * not O(all following nodes), and every unaffected subtree is shared by identity.
+ *
+ * An absolute view is recovered on query by accumulating the parent base as you
+ * descend (the `absolutize` / `absoluteSpanAt` cursor) — one source of truth,
+ * two manifestations.
+ */
+/** A node with an ABSOLUTE source span and ordered children. */
+export type AbsNode = {
+    readonly start: number;
+    readonly end: number;
+    readonly children: readonly AbsNode[];
+};
+/** A node whose `start`/`end` are RELATIVE to its parent's start (root base = 0). */
+export type RelNode = {
+    readonly start: number;
+    readonly end: number;
+    readonly children: readonly RelNode[];
+};
+/** Convert an absolute tree to parent-relative spans. */
+export declare function relativize(node: AbsNode, parentBase?: number): RelNode;
+/** Reconstruct absolute spans from a relative tree. Inverse of `relativize`. */
+export declare function absolutize(node: RelNode, parentBase?: number): AbsNode;
+/**
+ * Absolute span of the node at `path` (child indices from the root), accumulating
+ * the base as it descends — O(path length), no full absolutize. The relative-form
+ * cursor: query any node's absolute position without materializing the whole tree.
+ */
+export declare function absoluteSpanAt(root: RelNode, path: readonly number[]): {
+    start: number;
+    end: number;
+};
+/** Naive absolute reshift (baseline): shift every offset >= `at` by `delta`. */
+export declare function shiftAbsolute(node: AbsNode, at: number, delta: number): AbsNode;
+/**
+ * Apply an edit of `delta` characters at absolute offset `at` to a RELATIVE tree.
+ * Returns a new relative tree; every subtree that ends at/before `at` (in absolute
+ * terms) is returned by IDENTITY (unchanged), so the result structurally shares
+ * all unaffected subtrees with the input.
+ *
+ * `stats.allocated` counts nodes that had to be re-created — the incremental cost.
+ */
+export declare function applyEdit(root: RelNode, at: number, delta: number, stats?: {
+    allocated: number;
+}): RelNode;
+//# sourceMappingURL=relative-spans.d.ts.map

package/dist/cst/relative-spans.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"relative-spans.d.ts","sourceRoot":"","sources":["../../src/cst/relative-spans.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,gEAAgE;AAChE,MAAM,MAAM,OAAO,GAAG;IACpB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,QAAQ,CAAC,QAAQ,EAAE,SAAS,OAAO,EAAE,CAAA;CACtC,CAAA;AAED,qFAAqF;AACrF,MAAM,MAAM,OAAO,GAAG;IACpB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,QAAQ,CAAC,QAAQ,EAAE,SAAS,OAAO,EAAE,CAAA;CACtC,CAAA;AAED,yDAAyD;AACzD,wBAAgB,UAAU,CAAC,IAAI,EAAE,OAAO,EAAE,UAAU,SAAI,GAAG,OAAO,CAMjE;AAED,gFAAgF;AAChF,wBAAgB,UAAU,CAAC,IAAI,EAAE,OAAO,EAAE,UAAU,SAAI,GAAG,OAAO,CAOjE;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAUrG;AAED,gFAAgF;AAChF,wBAAgB,aAAa,CAAC,IAAI,EAAE,OAAO,EAAE,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAQ/E;AAED;;;;;;;GAOG;AACH,wBAAgB,SAAS,CACvB,IAAI,EAAE,OAAO,EACb,EAAE,EAAE,MAAM,EACV,KAAK,EAAE,MAAM,EACb,KAAK,CAAC,EAAE;IAAE,SAAS,EAAE,MAAM,CAAA;CAAE,GAC5B,OAAO,CAGT"}

package/dist/cst/types.d.ts

@@ -5,7 +5,7 @@ import type { Span } from '../types.ts';
  * and `children` works — whether from `node()` build callbacks or custom ASTs.
  *
  * `children` only needs items with `_tag` so traversal can distinguish sub-nodes
- * from leaves. `makeFunctionalDoc` uses an optional `rebuild` callback (or a
+ * from leaves. `parseDoc` uses an optional `rebuild` callback (or a
  * shallow spread) when grafting a re-parsed subtree.
  */
 export type NodeLike = {

package/dist/functional/doc.d.ts

@@ -1,5 +1,5 @@
 /**
- * Functional incremental document — incremental re-parse over a rules() registry.
+ * Incremental parse document — incremental re-parse over a rules() registry.
  */
 import type { ParseContext, ParseFail, ParseResult } from '../types.ts';
 import type { NodeLike, CSTLeaf, CSTError } from '../cst/types.ts';
@@ -7,7 +7,7 @@ import type { NodeLike, CSTLeaf, CSTError } from '../cst/types.ts';
 export type RuleFn<N> = (input: string, pos: number, ctx: ParseContext) => ParseResult<N>;
 /** Rule name → parser function. This is exactly the shape `rules()` returns. */
 export type Registry<N> = Record<string, RuleFn<N>>;
-export type FunctionalDocOptions<N extends NodeLike> = {
+export type ParseDocOptions<N extends NodeLike> = {
     /** Initial grammar state threaded into ctx.state for the root parse. */
     state?: unknown;
     /**
@@ -16,20 +16,40 @@ export type FunctionalDocOptions<N extends NodeLike> = {
      * works for plain-object nodes; class-instance ASTs should supply their own.
      */
     rebuild?: (node: N, children: ReadonlyArray<N | CSTLeaf | CSTError>) => N;
+    /**
+     * Mode host for a linkable/fused grammar (RULE_ABI_PLAN §7): threaded into
+     * `ctx.build` on every (re)parse so `node()` rules build a positioned CST /
+     * language-service tree instead of their own eval-AST. Unset → the grammar's
+     * own builders (eval mode).
+     */
+    build?: ParseContext['build'];
 };
-export interface FunctionalDoc<N extends NodeLike> {
+export interface ParseDoc<N extends NodeLike> {
     readonly tree: N | null;
     readonly errors: ParseFail[];
     readonly input: string;
     /**
      * Incrementally re-parse after a text change. `from`/`to` are byte offsets in
      * the OLD input; `replacement` fills that range (editor change-event shape).
+     * Sound: the result tree is always structurally identical to a fresh
+     * `parseDoc` of the edited text (the Stage-2 guard falls back to a full
+     * reparse whenever reuse can't be proven safe). Reuse/strategy is intentionally
+     * NOT reported here — an observer derives it by diffing this tree against the
+     * previous one (see the incremental tests); the runtime's job is to be fast,
+     * not to measure itself.
      */
-    edit(from: number, to: number, replacement: string): FunctionalDoc<N>;
+    edit(from: number, to: number, replacement: string): ParseDoc<N>;
 }
 /**
- * Parse `input` from `rootRule` and wrap the result in a FunctionalDoc that can
+ * Deep structural equality on parse trees: `_tag`, `span`, node `type`, leaf
+ * `value`, and children pairwise. This is the oracle relation `.edit()` must
+ * preserve against a full reparse; it's also what the Stage-2 guard compares
+ * probe results with.
+ */
+export declare function structurallyEqual(a: unknown, b: unknown): boolean;
+/**
+ * Parse `input` from `rootRule` and wrap the result in a ParseDoc that can
  * be incrementally re-parsed via `.edit()`.
  */
-export declare function makeFunctionalDoc<N extends NodeLike>(registry: Registry<N>, rootRule: string, input: string, opts?: FunctionalDocOptions<N>): FunctionalDoc<N>;
+export declare function parseDoc<N extends NodeLike>(registry: Registry<N>, rootRule: string, input: string, opts?: ParseDocOptions<N>): ParseDoc<N>;
 //# sourceMappingURL=doc.d.ts.map

package/dist/functional/doc.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"doc.d.ts","sourceRoot":"","sources":["../../src/functional/doc.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,KAAK,EAAE,YAAY,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,aAAa,CAAA;AACvE,OAAO,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAA;AAElE,qFAAqF;AACrF,MAAM,MAAM,MAAM,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,YAAY,KAAK,WAAW,CAAC,CAAC,CAAC,CAAA;AAEzF,gFAAgF;AAChF,MAAM,MAAM,QAAQ,CAAC,CAAC,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,CAAA;AAEnD,MAAM,MAAM,oBAAoB,CAAC,CAAC,SAAS,QAAQ,IAAI;IACrD,wEAAwE;IACxE,KAAK,CAAC,EAAE,OAAO,CAAA;IACf;;;;OAIG;IACH,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,QAAQ,EAAE,aAAa,CAAC,CAAC,GAAG,OAAO,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAA;CAC1E,CAAA;AAED,MAAM,WAAW,aAAa,CAAC,CAAC,SAAS,QAAQ;IAC/C,QAAQ,CAAC,IAAI,EAAE,CAAC,GAAG,IAAI,CAAA;IACvB,QAAQ,CAAC,MAAM,EAAE,SAAS,EAAE,CAAA;IAC5B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB;;;OAGG;IACH,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,aAAa,CAAC,CAAC,CAAC,CAAA;CACtE;AA0KD;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,SAAS,QAAQ,EAClD,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,EACrB,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,EACb,IAAI,GAAE,oBAAoB,CAAC,CAAC,CAAM,GACjC,aAAa,CAAC,CAAC,CAAC,CASlB"}
+{"version":3,"file":"doc.d.ts","sourceRoot":"","sources":["../../src/functional/doc.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,KAAK,EAAE,YAAY,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,aAAa,CAAA;AACvE,OAAO,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAA;AAElE,qFAAqF;AACrF,MAAM,MAAM,MAAM,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,YAAY,KAAK,WAAW,CAAC,CAAC,CAAC,CAAA;AAEzF,gFAAgF;AAChF,MAAM,MAAM,QAAQ,CAAC,CAAC,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,CAAA;AAEnD,MAAM,MAAM,eAAe,CAAC,CAAC,SAAS,QAAQ,IAAI;IAChD,wEAAwE;IACxE,KAAK,CAAC,EAAE,OAAO,CAAA;IACf;;;;OAIG;IACH,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,QAAQ,EAAE,aAAa,CAAC,CAAC,GAAG,OAAO,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAA;IACzE;;;;;OAKG;IACH,KAAK,CAAC,EAAE,YAAY,CAAC,OAAO,CAAC,CAAA;CAC9B,CAAA;AAED,MAAM,WAAW,QAAQ,CAAC,CAAC,SAAS,QAAQ;IAC1C,QAAQ,CAAC,IAAI,EAAE,CAAC,GAAG,IAAI,CAAA;IACvB,QAAQ,CAAC,MAAM,EAAE,SAAS,EAAE,CAAA;IAC5B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB;;;;;;;;;OASG;IACH,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAA;CACjE;AA6GD;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAG,OAAO,CAsBjE;AAyID;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,CAAC,SAAS,QAAQ,EACzC,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,EACrB,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,EACb,IAAI,GAAE,eAAe,CAAC,CAAC,CAAM,GAC5B,QAAQ,CAAC,CAAC,CAAC,CASb"}