parseman 0.13.0 → 0.14.1

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;AAqbzH,wBAAgB,oBAAoB,CAAC,EAAE,EAAE,OAAO,GAAG,IAAI,CAA0B;AAohDjF,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,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,CAiFhD"}
+{"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.map

@@ -1 +1 @@
-{"version":3,"file":"scannable-run.d.ts","sourceRoot":"","sources":["../../src/compiler/scannable-run.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,MAAM,OAAO,GACf;IAAE,IAAI,EAAE,KAAK,CAAC;IAAC,GAAG,EAAE,MAAM,EAAE,CAAC;IAAC,QAAQ,EAAE,OAAO,CAAA;CAAE,GACjD;IAAE,IAAI,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAAC,OAAO,EAAE,OAAO,CAAC;IAAC,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC;IAAC,SAAS,EAAE,OAAO,CAAA;CAAE,GAClG;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,SAAS,CAAC;IAAC,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC;IAAC,SAAS,EAAE,OAAO,CAAA;CAAE,CAAA;AAEvE,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,GAG1F;IAAE,IAAI,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,OAAO,EAAE,CAAA;CAAE,GAGjC;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,MAAM,EAAE,CAAA;CAAE,GAKnC;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,KAAK,EAAE,SAAS,CAAC;IAAC,MAAM,EAAE,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAAC,YAAY,EAAE,OAAO,CAAC;IAAC,QAAQ,EAAE,OAAO,CAAA;CAAE,GASlH;IAAE,IAAI,EAAE,KAAK,CAAC;IAAC,IAAI,EAAE,SAAS,EAAE,CAAC;IAAC,QAAQ,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,KAAK,CAAC,OAAO,GAAG,IAAI,CAAC,CAAA;CAAE,CAAA;AAExF,0EAA0E;AAC1E,eAAO,MAAM,SAAS,KAAK,CAAA;AAK3B;;;;;;GAMG;AACH,eAAO,MAAM,YAAY,EAAE,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAGhD,CAAA;AA2BD,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GAAG,IAAI,CAyC7E;AAqRD,KAAK,OAAO,GAAG;IAAE,MAAM,EAAE,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAAC,OAAO,EAAE,OAAO,CAAA;CAAE,CAAA;AA+VpE;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CAY/D;AAkDD;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CAOlF;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,CA6PZ;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/functional/doc.d.ts

@@ -16,6 +16,13 @@ export type ParseDocOptions<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 ParseDoc<N extends NodeLike> {
     readonly tree: N | null;
@@ -24,9 +31,22 @@ export interface ParseDoc<N extends NodeLike> {
     /**
      * 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): ParseDoc<N>;
 }
+/**
+ * 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()`.

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,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;CAC1E,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;;;OAGG;IACH,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAA;CACjE;AA0KD;;;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"}
+{"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"}

package/dist/functional/run.d.ts

@@ -0,0 +1,63 @@
+import type { Combinator, ParseContext, ParseError, ParseResult } from '../types.ts';
+/**
+ * Run a compiled/interpreted grammar entry against an input and collect the raw
+ * outcome a tool needs to shape a parse result — WITHOUT the consumer having to
+ * hand-build a `ctx`, branch on function-vs-combinator, or scan for leftover
+ * input itself.
+ *
+ * A `compile()`/macro grammar hands you a map of bare parse FUNCTIONS; the
+ * interpreter hands you COMBINATORS. `run()` invokes either, threads the standard
+ * framework ctx (trivia log, recover/expect error sink, the `ctx.build` host,
+ * grammar state), and — given the grammar's trivia parser — reports where
+ * non-trivia input was left unconsumed. The consumer keeps only its own policy:
+ * how to shape the tree and how to turn diagnostics into its error type.
+ */
+/** A compiled rule (macro/`compile()` output) OR an interpreter combinator. */
+export type Runnable = ((input: string, pos: number, ctx: ParseContext) => ParseResult<unknown>) | Combinator<unknown>;
+export type RunOptions = {
+    /** `ctx.build` host — makes structural `node()` rules build a CST / AST via the
+     * host instead of their own eval builders. Omit for a grammar's own builders. */
+    build?: ParseContext['build'];
+    /** Initial grammar state threaded into `ctx.state`. */
+    state?: unknown;
+    /**
+     * The grammar's trivia rule. A root rule consumes trivia BETWEEN terms but not
+     * after the last one, so trailing whitespace/comments would otherwise look like
+     * unparsed input. Given the trivia rule, `run` skips that tail before computing
+     * `unconsumedFrom` — so only real leftover is reported. Also encodes dialect
+     * differences for free: pass the CSS trivia and a trailing `//` counts as
+     * leftover; pass the Less trivia (which treats `//` as a line comment) and it
+     * doesn't. An UNTERMINATED comment (which the trivia rule won't match) surfaces
+     * at its start. Omit to require the parse to reach the exact end itself.
+     */
+    trivia?: Runnable;
+};
+export type RunResult = {
+    ok: boolean;
+    /** The entry's value on success; undefined on failure. */
+    value: unknown;
+    span: {
+        start: number;
+        end: number;
+    };
+    /** Expected-token set when the TOP-LEVEL parse failed (empty on success). */
+    expected: string[];
+    /** `recover()` / `expect()` diagnostics collected during the parse (in order). */
+    errors: ParseError[];
+    /**
+     * Flat trivia log for building a trivia map. Entry width depends on whether the
+     * grammar uses labeled trivia: 2 numbers per entry (`start, end`) for plain
+     * trivia, 3 numbers per entry (`start, end, kindIndex`) for labeled trivia
+     * (grammars with `label()` arms in their trivia choice). Use `buildTriviaIndex`
+     * / `triviaEntries` to consume it format-agnostically rather than iterating raw.
+     */
+    triviaLog: number[];
+    /** Offset where unparsed input begins — the first non-trivia character the parse
+     * left unconsumed (trailing trivia skipped when `trivia` is given), or null if
+     * the whole input was consumed. This is how you detect "the grammar stopped short,
+     * there's junk here". Only meaningful on success — a failed parse reports its own
+     * `span`/`expected`. */
+    unconsumedFrom: number | null;
+};
+export declare function run(entry: Runnable, input: string, options?: RunOptions): RunResult;
+//# sourceMappingURL=run.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../../src/functional/run.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,aAAa,CAAA;AAEpF;;;;;;;;;;;;GAYG;AAEH,+EAA+E;AAC/E,MAAM,MAAM,QAAQ,GAChB,CAAC,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,YAAY,KAAK,WAAW,CAAC,OAAO,CAAC,CAAC,GACzE,UAAU,CAAC,OAAO,CAAC,CAAA;AAEvB,MAAM,MAAM,UAAU,GAAG;IACvB;qFACiF;IACjF,KAAK,CAAC,EAAE,YAAY,CAAC,OAAO,CAAC,CAAA;IAC7B,uDAAuD;IACvD,KAAK,CAAC,EAAE,OAAO,CAAA;IACf;;;;;;;;;OASG;IACH,MAAM,CAAC,EAAE,QAAQ,CAAA;CAClB,CAAA;AAED,MAAM,MAAM,SAAS,GAAG;IACtB,EAAE,EAAE,OAAO,CAAA;IACX,0DAA0D;IAC1D,KAAK,EAAE,OAAO,CAAA;IACd,IAAI,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,CAAA;IACpC,6EAA6E;IAC7E,QAAQ,EAAE,MAAM,EAAE,CAAA;IAClB,kFAAkF;IAClF,MAAM,EAAE,UAAU,EAAE,CAAA;IACpB;;;;;;OAMG;IACH,SAAS,EAAE,MAAM,EAAE,CAAA;IACnB;;;;4BAIwB;IACxB,cAAc,EAAE,MAAM,GAAG,IAAI,CAAA;CAC9B,CAAA;AAKD,wBAAgB,GAAG,CAAC,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,GAAE,UAAe,GAAG,SAAS,CAqCvF"}