parseman 0.33.0 → 0.34.0

package/dist/analysis/gating.d.ts

@@ -15,8 +15,16 @@
  * (see `src/compiler/codegen.ts`). Accept a deliberately-ungated choice by listing
  * its `id` in the gating snapshot allowlist (`analyzeGating(entry, { accept })` /
  * `compile(g, { gating: { level, accept } })`) — the single suppression mechanism.
+ *
+ * WHERE the question is asked matters as much as the answer. A SHARED SHAPE — a
+ * `rules()` map referencing a rule it doesn't define (`g.Value`) — has no verdict of
+ * its own: the hole makes every first-set through it `any`, but that configuration is
+ * never executed and its author cannot fix it. Such a choice is `deferred` here, and
+ * re-asked with `resolveRef` at the site that BINDS the name (`runFusedGatingDiagnostic`
+ * in codegen.ts) — the artifact that really runs, whose author really can fix it.
  */
 import type { Combinator, FirstSet } from '../types.ts';
+import { type RefResolver } from '../combinators/first-set.ts';
 /** Why an arm's (deep) first-set is `any` / over-broad — the poison source. */
 export type FirstSetCause = 'leading-not' | 'nullable-prefix' | 'cross-artifact-ref' | 'broad-recognizer' | 'opaque-wrapper' | 'ref-cycle';
 /** An arm whose deep first-set is `any` / over-broad. */
@@ -32,6 +40,16 @@ export type AnyArm = {
      * genuinely-ungated finding.
      */
     shallowAnyOnly: boolean;
+    /**
+     * True when the poison is a NAMED cross-artifact hole this artifact cannot resolve
+     * (`g.Value` in a shared shape). The author of THIS artifact cannot act on it — the
+     * arm's real first-set only exists once a consumer binds the name — so a choice
+     * whose every `any` arm is one of these is `deferred`, not `ungated`.
+     *
+     * An UNNAMED unresolved `ref()` is NOT this: nobody can bind it by name, so it is a
+     * genuine local finding and stays reportable here.
+     */
+    unresolvedExternal: boolean;
     /** Concrete fix, naming a real primitive. */
     suggestion: string;
 };
@@ -72,6 +90,17 @@ export type ChoiceGating = {
     gates: 'yes' | 'recoverable' | 'no';
     /** True when this ungated choice's `id` is in the accepted-snapshot allowlist. */
     accepted: boolean;
+    /**
+     * `gates: 'no'` was decided by cross-artifact HOLES ONLY — every `any` arm is an
+     * unresolved NAMED `g.Foo` ref and no two finite arms overlap. The verdict is not
+     * this artifact's to make: the shape module can't fix it (the hole has no body
+     * here) and the configuration it describes never runs. The answer belongs to the
+     * FUSED artifact, where the name is bound — see `runFusedGatingDiagnostic`.
+     *
+     * Deferred choices are excluded from `ungated`: they neither warn nor fail the
+     * `'error'` gate at this site.
+     */
+    deferred: boolean;
     combinedFirstSet: {
         shallow: FirstSet;
         deep: FirstSet;
@@ -88,6 +117,22 @@ export type AnalyzeGatingOptions = {
      * SINGLE per-choice suppression mechanism.
      */
     accept?: Iterable<string>;
+    /**
+     * Name to attribute an UNNAMED entry to, instead of the synthetic `<entry>`.
+     * The macro plugin passes the binding's own variable name, so a warning on a
+     * top-level combinator const reads `choice @ directMixinReferenceAhead`
+     * (actionable, and a discriminating `accept` key) rather than `choice @
+     * <entry>` repeated once per const. Ignored when the entry already carries a
+     * `_ruleName`.
+     */
+    entryName?: string;
+    /**
+     * Bind NAMED cross-artifact holes (`g.Foo`) by name — supply the FUSED winner map's
+     * lookup. With it, an arm led by a shared shape's hole reports the first-set it
+     * really has once bound, so `deferred` collapses to a real `yes`/`no` verdict.
+     * Without it (the authoring site) such a choice stays `deferred`.
+     */
+    resolveRef?: RefResolver;
 };
 export type GatingReport = {
     totalChoices: number;
@@ -97,6 +142,12 @@ export type GatingReport = {
     ungated: ChoiceGating[];
     /** Ungated choices whose id was in the accepted allowlist — silent, accepted with intent. */
     accepted: ChoiceGating[];
+    /**
+     * Choices whose verdict is NOT this artifact's to make — every `any` arm is an
+     * unresolved cross-artifact hole (see `ChoiceGating.deferred`). Silent here; the
+     * fused artifact re-asks the question with the hole bound.
+     */
+    deferred: ChoiceGating[];
     /** Accepted ids that matched no ungated choice — stale snapshot entries to prune. */
     acceptedUnused: string[];
     /** Every choice, for full inspection / CI snapshots. */
@@ -105,11 +156,25 @@ export type GatingReport = {
 };
 export declare function firstSetToString(fs: FirstSet): string;
 export declare function analyzeGating(entry: Combinator<unknown>, opts?: AnalyzeGatingOptions): GatingReport;
+/**
+ * Multi-root variant: analyze a WHOLE `rules()` map in one walk, so every choice
+ * is attributed to the rule that owns it.
+ *
+ * The macro build compiles a grammar through `compileRuleMap`/`compileLinkable`,
+ * never through the single-entry `compile()`. Analyzing one entry at a time (or
+ * not at all) is what produced unnamed `choice @ <entry>` warnings and ZERO
+ * anti-patterns for grammars that in fact have dozens: an unnamed warning in a
+ * multi-thousand-line grammar is unactionable. Seeding the walk with EVERY named
+ * root is what recovers the rule names — and, because the walk is shared, each
+ * choice is still analyzed exactly once however many rules reach it.
+ */
+export declare function analyzeGatingRules(ruleMap: ReadonlyArray<readonly [string, Combinator<unknown>]>, opts?: AnalyzeGatingOptions): GatingReport;
 export type GatingWarnLevel = 'off' | 'warn' | 'error';
 /**
  * Format the genuinely-ungated findings + anti-patterns as ready-to-print lines.
  * Precise by design: only 'no'-gated choices NOT in the accepted allowlist, plus
- * the anti-pattern lints. Recoverable / gated / accepted choices produce nothing.
+ * the anti-pattern lints. Recoverable / gated / accepted / DEFERRED choices produce
+ * nothing (a deferred choice's verdict belongs to the fusing artifact, not here).
  */
 export declare function formatGatingWarnings(report: GatingReport): string[];
 //# sourceMappingURL=gating.d.ts.map

package/dist/analysis/gating.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gating.d.ts","sourceRoot":"","sources":["../../src/analysis/gating.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,OAAO,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAa,MAAM,aAAa,CAAA;AAGlE,+EAA+E;AAC/E,MAAM,MAAM,aAAa,GACrB,aAAa,GACb,iBAAiB,GACjB,oBAAoB,GACpB,kBAAkB,GAClB,gBAAgB,GAChB,WAAW,CAAA;AAEf,yDAAyD;AACzD,MAAM,MAAM,MAAM,GAAG;IACnB,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,aAAa,CAAA;IACpB,gGAAgG;IAChG,MAAM,EAAE,MAAM,CAAA;IACd;;;;;OAKG;IACH,cAAc,EAAE,OAAO,CAAA;IACvB,6CAA6C;IAC7C,UAAU,EAAE,MAAM,CAAA;CACnB,CAAA;AAED,oEAAoE;AACpE,MAAM,MAAM,OAAO,GAAG;IACpB,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;IACT,EAAE,EAAE,QAAQ,CAAA;IACZ,UAAU,EAAE,MAAM,CAAA;CACnB,CAAA;AAED,iFAAiF;AACjF,MAAM,MAAM,WAAW,GAAG;IACxB,IAAI,EAAE,YAAY,GAAG,aAAa,GAAG,eAAe,CAAA;IACpD,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE,MAAM,CAAA;IAChB,OAAO,EAAE,MAAM,CAAA;CAChB,CAAA;AAED,MAAM,MAAM,iBAAiB,GAAG,YAAY,GAAG,gBAAgB,GAAG,sBAAsB,GAAG,cAAc,CAAA;AAEzG,MAAM,MAAM,YAAY,GAAG;IACzB;;;;;OAKG;IACH,EAAE,EAAE,MAAM,CAAA;IACV,iFAAiF;IACjF,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE,iBAAiB,CAAA;IAC3B;;;;;;;OAOG;IACH,KAAK,EAAE,KAAK,GAAG,aAAa,GAAG,IAAI,CAAA;IACnC,kFAAkF;IAClF,QAAQ,EAAE,OAAO,CAAA;IACjB,gBAAgB,EAAE;QAAE,OAAO,EAAE,QAAQ,CAAC;QAAC,IAAI,EAAE,QAAQ,CAAA;KAAE,CAAA;IACvD,OAAO,EAAE,MAAM,EAAE,CAAA;IACjB,QAAQ,EAAE,OAAO,EAAE,CAAA;CACpB,CAAA;AAED,qEAAqE;AACrE,MAAM,MAAM,oBAAoB,GAAG;IACjC;;;;;OAKG;IACH,MAAM,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAA;CAC1B,CAAA;AAED,MAAM,MAAM,YAAY,GAAG;IACzB,YAAY,EAAE,MAAM,CAAA;IACpB,KAAK,EAAE,MAAM,CAAA;IACb,WAAW,EAAE,MAAM,CAAA;IACnB,uFAAuF;IACvF,OAAO,EAAE,YAAY,EAAE,CAAA;IACvB,6FAA6F;IAC7F,QAAQ,EAAE,YAAY,EAAE,CAAA;IACxB,qFAAqF;IACrF,cAAc,EAAE,MAAM,EAAE,CAAA;IACxB,wDAAwD;IACxD,OAAO,EAAE,YAAY,EAAE,CAAA;IACvB,YAAY,EAAE,WAAW,EAAE,CAAA;CAC5B,CAAA;AAsCD,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,QAAQ,GAAG,MAAM,CAIrD;AAgJD,wBAAgB,aAAa,CAAC,KAAK,EAAE,UAAU,CAAC,OAAO,CAAC,EAAE,IAAI,CAAC,EAAE,oBAAoB,GAAG,YAAY,CAiDnG;AA4CD,MAAM,MAAM,eAAe,GAAG,KAAK,GAAG,MAAM,GAAG,OAAO,CAAA;AAEtD;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,YAAY,GAAG,MAAM,EAAE,CAanE"}
+{"version":3,"file":"gating.d.ts","sourceRoot":"","sources":["../../src/analysis/gating.ts"],"names":[],"mappings":"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"}

package/dist/combinators/case-fold.d.ts

@@ -0,0 +1,39 @@
+/**
+ * The case-fold CLASS of a code point under ECMAScript's NON-Unicode `/i`
+ * matching — the exact relation `keywords({ caseInsensitive: true })` compiles to.
+ *
+ * A first-set drives O(1) `choice` dispatch, so it MUST be a superset of every
+ * character the combinator can really start with. For a case-insensitive matcher
+ * that means: for every input char X that the matcher would accept as the first
+ * char, X is in the set. Under `/i` WITHOUT `u`, two chars match iff they share a
+ * canonical form, and that relation is NOT simply `{c, toUpperCase(c),
+ * toLowerCase(c)}` — 67 BMP code points sit in classes those three miss:
+ *
+ *   σ (U+03C3) ↔ Σ (U+03A3) ↔ ς (U+03C2)   final sigma is in the class but is
+ *                                            neither the upper- nor lowercase of σ
+ *   µ (U+00B5) ↔ μ (U+03BC) ↔ Μ (U+039C)   micro sign folds into Greek mu
+ *   DŽ (U+01C4) ↔ Dž (U+01C5) ↔ dž (U+01C6)   titlecase digraphs (also LJLjljNJNjnjDZDzdz)
+ *   ͅ (U+0345) ↔ ι (U+03B9) ↔ ι (U+1FBE)   combining iota subscript
+ *
+ * so widening a first-set by upper/lower alone is UNSOUND for them.
+ *
+ * The canonical form below is ECMAScript's `Canonicalize` for non-Unicode mode:
+ * uppercase the char; if that is not exactly one char, or if it would cross the
+ * ASCII boundary INTO Basic Latin, keep the original. That last clause is why
+ * `/s/i` does not match `ſ` (U+017F) and `/k/i` does not match `K` (U+212A) —
+ * cross-boundary folds are refused in BOTH directions, which is what keeps an
+ * ASCII first-set tight and sound for the common all-ASCII keyword set.
+ *
+ * The classes are derived from the RUNNING engine's own `toUpperCase`, not a
+ * frozen table, so they cannot drift from the regex engine that will do the
+ * matching. Verified exhaustively against real `/i` behaviour across the BMP:
+ * 1141 multi-member classes, 2307 members, zero disagreements in either
+ * direction (see `test/unit/case-fold.test.ts`).
+ */
+/**
+ * Every code point that a non-Unicode `/i` matcher treats as equal to `cp`,
+ * INCLUDING `cp` itself. Union these into a first-set to keep case-insensitive
+ * dispatch sound.
+ */
+export declare function caseFoldVariants(cp: number): readonly number[];
+//# sourceMappingURL=case-fold.d.ts.map

package/dist/combinators/case-fold.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"case-fold.d.ts","sourceRoot":"","sources":["../../src/combinators/case-fold.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAuCH;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,MAAM,GAAG,SAAS,MAAM,EAAE,CAc9D"}

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;AAGhG,YAAY,EAAE,UAAU,EAAE,CAAA;AAE1B;;;;;;;;;;;;;GAaG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,GAAG,MAAM,EAAE,CAsC/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,CA2B/F;AAED,+DAA+D;AAC/D,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,UAAU,CAEhE"}
+{"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;AAGhG,YAAY,EAAE,UAAU,EAAE,CAAA;AAE1B;;;;;;;;;;;;;GAaG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,GAAG,MAAM,EAAE,CAuC/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,CA2B/F;AAED,+DAA+D;AAC/D,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,UAAU,CAEhE"}

package/dist/combinators/first-set.d.ts

@@ -1,4 +1,17 @@
 import type { FirstSet, Combinator } from '../types.ts';
+/**
+ * Resolve a NAMED cross-artifact rule reference (`g.Foo`) whose own thunk does not
+ * resolve — the shared-shape hole, bound by name at fuse time.
+ *
+ * A shape module compiles `Ratio: sequence(g.Value, …)` without defining `Value`, so
+ * that `lazy`'s thunk throws and every first-set through it degrades to `any`. Once
+ * the shape is FUSED with a dialect that defines `Value`, the hole is bound — pass a
+ * resolver over the fused winner map and the first-set is the real one.
+ *
+ * Only NAMED refs are resolvable: an unnamed `ref()` that was never `.define()`d
+ * carries no name for anyone to bind, so it stays `any`.
+ */
+export type RefResolver = (name: string) => Combinator<unknown> | undefined;
 export declare function union(a: FirstSet, b: FirstSet): FirstSet;
 export declare function intersects(a: FirstSet, b: FirstSet): boolean;
 export declare function fromChar(code: number): FirstSet;
@@ -20,7 +33,7 @@ export declare function empty(): FirstSet;
  * set, which stays sound; under-estimating would drop valid start chars and make
  * first-char dispatch skip a matching arm.
  */
-export declare function matchesEmpty(p: Combinator<unknown>, seen?: Set<Combinator<unknown>>): boolean;
+export declare function matchesEmpty(p: Combinator<unknown>, seen?: Set<Combinator<unknown>>, resolve?: RefResolver): boolean;
 /**
  * A ZERO-WIDTH ASSERTION never consumes input, so it contributes NOTHING to a
  * sequence's first-set — the first consumed char comes from the following
@@ -33,17 +46,27 @@ export declare function matchesEmpty(p: Combinator<unknown>, seen?: Set<Combinat
  * widens the set of possible first chars beyond Y. So firstSet(Y) is a sound (and
  * tighter) superset.
  *
- * Parseman has NO positive-lookahead combinator (`(?=X)` exists only INSIDE a
- * `regex()` pattern, where the regex first-set analyzer handles it). If one is ever
- * added, its tight first-set is firstSet(body) ∩ firstSet(Y) when `body` is
- * NON-nullable (both must be satisfiable at the same position), else firstSet(Y)
- * (a nullable `(?=body)` succeeds on empty, so it imposes no first-char constraint
- * and intersecting would UNSOUNDLY exclude valid chars). It must NOT be added to
- * this predicate without that intersection logic — a future assertion combinator
- * left out of this set merely contributes its shallow `any` first-set, which stays
- * sound (over-approximation), only losing tightness.
+ * The POSITIVE lookahead `peek(X)` is zero-width too, but it is NOT in this
+ * predicate: unlike `not`, it knows what it requires, so its first-set is a real
+ * constraint that must be INTERSECTED into the sequence's set rather than dropped
+ * (see `isPositiveLookahead` and `sequenceFirstSet`).
  */
 export declare function isZeroWidthAssertion(p: Combinator<unknown>): boolean;
+/**
+ * A POSITIVE zero-width assertion (`peek(X)`). It consumes nothing, so like
+ * `not(X)` it does not contribute a first char of its own — but it does REQUIRE
+ * that X match here, so `peek(X) Y` can only start with a char in
+ * firstSet(X) ∩ firstSet(Y). That intersection is what makes a leading `peek()`
+ * gate its choice arm; `not(not(X))`, the only previous spelling, reports `any()`
+ * and poisons the dispatch instead.
+ *
+ * Soundness: first-sets are SUPERSETS of the true first chars, and
+ * (A ⊇ a) ∧ (B ⊇ b) ⇒ A ∩ B ⊇ a ∩ b — so intersecting stays a superset and can
+ * never skip a real match. A NULLABLE body succeeds on the empty string and
+ * therefore constrains nothing; `peek()` reports `any()` in that case, which the
+ * intersection treats as "no constraint".
+ */
+export declare function isPositiveLookahead(p: Combinator<unknown>): boolean;
 /**
  * First-set of a sequence: union each term's first-set through the NULLABLE
  * PREFIX — a leading `optional(…)` / `many(…)` / nullable term can be skipped, so
@@ -66,6 +89,10 @@ export declare function sequenceFirstSet(parsers: readonly Combinator<unknown>[]
  * SOUND ONLY where refs are FINAL (monolithic compile). Under compose OVERRIDE a
  * referenced rule can be replaced with a WIDER first-set, so a baked deep set
  * would wrongly skip valid input — the compose path defers dispatch to fuse time.
+ *
+ * `resolve` binds NAMED cross-artifact holes (`g.Foo`) against a fused winner map —
+ * see `RefResolver`. Diagnostic-only today: it is what lets the gating analysis ask
+ * the question at the site where the hole actually HAS an answer.
  */
-export declare function firstSetOf(p: Combinator<unknown>, seen?: Set<Combinator<unknown>>): FirstSet;
+export declare function firstSetOf(p: Combinator<unknown>, seen?: Set<Combinator<unknown>>, resolve?: RefResolver): FirstSet;
 //# sourceMappingURL=first-set.d.ts.map

package/dist/combinators/first-set.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"first-set.d.ts","sourceRoot":"","sources":["../../src/combinators/first-set.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAa,QAAQ,EAAE,UAAU,EAAa,MAAM,aAAa,CAAA;AAE7E,wBAAgB,KAAK,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,QAAQ,GAAG,QAAQ,CAKxD;AAED,wBAAgB,UAAU,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,QAAQ,GAAG,OAAO,CAS5D;AAED,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,QAAQ,CAE/C;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,UAAU,EAAE,UAAU,CAAC,OAAO,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAQnG;AAED,wBAAgB,SAAS,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,QAAQ,CAE1D;AAED,wBAAgB,GAAG,IAAI,QAAQ,CAE9B;AAED,wBAAgB,KAAK,IAAI,QAAQ,CAEhC;AAED;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,EAAE,IAAI,GAAE,GAAG,CAAC,UAAU,CAAC,OAAO,CAAC,CAAa,GAAG,OAAO,CAqCxG;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,GAAG,OAAO,CAEpE;AAED;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,SAAS,UAAU,CAAC,OAAO,CAAC,EAAE,GAAG,QAAQ,CAOlF;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,EAAE,IAAI,GAAE,GAAG,CAAC,UAAU,CAAC,OAAO,CAAC,CAAa,GAAG,QAAQ,CA2CvG"}
+{"version":3,"file":"first-set.d.ts","sourceRoot":"","sources":["../../src/combinators/first-set.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAa,QAAQ,EAAE,UAAU,EAAa,MAAM,aAAa,CAAA;AAE7E;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,WAAW,GAAG,CAAC,IAAI,EAAE,MAAM,KAAK,UAAU,CAAC,OAAO,CAAC,GAAG,SAAS,CAAA;AAS3E,wBAAgB,KAAK,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,QAAQ,GAAG,QAAQ,CAKxD;AAED,wBAAgB,UAAU,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,QAAQ,GAAG,OAAO,CAS5D;AAED,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,QAAQ,CAE/C;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,UAAU,EAAE,UAAU,CAAC,OAAO,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAQnG;AAED,wBAAgB,SAAS,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,QAAQ,CAE1D;AAED,wBAAgB,GAAG,IAAI,QAAQ,CAE9B;AAED,wBAAgB,KAAK,IAAI,QAAQ,CAEhC;AAED;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAC1B,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,EACtB,IAAI,GAAE,GAAG,CAAC,UAAU,CAAC,OAAO,CAAC,CAAa,EAC1C,OAAO,CAAC,EAAE,WAAW,GACpB,OAAO,CA6CT;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,GAAG,OAAO,CAEpE;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,GAAG,OAAO,CAEnE;AA6BD;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,SAAS,UAAU,CAAC,OAAO,CAAC,EAAE,GAAG,QAAQ,CAalF;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,UAAU,CACxB,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,EACtB,IAAI,GAAE,GAAG,CAAC,UAAU,CAAC,OAAO,CAAC,CAAa,EAC1C,OAAO,CAAC,EAAE,WAAW,GACpB,QAAQ,CAsDV"}

package/dist/combinators/keywords.d.ts

@@ -13,10 +13,19 @@ export type KeywordsOptions = {
  * matching `true` inside `trueish`. The boundary defaults to `_0-9A-Za-z`,
  * which covers most programming-language identifiers.
  *
- *   word('true')              // matches "true" but not "trueish"
- *   word('color', 'A-Za-z-') // CSS-style identifier boundary
+ *   word('true')                                    // matches "true" but not "trueish"
+ *   word('color', 'A-Za-z-')                        // CSS-style identifier boundary
+ *   word('media', 'A-Za-z0-9_-', { caseInsensitive: true })
+ *   word('media', { caseInsensitive: true })        // default boundary + options
+ *
+ * `caseInsensitive` matches `keywords()` and exists because it is REQUIRED, not a
+ * nicety: CSS at-keywords, function names and units are ASCII case-insensitive per
+ * spec (CSS Syntax §3). Without it the only conforming spellings were
+ * `regex(/media/i)` — which `analyzeGating` correctly flags as the `keyword-regex`
+ * anti-pattern — or `keywords(['media'], …)` for a single word.
  */
-export declare function word(str: string, boundary?: string): Combinator<string>;
+export declare function word(str: string, boundary?: string, opts?: Omit<KeywordsOptions, 'boundary'>): Combinator<string>;
+export declare function word(str: string, opts: Omit<KeywordsOptions, 'boundary'>): Combinator<string>;
 /**
  * Create a keyword factory with a fixed word-boundary class. Use when many
  * keywords share the same boundary (e.g. CSS identifiers). For a single keyword,

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

@@ -1 +1 @@
-{"version":3,"file":"keywords.d.ts","sourceRoot":"","sources":["../../src/combinators/keywords.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAmD,MAAM,aAAa,CAAA;AAK9F,MAAM,MAAM,eAAe,GAAG;IAC5B,gCAAgC;IAChC,eAAe,CAAC,EAAE,OAAO,CAAA;IACzB;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB,CAAA;AAED;;;;;;;GAOG;AACH,wBAAgB,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,SAAe,GAAG,UAAU,CAAC,MAAM,CAAC,CAE7E;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,QAAQ,CAAC,QAAQ,SAAe,GAAG,CAAC,GAAG,EAAE,MAAM,KAAK,UAAU,CAAC,MAAM,CAAC,CAErF;AAMD;;;;;;;;;GASG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,EAAE,IAAI,GAAE,eAAoB,GAAG,UAAU,CAAC,MAAM,CAAC,CA0CjG"}
+{"version":3,"file":"keywords.d.ts","sourceRoot":"","sources":["../../src/combinators/keywords.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAmD,MAAM,aAAa,CAAA;AAM9F,MAAM,MAAM,eAAe,GAAG;IAC5B,gCAAgC;IAChC,eAAe,CAAC,EAAE,OAAO,CAAA;IACzB;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB,CAAA;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,IAAI,CAAC,eAAe,EAAE,UAAU,CAAC,GAAG,UAAU,CAAC,MAAM,CAAC,CAAA;AAClH,wBAAgB,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,CAAC,eAAe,EAAE,UAAU,CAAC,GAAG,UAAU,CAAC,MAAM,CAAC,CAAA;AAW9F;;;;;;;;;;;GAWG;AACH,wBAAgB,QAAQ,CAAC,QAAQ,SAAe,GAAG,CAAC,GAAG,EAAE,MAAM,KAAK,UAAU,CAAC,MAAM,CAAC,CAErF;AAMD;;;;;;;;;GASG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,EAAE,IAAI,GAAE,eAAoB,GAAG,UAAU,CAAC,MAAM,CAAC,CA8DjG"}

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

@@ -1 +1 @@
-{"version":3,"file":"not.d.ts","sourceRoot":"","sources":["../../src/combinators/not.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAyC,MAAM,aAAa,CAAA;AAIpF;;;;;;;;;GASG;AACH,wBAAgB,GAAG,CAAC,UAAU,EAAE,UAAU,CAAC,OAAO,CAAC,GAAG,UAAU,CAAC,IAAI,CAAC,CA0BrE"}
+{"version":3,"file":"not.d.ts","sourceRoot":"","sources":["../../src/combinators/not.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAyC,MAAM,aAAa,CAAA;AAIpF;;;;;;;;;GASG;AACH,wBAAgB,GAAG,CAAC,UAAU,EAAE,UAAU,CAAC,OAAO,CAAC,GAAG,UAAU,CAAC,IAAI,CAAC,CAwCrE"}

package/dist/combinators/peek.d.ts

@@ -0,0 +1,27 @@
+import type { Combinator } from '../types.ts';
+/**
+ * Positive lookahead. Succeeds (consuming nothing) when `combinator` matches at
+ * this position; fails when it doesn't. The mirror of `not()`.
+ *
+ *   // "a mixin reference, not a class selector": require the punctuation ahead,
+ *   // then let the real production consume it.
+ *   const mixinRef = sequence(peek(regex(/[.#]/)), mixinCall)
+ *
+ * WHY THIS EXISTS AS A PRIMITIVE (not `not(not(X))`):
+ *
+ * `not(not(X))` is behaviourally a positive lookahead, but `not()` reports
+ * `firstSet: any()` — it cannot know what it forbids — so `not(not(X))` reports
+ * `any()` too. An arm leading with it therefore POISONS its choice's first-char
+ * dispatch (`analyzeGating` flags it as the `double-not` anti-pattern), and among
+ * sibling arms that share a first char the hand-rolled gate miscompiles.
+ *
+ * `peek(X)` carries X's first-set instead, so a leading `peek()` GATES its arm:
+ * `choice(sequence(peek(regex(/[.#]/)), …), …)` still emits O(1) dispatch.
+ *
+ * The first-set is exact only when X is NON-NULLABLE. A nullable `peek(X)`
+ * succeeds on the empty string, so it constrains no first character at all — it
+ * reports `any()`, the sound over-approximation. (Same rule the sequence
+ * first-set uses; see `isPositiveLookahead` in `first-set.ts`.)
+ */
+export declare function peek(combinator: Combinator<unknown>): Combinator<null>;
+//# sourceMappingURL=peek.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"peek.d.ts","sourceRoot":"","sources":["../../src/combinators/peek.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAyC,MAAM,aAAa,CAAA;AAIpF;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,IAAI,CAAC,UAAU,EAAE,UAAU,CAAC,OAAO,CAAC,GAAG,UAAU,CAAC,IAAI,CAAC,CAkCtE"}

package/dist/combinators/repeat.d.ts

@@ -1,6 +1,71 @@
 import type { Combinator } from '../types.ts';
-export declare function many<T>(combinator: Combinator<T>): Combinator<T[]>;
-export declare function oneOrMore<T>(combinator: Combinator<T>): Combinator<T[]>;
+export type RepeatOptions = {
+    /**
+     * Minimum number of ITEMS. Default `0`.
+     *
+     * `min >= 1` is not a validation nicety — it is what makes the combinator
+     * NON-NULLABLE. A nullable arm matches at every position, which disables its
+     * `choice`'s first-char dispatch by parseman's own first-set rule; a `min >= 1`
+     * repeat keeps the item's first-set, so an arm led by it still gates.
+     */
+    min?: number;
+    /** Maximum number of ITEMS. Default: unbounded. Never affects nullability. */
+    max?: number;
+};
+/**
+ * Repetition: `item*` by default, bounded by `{ min, max }` (both count ITEMS).
+ *
+ *   many(g.Decl)                       // zero or more — NULLABLE
+ *   many(g.Decl, { min: 1 })           // one or more  — same as oneOrMore(g.Decl)
+ *   many(g.HexDigit, { min: 3, max: 8 })
+ *
+ * `oneOrMore(x)` is kept as the sugar for the common `{ min: 1 }` case.
+ */
+export declare function many<T>(combinator: Combinator<T>, opts?: RepeatOptions): Combinator<T[]>;
+/**
+ * Sugar for the commonest bound: `many(combinator, { min: 1 })` — the identical
+ * combinator, not merely an equivalent one.
+ */
+export declare function oneOrMore<T>(combinator: Combinator<T>, opts?: RepeatOptions): Combinator<T[]>;
 export declare function optional<T>(combinator: Combinator<T>): Combinator<T | null>;
-export declare function sepBy<T, S>(combinator: Combinator<T>, separator: Combinator<S>): Combinator<T[]>;
+/**
+ * Non-empty separated list — `oneOrMore`'s relationship to `many`, for separated
+ * lists. `oneOrMoreSep(item, sep)` is exactly `sepBy(item, sep, { min: 1 })`.
+ *
+ *   oneOrMoreSep(g.Selector, literal(','))   // a selector list is never empty
+ *
+ * REACH FOR THIS, NOT `sepBy`, for any list that cannot actually be empty —
+ * selector lists, value lists, media-query preludes, keyframe selectors. `sepBy`'s
+ * min-0 default matches the EMPTY STRING, which makes it nullable, and a nullable
+ * arm disables its `choice`'s first-char dispatch by parseman's own first-set
+ * rule. This form is non-nullable and keeps the item's first-set, so an arm led by
+ * it still gates.
+ */
+export declare function oneOrMoreSep<T, S>(combinator: Combinator<T>, separator: Combinator<S>, opts?: SepByOptions): Combinator<T[]>;
+/** How a separator with NO item after it is treated. */
+export type TrailingSeparator = 
+/**
+ * DEFAULT, and what `sepBy` has always done: the trailing separator is NOT
+ * consumed — the list ends before it and the enclosing grammar sees it. (It is
+ * not an error here; "forbid" means the list refuses to own it.)
+ */
+'forbid'
+/** Consume a trailing separator when present (`a, b,` → 2 items, comma eaten). */
+ | 'allow';
+export type SepByOptions = RepeatOptions & {
+    /** What to do with a separator that has no item after it. Default `'forbid'`. */
+    trailing?: TrailingSeparator;
+};
+/**
+ * Separated list: `(item (sep item)*)?` by default — note that it MATCHES THE
+ * EMPTY STRING, which makes it nullable and therefore un-gateable as a choice arm.
+ * For a list that cannot be empty reach for `oneOrMoreSep`, or pass `{ min: 1 }`.
+ *
+ *   sepBy(g.Value, literal(','))                  // may be empty — NULLABLE
+ *   oneOrMoreSep(g.Selector, literal(','))        // non-empty — gates as a choice arm
+ *   sepBy(g.Decl, literal(';'), { trailing: 'allow' })
+ *
+ * `min`/`max` count ITEMS, not separators.
+ */
+export declare function sepBy<T, S>(combinator: Combinator<T>, separator: Combinator<S>, opts?: SepByOptions): Combinator<T[]>;
 //# sourceMappingURL=repeat.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"repeat.d.ts","sourceRoot":"","sources":["../../src/combinators/repeat.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAyC,MAAM,aAAa,CAAA;AAqEpF,wBAAgB,IAAI,CAAC,CAAC,EAAE,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC,CAAC,EAAE,CAAC,CAkDlE;AAED,wBAAgB,SAAS,CAAC,CAAC,EAAE,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC,CAAC,EAAE,CAAC,CA8CvE;AAED,wBAAgB,QAAQ,CAAC,CAAC,EAAE,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC,CAAC,GAAG,IAAI,CAAC,CAwB3E;AAED,wBAAgB,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC,CAAC,EAAE,CAAC,CAwFhG"}
+{"version":3,"file":"repeat.d.ts","sourceRoot":"","sources":["../../src/combinators/repeat.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAyC,MAAM,aAAa,CAAA;AAqEpF,MAAM,MAAM,aAAa,GAAG;IAC1B;;;;;;;OAOG;IACH,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,8EAA8E;IAC9E,GAAG,CAAC,EAAE,MAAM,CAAA;CACb,CAAA;AAcD;;;;;;;;GAQG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC,EAAE,IAAI,GAAE,aAAkB,GAAG,UAAU,CAAC,CAAC,EAAE,CAAC,CA6D5F;AAED;;;GAGG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC,EAAE,IAAI,GAAE,aAAkB,GAAG,UAAU,CAAC,CAAC,EAAE,CAAC,CAEjG;AA6ED,wBAAgB,QAAQ,CAAC,CAAC,EAAE,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC,CAAC,GAAG,IAAI,CAAC,CAwB3E;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,CAAC,EAAE,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,UAAU,CAAC,CAAC,CAAC,EAAE,IAAI,GAAE,YAAiB,GAAG,UAAU,CAAC,CAAC,EAAE,CAAC,CAEhI;AAED,wDAAwD;AACxD,MAAM,MAAM,iBAAiB;AAC3B;;;;GAIG;AACD,QAAQ;AACV,kFAAkF;GAChF,OAAO,CAAA;AAEX,MAAM,MAAM,YAAY,GAAG,aAAa,GAAG;IACzC,iFAAiF;IACjF,QAAQ,CAAC,EAAE,iBAAiB,CAAA;CAC7B,CAAA;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,UAAU,CAAC,CAAC,CAAC,EAAE,IAAI,GAAE,YAAiB,GAAG,UAAU,CAAC,CAAC,EAAE,CAAC,CAoJzH"}

package/dist/combinators/trivia-skip.d.ts

@@ -1,4 +1,4 @@
-import type { ParseContext } from '../types.ts';
+import type { ParseContext, ParseFail } from '../types.ts';
 /**
  * Result of scanning trivia: the position after it, plus a `commit()` that
  * records the matched trivia tokens into the active rawChildren collector.
@@ -23,6 +23,28 @@ export type TriviaRollbackMark = {
 export declare function needsDeferredTriviaCommit(ctx: ParseContext): boolean;
 export declare function saveTriviaMark(ctx: ParseContext): TriviaRollbackMark;
 export declare function rollbackTrivia(ctx: ParseContext, mark: TriviaRollbackMark): void;
+/**
+ * A ZERO-WIDTH LOOKAHEAD's mark: everything `saveTriviaMark` covers, plus the
+ * completions probe's current best failure.
+ *
+ * `_probe` is a sink like any other — `failAt` (probe.ts) replaces
+ * `ctx._probe.best` whenever a failure lands at or before the cursor — but it is
+ * deliberately NOT part of `rollbackTrivia`, because most rollbacks must leave it
+ * alone. A failed `choice` arm or `sequence` term SHOULD keep its contribution:
+ * merging the expectations of alternatives that failed at the cursor is exactly
+ * how `completionsAt` builds its set.
+ *
+ * A lookahead is the exception. `peek`/`not` consume nothing on EITHER outcome
+ * and promise to leave no observable trace, so expectations raised INSIDE the
+ * probe are not reachable from the enclosing grammar at the cursor:
+ * `peek(sequence(literal('a'), literal('zzz')))` over `"ab"` offered `"zzz"` as
+ * the ONLY completion, though no input can ever reach it there.
+ */
+export type LookaheadMark = TriviaRollbackMark & {
+    probeBest: ParseFail | null;
+};
+export declare function saveLookaheadMark(ctx: ParseContext): LookaheadMark;
+export declare function rollbackLookahead(ctx: ParseContext, mark: LookaheadMark): void;
 /**
  * Skip trivia at `cur` and return the new position. No recording, no wrapper
  * object — use between sequence/repeat terms when CST trivia capture is off.

package/dist/combinators/trivia-skip.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"trivia-skip.d.ts","sourceRoot":"","sources":["../../src/combinators/trivia-skip.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAc,YAAY,EAAE,MAAM,aAAa,CAAA;AAe3D;;;;;;GAMG;AACH,MAAM,MAAM,UAAU,GAAG;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,IAAI,CAAA;CAAE,CAAA;AAE5D,iEAAiE;AACjE,MAAM,MAAM,kBAAkB,GAAG;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAAA;AAM3H,oFAAoF;AACpF,wBAAgB,yBAAyB,CAAC,GAAG,EAAE,YAAY,GAAG,OAAO,CAEpE;AAED,wBAAgB,cAAc,CAAC,GAAG,EAAE,YAAY,GAAG,kBAAkB,CAGpE;AAED,wBAAgB,cAAc,CAAC,GAAG,EAAE,YAAY,EAAE,IAAI,EAAE,kBAAkB,GAAG,IAAI,CAGhF;AAiBD;;;GAGG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,YAAY,GAAG,MAAM,CAWnF;AAED;;;GAGG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,YAAY,GAAG,UAAU,CAkCpF;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,YAAY,GAAG,MAAM,CAKnF"}
+{"version":3,"file":"trivia-skip.d.ts","sourceRoot":"","sources":["../../src/combinators/trivia-skip.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAc,YAAY,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAetE;;;;;;GAMG;AACH,MAAM,MAAM,UAAU,GAAG;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,IAAI,CAAA;CAAE,CAAA;AAE5D,iEAAiE;AACjE,MAAM,MAAM,kBAAkB,GAAG;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAAA;AAM3H,oFAAoF;AACpF,wBAAgB,yBAAyB,CAAC,GAAG,EAAE,YAAY,GAAG,OAAO,CAEpE;AAED,wBAAgB,cAAc,CAAC,GAAG,EAAE,YAAY,GAAG,kBAAkB,CAGpE;AAED,wBAAgB,cAAc,CAAC,GAAG,EAAE,YAAY,EAAE,IAAI,EAAE,kBAAkB,GAAG,IAAI,CAGhF;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,MAAM,aAAa,GAAG,kBAAkB,GAAG;IAAE,SAAS,EAAE,SAAS,GAAG,IAAI,CAAA;CAAE,CAAA;AAEhF,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,YAAY,GAAG,aAAa,CAElE;AAED,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,YAAY,EAAE,IAAI,EAAE,aAAa,GAAG,IAAI,CAG9E;AAiBD;;;GAGG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,YAAY,GAAG,MAAM,CAWnF;AAED;;;GAGG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,YAAY,GAAG,UAAU,CAkCpF;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,YAAY,GAAG,MAAM,CAKnF"}

package/dist/compiler/codegen.d.ts

@@ -128,7 +128,33 @@ export declare function ruleDependencies(ruleMap: ReadonlyArray<readonly [string
 export type GatingOption = GatingWarnLevel | {
     level?: GatingWarnLevel;
     accept?: Iterable<string>;
+    entryName?: string;
 };
+/**
+ * The FUSE-time form of the diagnostic — the only site where a shared shape's
+ * `g.Foo` hole has an answer.
+ *
+ * A shape module (`rules(g => ({ Term: choice(sequence(g.Value, …), …) }))`) cannot
+ * decide whether `Term` gates: `g.Value` is unbound there, so its first-set reads
+ * `any`. `analyzeGatingRules` marks such a choice `deferred` rather than `ungated` —
+ * warning about it would describe a configuration that never runs, and its author
+ * has nothing to fix. This runs the SAME analysis over the fused winner map, where
+ * `Value` is bound, and reports what the binding actually produced.
+ *
+ * Threading `gating` into the per-piece `compileLinkable` calls would NOT do this:
+ * each piece is lowered alone, so the hole is still unbound and the shape's own false
+ * positive is simply re-emitted. Resolution needs the MERGED map.
+ *
+ * Reports ONLY choices their authoring site deferred (the local, resolver-free pass
+ * names them). That is what keeps an ordinary hole-free grammar from being warned
+ * about twice — once by `compileRuleMap` and again by every `compose()` that fuses
+ * it. Anti-patterns are structural and already reported at the authoring site, so
+ * they are dropped here for the same reason.
+ *
+ * The rule maps arrive as a THUNK because producing them costs a re-hydration of the
+ * carried IR: `gating: 'off'` must not pay for a diagnostic it will not print.
+ */
+export declare function runFusedGatingDiagnostic(getRuleMaps: () => ReadonlyArray<ReadonlyArray<readonly [string, Combinator<unknown>]>>, opt?: GatingOption): GatingReport | undefined;
 export declare function compile<T>(combinator: Combinator<T>, mapFnSources?: string[], opts?: {
     recovery?: boolean;
     coverage?: boolean;
@@ -139,6 +165,7 @@ export declare function compileRuleMap(ruleMap: ReadonlyArray<readonly [string,
     scanSkip?: Combinator<unknown>[];
     recovery?: boolean;
     coverage?: boolean;
+    gating?: GatingOption;
 }): {
     keys: string[];
     replacement: string;
@@ -219,5 +246,18 @@ export declare function compileLinkable(ruleMapArg: ReadonlyArray<readonly [stri
     recovery?: boolean;
     captureTerminals?: boolean;
     coverage?: GrammarCoveragePlan;
+    gating?: GatingOption;
 }): LinkablePieces | null;
+/**
+ * Does this rule map reference a rule it doesn't define — a NAMED `ref` (`g.Foo`)
+ * that never got `.define()`d? That is the SHARED-SHAPE signature: the grammar is a
+ * shape with a hole, so it can't be inlined as a standalone parser, but it IS
+ * linkable (`compileLinkable` emits a by-name `_r_Foo` call for the hole, bound at
+ * fuse time). Callers use this to tell that case apart from a genuine
+ * "couldn't compile, fall back to the interpreter".
+ *
+ * A `rules()` map's own `Object.entries` also leaks accessed-but-undefined names as
+ * top-level entries, so both the entry values AND their bodies are scanned.
+ */
+export declare function hasExternalRuleRef(ruleMap: ReadonlyArray<readonly [string, Combinator<unknown>]>): boolean;
 //# 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,EAAa,QAAQ,EAAE,WAAW,EAAE,YAAY,EAAE,UAAU,EAA4B,MAAM,aAAa,CAAA;AAKnI,OAAO,EAAuC,KAAK,YAAY,EAAE,KAAK,eAAe,EAAE,MAAM,uBAAuB,CAAA;AAEpH;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAOH,MAAM,MAAM,WAAW,GAAG;IAAE,GAAG,EAAE,QAAQ,CAAC;IAAC,QAAQ,EAAE,OAAO,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAA;CAAE,CAAA;AAC5E,MAAM,MAAM,cAAc,GAAG;IAAE,IAAI,EAAE,WAAW,EAAE,EAAE,CAAA;CAAE,CAAA;AACtD,wBAAgB,qBAAqB,CAAC,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,EAAE,IAAI,GAAE,GAAG,CAAC,UAAU,CAAC,OAAO,CAAC,CAAa,GAAG,cAAc,CA4FxH;AAGD,OAAO,EAAoB,KAAK,mBAAmB,EAAE,MAAM,2BAA2B,CAAA;AAsBtF;;;;;;;;GAQG;AACH,eAAO,MAAM,eAAe,uTAC0R,CAAA;AActT,8EAA8E;AAC9E,wBAAgB,oBAAoB,IAAI,IAAI,CAE3C;AAED,+EAA+E;AAC/E,wBAAgB,kBAAkB,IAAI,MAAM,EAAE,CAI7C;AAogBD,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,EAAE,QAAQ,GAAG,MAAM,CAQlE;AAcD,wBAAgB,oBAAoB,CAAC,EAAE,EAAE,OAAO,GAAG,IAAI,CAA0B;AAMjF,wBAAgB,wBAAwB,CAAC,EAAE,EAAE,OAAO,GAAG,IAAI,CAA8B;AAmiFzF,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;;;;;OAKG;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;IAC/B,4DAA4D;IAC5D,mBAAmB,CAAC,EAAE,SAAS,OAAO,2BAA2B,EAAE,yBAAyB,EAAE,CAAA;IAC9F;;;;;;OAMG;IACH,MAAM,CAAC,EAAE,YAAY,CAAA;CACtB,CAAA;AAuPD;;;;;;;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;;;;;GAKG;AACH;;;;GAIG;AACH,MAAM,MAAM,YAAY,GAAG,eAAe,GAAG;IAAE,KAAK,CAAC,EAAE,eAAe,CAAC;IAAC,MAAM,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAA;CAAE,CAAA;AAiCnG,wBAAgB,OAAO,CAAC,CAAC,EAAE,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC,EAAE,YAAY,CAAC,EAAE,MAAM,EAAE,EAAE,IAAI,CAAC,EAAE;IAAE,QAAQ,CAAC,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;IAAC,MAAM,CAAC,EAAE,YAAY,CAAA;CAAE,GAAG,cAAc,CAAC,CAAC,CAAC,CA+I1K;AAsDD,wBAAgB,cAAc,CAC5B,OAAO,EAAE,aAAa,CAAC,SAAS,CAAC,MAAM,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC,EAC9D,IAAI,CAAC,EAAE;IAAE,MAAM,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC;IAAC,QAAQ,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,EAAE,CAAC;IAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;CAAE,GAChH;IAAE,IAAI,EAAE,MAAM,EAAE,CAAC;IAAC,WAAW,EAAE,MAAM,CAAC;IAAC,mBAAmB,CAAC,EAAE,SAAS,OAAO,2BAA2B,EAAE,yBAAyB,EAAE,CAAA;CAAE,GAAG,IAAI,CAoJhJ;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B;;;;;;OAMG;IACH,CAAC,EAAE,MAAM,CAAA;IACT,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;;;;OAIG;IACH,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAA;IAChC;;;;;;OAMG;IACH,QAAQ,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC/B;;;;;;OAMG;IACH,eAAe,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,cAAc,CAAC,CAAA;IAC7C,IAAI,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAA;IAC3B,YAAY,EAAE,OAAO,CAAA;IACrB,cAAc,EAAE,OAAO,CAAA;IACvB,6EAA6E;IAC7E,iBAAiB,CAAC,EAAE,OAAO,CAAA;IAC3B,mFAAmF;IACnF,iBAAiB,CAAC,EAAE,OAAO,CAAA;IAC3B;;;;;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;AAGD,wBAAgB,eAAe,CAC7B,UAAU,EAAE,aAAa,CAAC,SAAS,CAAC,MAAM,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC,EACjE,EAAE,EAAE,MAAM,EACV,IAAI,CAAC,EAAE;IAAE,MAAM,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC;IAAC,QAAQ,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,EAAE,CAAC;IAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;IAAC,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,EAAE,mBAAmB,CAAA;CAAE,GACxJ,cAAc,GAAG,IAAI,CA2NvB"}
+{"version":3,"file":"codegen.d.ts","sourceRoot":"","sources":["../../src/compiler/codegen.ts"],"names":[],"mappings":"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"}

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

@@ -1 +1 @@
-{"version":3,"file":"fields.d.ts","sourceRoot":"","sources":["../../src/compiler/fields.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAGlE,KAAK,OAAO,GAAG,OAAO,CAAC,SAAS,EAAE;IAAE,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC,CAAA;AAElD,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAMtD;AAED,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,EAAE,IAAI,GAAE,GAAG,CAAC,UAAU,CAAC,OAAO,CAAC,CAAa,GAAG,OAAO,CAiC9G;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,EAAE,IAAI,GAAE,GAAG,CAAC,UAAU,CAAC,OAAO,CAAC,CAAa,GAAG,OAAO,CA0C/G;AAED;;;;;GAKG;AACH,wBAAgB,0BAA0B,CAAC,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,EAAE,IAAI,GAAE,GAAG,CAAC,UAAU,CAAC,OAAO,CAAC,CAAa,GAAG,OAAO,CAiCtH;AAED,wBAAgB,aAAa,CAAC,QAAQ,EAAE,aAAa,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,OAAO,CAAC;IAAC,IAAI,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,CAAA;CAAE,CAAC,GAAG,SAAS,GAAG,QAAQ,GAAG,SAAS,CAW/J"}
+{"version":3,"file":"fields.d.ts","sourceRoot":"","sources":["../../src/compiler/fields.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAGlE,KAAK,OAAO,GAAG,OAAO,CAAC,SAAS,EAAE;IAAE,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC,CAAA;AAElD,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAMtD;AAED,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,EAAE,IAAI,GAAE,GAAG,CAAC,UAAU,CAAC,OAAO,CAAC,CAAa,GAAG,OAAO,CAkC9G;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,EAAE,IAAI,GAAE,GAAG,CAAC,UAAU,CAAC,OAAO,CAAC,CAAa,GAAG,OAAO,CA2C/G;AAED;;;;;GAKG;AACH,wBAAgB,0BAA0B,CAAC,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,EAAE,IAAI,GAAE,GAAG,CAAC,UAAU,CAAC,OAAO,CAAC,CAAa,GAAG,OAAO,CAkCtH;AAED,wBAAgB,aAAa,CAAC,QAAQ,EAAE,aAAa,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,OAAO,CAAC;IAAC,IAAI,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,CAAA;CAAE,CAAC,GAAG,SAAS,GAAG,QAAQ,GAAG,SAAS,CAW/J"}

package/dist/compiler/ir-serialize.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ir-serialize.d.ts","sourceRoot":"","sources":["../../src/compiler/ir-serialize.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,KAAK,EAAE,UAAU,EAAa,MAAM,aAAa,CAAA;AAmBxD,KAAK,IAAI,GAAG,UAAU,CAAC,OAAO,CAAC,CAAA;AA8C/B,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,aAAa,CAAC,SAAS,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC,EAC/C,QAAQ,CAAC,EAAE,SAAS,IAAI,EAAE,GAAG,IAAI,GAChC,MAAM,GAAG,IAAI,CAUf;AAED;;oFAEoF;AACpF,wBAAgB,aAAa,CAAC,EAAE,EAAE,MAAM,GAAG,KAAK,CAAC,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC,CAqG/D"}
+{"version":3,"file":"ir-serialize.d.ts","sourceRoot":"","sources":["../../src/compiler/ir-serialize.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,KAAK,EAAE,UAAU,EAAa,MAAM,aAAa,CAAA;AAoBxD,KAAK,IAAI,GAAG,UAAU,CAAC,OAAO,CAAC,CAAA;AAwD/B,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,aAAa,CAAC,SAAS,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC,EAC/C,QAAQ,CAAC,EAAE,SAAS,IAAI,EAAE,GAAG,IAAI,GAChC,MAAM,GAAG,IAAI,CAUf;AAED;;oFAEoF;AACpF,wBAAgB,aAAa,CAAC,EAAE,EAAE,MAAM,GAAG,KAAK,CAAC,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC,CAqG/D"}

package/dist/compiler/linker.d.ts

@@ -77,6 +77,11 @@ export type IRPiece = {
     ns: string;
     ir: string;
 };
+/** The re-lowerable carried pieces' rule maps, in compose order — the input to the
+ * fuse-time gating diagnostic. An opaque precompiled artifact contributes no
+ * combinator graph, so it is simply skipped: a hole it would have bound stays
+ * unresolved and its choice stays deferred (silent), never falsely warned. */
+export declare function carriedRuleMaps(carried: ReadonlyArray<LinkablePieces | IRPiece>): Array<Array<[string, Combinator<unknown>]>>;
 /** Return the final override-winner combinator map carried by runtime
  * `compose()`, or `undefined` when a precompiled opaque artifact participated.
  * This is intentionally internal: callers must not treat it as a parser API. */

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

@@ -1 +1 @@
-{"version":3,"file":"linker.d.ts","sourceRoot":"","sources":["../../src/compiler/linker.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"linker.d.ts","sourceRoot":"","sources":["../../src/compiler/linker.ts"],"names":[],"mappings":"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"}

package/dist/compiler/value-usage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"value-usage.d.ts","sourceRoot":"","sources":["../../src/compiler/value-usage.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAa,MAAM,aAAa,CAAA;AAExD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,UAAU,CAAC,OAAO,CAAC,GAAG,IAAI,CAkHhE"}
+{"version":3,"file":"value-usage.d.ts","sourceRoot":"","sources":["../../src/compiler/value-usage.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAa,MAAM,aAAa,CAAA;AAExD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,UAAU,CAAC,OAAO,CAAC,GAAG,IAAI,CAmHhE"}

package/dist/coverage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"coverage.d.ts","sourceRoot":"","sources":["../src/coverage.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"coverage.d.ts","sourceRoot":"","sources":["../src/coverage.ts"],"names":[],"mappings":"AAAA,OAAO,EAAO,KAAK,UAAU,EAAE,KAAK,SAAS,EAAE,KAAK,QAAQ,EAAE,MAAM,qBAAqB,CAAA;AACzF,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAe,MAAM,YAAY,CAAA;AAkBvE,OAAO,EAAoB,KAAK,yBAAyB,EAA4B,MAAM,oCAAoC,CAAA;AAE/H,YAAY,EAAE,yBAAyB,EAAE,MAAM,oCAAoC,CAAA;AAGnF,MAAM,MAAM,uBAAuB,GAAG;IACpC,WAAW,EAAE,SAAS,yBAAyB,EAAE,CAAA;IACjD,IAAI,EAAE,SAAS,MAAM,EAAE,CAAA;IACvB,KAAK,EAAE,SAAS,MAAM,EAAE,CAAA;IACxB,KAAK,EAAE,MAAM,CAAA;CACd,CAAA;AAED,MAAM,MAAM,wBAAwB,GAAG;IACrC,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAAA;IACrB,QAAQ,IAAI,uBAAuB,CAAA;IACnC,KAAK,IAAI,IAAI,CAAA;CACd,CAAA;AAED;;2DAE2D;AAC3D,eAAO,MAAM,4BAA4B,EAAE,MAA0D,CAAA;AAErG,wBAAgB,kCAAkC,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,yBAAyB,EAAE,CAUzH;AAED,MAAM,MAAM,iBAAiB,GAAG,OAAO,GAAG,SAAS,GAAG,UAAU,GAAG,SAAS,GAAG,SAAS,GAAG,WAAW,GAAG,UAAU,CAAA;AACnH,MAAM,MAAM,iBAAiB,GAAG;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,iBAAiB,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAA;CAAE,CAAA;AACtG,MAAM,MAAM,oBAAoB,GAAG;IAAE,MAAM,EAAE,SAAS,iBAAiB,EAAE,CAAC;IAAC,SAAS,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAA;AAChH,MAAM,MAAM,gBAAgB,GAAG;IAAE,KAAK,CAAC,KAAK,EAAE,iBAAiB,GAAG,IAAI,CAAC;IAAC,QAAQ,IAAI,oBAAoB,CAAA;CAAE,CAAA;AAC1G,+EAA+E;AAC/E,MAAM,MAAM,6BAA6B,GAAG,YAAY,GAAG;IACzD,gBAAgB,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,IAAI,CAAA;IACvC,aAAa,CAAC,EAAE,gBAAgB,CAAA;CACjC,CAAA;AAED,8EAA8E;AAC9E,wBAAgB,mCAAmC,CAAC,OAAO,GAAE;IAC3D,SAAS,CAAC,EAAE,wBAAwB,CAAA;IACpC,KAAK,CAAC,EAAE,gBAAgB,CAAA;IACxB,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,KAAK,CAAC,EAAE,OAAO,CAAA;CACX,GAAG,6BAA6B,CAOrC;AAED;mEACmE;AACnE,wBAAgB,sBAAsB,CAAC,OAAO,EAAE;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,CAAC,KAAK,EAAE,iBAAiB,KAAK,OAAO,GAAG,IAAI,CAAA;CAAE,GAAG,gBAAgB,CAkB5I;AAED,wBAAgB,8BAA8B,CAAC,WAAW,EAAE,SAAS,yBAAyB,EAAE,GAAG,wBAAwB,CAa1H;AAED,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,UAAU,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC,GAAG,SAAS,yBAAyB,EAAE,CAE1J;AAED;;8EAE8E;AAC9E,wBAAgB,kCAAkC,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,SAAS,EAAE,MAAM,GAAG,SAAS,yBAAyB,EAAE,CAM5I;AA4JD,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,GAAE,UAAU,GAAG;IAAE,SAAS,CAAC,EAAE,wBAAwB,CAAC;IAAC,KAAK,CAAC,EAAE,gBAAgB,CAAA;CAAO,GAAG;IAAE,MAAM,EAAE,SAAS,CAAC;IAAC,QAAQ,EAAE,uBAAuB,CAAA;CAAE,CAO9N"}