@kernlang/core 3.4.2 → 3.4.3-canary.11.1.8a8b6d69

package/dist/native-eligibility-ast.js

@@ -0,0 +1,189 @@
+/** Native KERN handler-body AST eligibility — slice α-3.
+ *
+ *  Replaces slice 5a's regex pre-screen (in `native-eligibility.ts`) with a
+ *  TS-AST walk that mirrors the migrator's `mapStatement` rules in
+ *  `packages/cli/src/commands/migrate-native-handlers.ts`. After this slice,
+ *  the diagnostic and the migrator agree by construction:
+ *
+ *      classifyHandlerBodyAst(body).eligible === true
+ *      ⟺ kern migrate native-handlers will emit a `lang="kern"` rewrite for it.
+ *
+ *  Why this matters: the slice 5a regex disagreed with the migrator's deeper
+ *  TS-AST shape check on ~34% of "eligible" bodies (agon scan, 2026-05-04).
+ *  Promoting the diagnostic from `info` to `warn` at that disagreement rate
+ *  would surface fix-or-suppress noise on bodies the migrator silently bails
+ *  on — exactly the no-unused-vars trust-collapse pattern. AST agreement is
+ *  the prerequisite for the future warn promotion.
+ *
+ *  The reason strings here are deliberately specific (e.g. `var-destructure`,
+ *  `try-finally`, `expr-stmt-mutation`) so users running
+ *  `kern migrate native-handlers` and `kern review` see actionable hints
+ *  instead of a generic "ineligible". */
+import ts from 'typescript';
+import { parseExpression } from './parser-expression.js';
+/** True when `exprText` parses cleanly under KERN's parser-expression. The
+ *  multi-line guard catches body-statement attributes (`value="…"`) where
+ *  raw newlines would break the line shape.
+ *
+ *  Exported so the migrator (`migrate-native-handlers.ts`) shares the
+ *  same predicate the classifier uses — slice α-3 gemini review pulled
+ *  the formerly duplicated helper into core to prevent the migrator's
+ *  bail conditions from drifting away from the classifier's pass
+ *  conditions. */
+export function isValidKernExpression(exprText) {
+    if (/\n/.test(exprText))
+        return false;
+    try {
+        parseExpression(exprText);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** True when `bodyText` contains any line or block comment. The migrator
+ *  drops comments silently on rewrite, so a body containing them is
+ *  ineligible — preserving the comment is the user's responsibility.
+ *  Exported (slice α-3 gemini review) so the migrator imports the same
+ *  scanner predicate and comment-detection cannot diverge between the
+ *  two sides. */
+export function hasComments(bodyText) {
+    const scanner = ts.createScanner(ts.ScriptTarget.Latest, /*skipTrivia*/ false);
+    scanner.setText(bodyText);
+    while (true) {
+        const kind = scanner.scan();
+        if (kind === ts.SyntaxKind.EndOfFileToken)
+            return false;
+        if (kind === ts.SyntaxKind.SingleLineCommentTrivia || kind === ts.SyntaxKind.MultiLineCommentTrivia)
+            return true;
+    }
+}
+/** Classify a single statement. Returns null if the migrator can emit it,
+ *  otherwise a kebab-case reason. Recurses through if/try branches. */
+function classifyStmt(stmt, sf) {
+    if (ts.isVariableStatement(stmt)) {
+        const flags = stmt.declarationList.flags;
+        if (!(flags & ts.NodeFlags.Const))
+            return 'var-non-const';
+        const decls = stmt.declarationList.declarations;
+        if (decls.length !== 1)
+            return 'var-multi-decl';
+        const decl = decls[0];
+        if (!ts.isIdentifier(decl.name))
+            return 'var-destructure';
+        if (!decl.initializer)
+            return 'var-no-init';
+        if (decl.type)
+            return 'var-typed';
+        if (!isValidKernExpression(decl.initializer.getText(sf)))
+            return 'var-bad-expr';
+        return null;
+    }
+    if (ts.isReturnStatement(stmt)) {
+        if (!stmt.expression)
+            return null;
+        if (!isValidKernExpression(stmt.expression.getText(sf)))
+            return 'return-bad-expr';
+        return null;
+    }
+    if (ts.isThrowStatement(stmt)) {
+        if (!stmt.expression)
+            return 'throw-no-expr';
+        if (!isValidKernExpression(stmt.expression.getText(sf)))
+            return 'throw-bad-expr';
+        return null;
+    }
+    if (ts.isIfStatement(stmt)) {
+        if (!isValidKernExpression(stmt.expression.getText(sf)))
+            return 'if-bad-cond';
+        const thenReason = classifyBranch(stmt.thenStatement, sf);
+        if (thenReason !== null)
+            return thenReason;
+        if (stmt.elseStatement) {
+            // `else if (…)` is a nested IfStatement here. The migrator's mapIf
+            // recurses for it, and the body emitters (TS + Python) collapse the
+            // resulting `else > if` shape back to `else if` / `elif` (commit
+            // 88c06dcc on dev). classifyBranch handles the nested IfStatement
+            // by re-entering classifyStmt, so the recursion is automatic.
+            const elseReason = classifyBranch(stmt.elseStatement, sf);
+            if (elseReason !== null)
+                return elseReason;
+        }
+        return null;
+    }
+    if (ts.isTryStatement(stmt)) {
+        if (!stmt.catchClause)
+            return 'try-no-catch';
+        if (stmt.finallyBlock)
+            return 'try-finally';
+        const cc = stmt.catchClause;
+        if (cc.variableDeclaration && !ts.isIdentifier(cc.variableDeclaration.name))
+            return 'try-destruct-catch';
+        const tryReason = classifyBranch(stmt.tryBlock, sf);
+        if (tryReason !== null)
+            return tryReason;
+        return classifyBranch(cc.block, sf);
+    }
+    if (ts.isExpressionStatement(stmt)) {
+        // Slice α-1: ExpressionStatement → `do value="…"`. Reject mutation
+        // (assignments, ++, --) here so the classifier matches what the migrator
+        // emits — the migrator has the same defensive guards.
+        if (ts.isBinaryExpression(stmt.expression)) {
+            const op = stmt.expression.operatorToken.kind;
+            if (op >= ts.SyntaxKind.FirstAssignment && op <= ts.SyntaxKind.LastAssignment)
+                return 'expr-stmt-assignment';
+        }
+        if (ts.isPostfixUnaryExpression(stmt.expression) || ts.isPrefixUnaryExpression(stmt.expression)) {
+            const op = stmt.expression.operator;
+            if (op === ts.SyntaxKind.PlusPlusToken || op === ts.SyntaxKind.MinusMinusToken)
+                return 'expr-stmt-mutation';
+        }
+        if (!isValidKernExpression(stmt.expression.getText(sf)))
+            return 'expr-stmt-bad-expr';
+        return null;
+    }
+    if (ts.isForStatement(stmt) || ts.isForOfStatement(stmt) || ts.isForInStatement(stmt))
+        return 'for-stmt';
+    if (ts.isWhileStatement(stmt) || ts.isDoStatement(stmt))
+        return 'while-do-stmt';
+    if (ts.isSwitchStatement(stmt))
+        return 'switch-stmt';
+    if (ts.isBlock(stmt))
+        return 'bare-block';
+    // Fallback — the TS SyntaxKind name surfaces in diagnostics so users have
+    // a starting point when they hit something exotic (label, with, debugger).
+    return `unsupported-stmt-${ts.SyntaxKind[stmt.kind]}`;
+}
+function classifyBranch(node, sf) {
+    const stmts = ts.isBlock(node) ? Array.from(node.statements) : [node];
+    for (const s of stmts) {
+        const r = classifyStmt(s, sf);
+        if (r !== null)
+            return r;
+    }
+    return null;
+}
+/** Classify a raw `<<<…>>>` handler body — the AST-aware replacement for
+ *  the slice 5a regex pass. Returns `eligible: true` only if every top-level
+ *  statement (and every nested if/try branch) maps to a body-statement form
+ *  the migrator can emit. */
+export function classifyHandlerBodyAst(rawBody) {
+    const trimmed = rawBody.trim();
+    if (trimmed === '')
+        return { eligible: true, reason: 'empty' };
+    if (hasComments(rawBody))
+        return { eligible: false, reason: 'comments-present' };
+    const sf = ts.createSourceFile('__handler.ts', rawBody, ts.ScriptTarget.Latest, true);
+    // ts.SourceFile carries `parseDiagnostics` despite not exposing it on the
+    // public type — the migrator reads it the same way.
+    const diags = sf.parseDiagnostics;
+    if (diags && diags.length > 0)
+        return { eligible: false, reason: 'ts-parse-error' };
+    for (const stmt of sf.statements) {
+        const r = classifyStmt(stmt, sf);
+        if (r !== null)
+            return { eligible: false, reason: r };
+    }
+    return { eligible: true, reason: 'ok' };
+}
+//# sourceMappingURL=native-eligibility-ast.js.map

package/dist/native-eligibility-ast.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"native-eligibility-ast.js","sourceRoot":"","sources":["../src/native-eligibility-ast.ts"],"names":[],"mappings":"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"}

package/dist/native-eligibility.d.ts

@@ -1,33 +1,37 @@
-/** Native KERN handler body eligibility classifier — slice 5a foundation.
+/** Native KERN handler body eligibility classifier — slice 5a foundation
+ *  (slice α-3 update: delegates to the AST walker in
+ *  `native-eligibility-ast.ts`; slice α-4: diagnostic surfaces at `warning`).
  *
  *  Given a raw `<<<...>>>` handler body, determines whether it could compile
  *  under `lang="kern"` opt-in WITHOUT manual rewrite. Used by:
  *
- *    1. The compiler diagnostic layer (parser-validate-propagation siblings)
- *       to surface `info`-level hints suggesting opt-in.
- *    2. The future `kern migrate native-handlers` CLI (slice 5b) to bulk-convert.
+ *    1. The compiler diagnostic layer (`parser-validate-native-eligible.ts`)
+ *       to surface `warning`-level `NATIVE_KERN_ELIGIBLE` hints suggesting opt-in.
+ *    2. The `kern migrate native-handlers` CLI (slice 5b) to bulk-convert.
  *    3. Empirical scans of real-world repos (e.g. Agon-AI) to measure the
  *       practical adoption ceiling for native bodies.
  *
- *  The classifier is INTENTIONALLY HEURISTIC — full eligibility requires the
- *  type-aware AST walk that slice 5b's rewriter performs. False positives here
- *  surface as compile errors when the user opts in; false negatives just
- *  deflate the suggestion rate. We err toward false negatives so the
- *  diagnostic stays trustworthy ("if I see this hint, opting in WILL work").
+ *  Slice α-3: replaced the regex pre-screen with a TS-AST walk that mirrors
+ *  the migrator's `mapStatement` rules. Eligibility now equals migrate-success
+ *  by construction — the prerequisite for slice α-4's promotion of
+ *  `NATIVE_KERN_ELIGIBLE` from `info` to `warning` without producing
+ *  fix-or-suppress noise on bodies the migrator silently bails on.
  *
- *  Slice 4d update: removed `try` / `catch` / `throw` / `finally`, `new`
- *  keyword, and `??` walrus from the disqualifier list — those landed in
- *  slice 4c+4d ship. Object spread is allowed; argument spread (`f(...x)`)
- *  is still gated since slice 4d only lowered the object-literal form.
+ *  The legacy regex disqualifier set lives at `LEGACY_NEG_PATTERNS` for
+ *  consumers that need a fast pre-filter (no TS parse). The canonical
+ *  classifier (`classifyHandlerBody`) uses the AST walker.
  */
 /** Result of classifying a single handler body. */
 export interface EligibilityResult {
     /** True iff the body uses ONLY syntactic patterns that lang=kern supports. */
     eligible: boolean;
-    /** When eligible: 'empty' (whitespace-only body) or 'no-disqualifier'.
-     *  When ineligible: the source of the matching disqualifier regex (e.g.
-     *  '\\bfor\\s*\\('). Surfaces in diagnostics + migrate reports so users
-     *  can see what's blocking. */
+    /** When eligible: `'empty'` (whitespace-only body) or `'ok'` (passed AST walk).
+     *  When ineligible: a kebab-case slug naming the first blocking shape —
+     *  e.g. `'var-destructure'`, `'try-finally'`, `'expr-stmt-mutation'`,
+     *  `'comments-present'`, `'ts-parse-error'`. See
+     *  `native-eligibility-ast.ts` for the full set. The legacy regex source
+     *  (e.g. `'\\bfor\\s*\\('`) is no longer surfaced — older callers that
+     *  switched on the regex string need to migrate to the new slugs. */
     reason: string;
 }
 /** A raw `<<<…>>>` handler body extracted from a `.kern` source file,
@@ -48,7 +52,14 @@ export interface FileEligibilityReport {
      *  as the bodies returned by `extractRawBodies(content)`. */
     bodies: Array<RawBody & EligibilityResult>;
 }
-/** Classify a single raw body. */
+/** Slice α-3: legacy regex disqualifier set. Kept exported for fast
+ *  pre-filtering (no TS parse) in tools that don't need precise reasons —
+ *  e.g. histogram scanners that only want a coarse "ineligible" signal.
+ *  The canonical classifier (`classifyHandlerBody`) no longer uses this set;
+ *  it delegates to the AST walker in `native-eligibility-ast.ts`. */
+export declare const LEGACY_NEG_PATTERNS: ReadonlyArray<RegExp>;
+/** Classify a single raw body. Slice α-3: delegates to the AST walker so
+ *  eligibility ≡ migrate-success by construction. */
 export declare function classifyHandlerBody(rawBody: string): EligibilityResult;
 /** Walk a `.kern` source file's text and pull out every `<<< … >>>` body,
  *  preserving line positions. Mirrors the behaviour of `parser-core.ts`

package/dist/native-eligibility.js

@@ -1,29 +1,33 @@
-/** Native KERN handler body eligibility classifier — slice 5a foundation.
+/** Native KERN handler body eligibility classifier — slice 5a foundation
+ *  (slice α-3 update: delegates to the AST walker in
+ *  `native-eligibility-ast.ts`; slice α-4: diagnostic surfaces at `warning`).
  *
  *  Given a raw `<<<...>>>` handler body, determines whether it could compile
  *  under `lang="kern"` opt-in WITHOUT manual rewrite. Used by:
  *
- *    1. The compiler diagnostic layer (parser-validate-propagation siblings)
- *       to surface `info`-level hints suggesting opt-in.
- *    2. The future `kern migrate native-handlers` CLI (slice 5b) to bulk-convert.
+ *    1. The compiler diagnostic layer (`parser-validate-native-eligible.ts`)
+ *       to surface `warning`-level `NATIVE_KERN_ELIGIBLE` hints suggesting opt-in.
+ *    2. The `kern migrate native-handlers` CLI (slice 5b) to bulk-convert.
  *    3. Empirical scans of real-world repos (e.g. Agon-AI) to measure the
  *       practical adoption ceiling for native bodies.
  *
- *  The classifier is INTENTIONALLY HEURISTIC — full eligibility requires the
- *  type-aware AST walk that slice 5b's rewriter performs. False positives here
- *  surface as compile errors when the user opts in; false negatives just
- *  deflate the suggestion rate. We err toward false negatives so the
- *  diagnostic stays trustworthy ("if I see this hint, opting in WILL work").
+ *  Slice α-3: replaced the regex pre-screen with a TS-AST walk that mirrors
+ *  the migrator's `mapStatement` rules. Eligibility now equals migrate-success
+ *  by construction — the prerequisite for slice α-4's promotion of
+ *  `NATIVE_KERN_ELIGIBLE` from `info` to `warning` without producing
+ *  fix-or-suppress noise on bodies the migrator silently bails on.
  *
- *  Slice 4d update: removed `try` / `catch` / `throw` / `finally`, `new`
- *  keyword, and `??` walrus from the disqualifier list — those landed in
- *  slice 4c+4d ship. Object spread is allowed; argument spread (`f(...x)`)
- *  is still gated since slice 4d only lowered the object-literal form.
+ *  The legacy regex disqualifier set lives at `LEGACY_NEG_PATTERNS` for
+ *  consumers that need a fast pre-filter (no TS parse). The canonical
+ *  classifier (`classifyHandlerBody`) uses the AST walker.
  */
-/** Patterns that disqualify a raw JS-like body from compiling under
- *  `lang="kern"` without manual rewrite. Order doesn't affect correctness
- *  but the first match wins and is reported as the `reason`. */
-const NEG_PATTERNS = [
+import { classifyHandlerBodyAst } from './native-eligibility-ast.js';
+/** Slice α-3: legacy regex disqualifier set. Kept exported for fast
+ *  pre-filtering (no TS parse) in tools that don't need precise reasons —
+ *  e.g. histogram scanners that only want a coarse "ineligible" signal.
+ *  The canonical classifier (`classifyHandlerBody`) no longer uses this set;
+ *  it delegates to the AST walker in `native-eligibility-ast.ts`. */
+export const LEGACY_NEG_PATTERNS = [
     /=>/,
     /\bfunction\b/,
     /\bclass\s+\w/,
@@ -73,16 +77,10 @@ const NEG_PATTERNS = [
     /\(\s*\.{3}/,
     /\/\w+\/[gimsy]*/,
 ];
-/** Classify a single raw body. */
+/** Classify a single raw body. Slice α-3: delegates to the AST walker so
+ *  eligibility ≡ migrate-success by construction. */
 export function classifyHandlerBody(rawBody) {
-    const trimmed = rawBody.trim();
-    if (trimmed === '')
-        return { eligible: true, reason: 'empty' };
-    for (const pat of NEG_PATTERNS) {
-        if (pat.test(rawBody))
-            return { eligible: false, reason: pat.source };
-    }
-    return { eligible: true, reason: 'no-disqualifier' };
+    return classifyHandlerBodyAst(rawBody);
 }
 /** Walk a `.kern` source file's text and pull out every `<<< … >>>` body,
  *  preserving line positions. Mirrors the behaviour of `parser-core.ts`

package/dist/native-eligibility.js.map

@@ -1 +1 @@
-{"version":3,"file":"native-eligibility.js","sourceRoot":"","sources":["../src/native-eligibility.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAiCH;;gEAEgE;AAChE,MAAM,YAAY,GAA0B;IAC1C,IAAI;IACJ,cAAc;IACd,cAAc;IACd,WAAW;IACX,YAAY;IACZ,cAAc;IACd,WAAW;IACX,eAAe;IACf,YAAY;IACZ,gBAAgB;IAChB,eAAe;IACf,aAAa;IACb,8EAA8E;IAC9E,2EAA2E;IAC3E,mEAAmE;IACnE,4BAA4B;IAC5B,yEAAyE;IACzE,0EAA0E;IAC1E,wEAAwE;IACxE,wEAAwE;IACxE,6EAA6E;IAC7E,SAAS;IACT,WAAW;IACX,uCAAuC;IACvC,mBAAmB;IACnB,YAAY;IACZ,2EAA2E;IAC3E,wEAAwE;IACxE,wEAAwE;IACxE,mEAAmE;IACnE,0EAA0E;IAC1E,UAAU;IACV,0DAA0D;IAC1D,UAAU;IACV,cAAc;IACd,aAAa;IACb,aAAa;IACb,iBAAiB;IACjB,eAAe;IACf,eAAe;IACf,YAAY;IACZ,gBAAgB;IAChB,WAAW;IACX,WAAW;IACX,UAAU;IACV,YAAY;IACZ,YAAY;IACZ,iBAAiB;CAClB,CAAC;AAEF,kCAAkC;AAClC,MAAM,UAAU,mBAAmB,CAAC,OAAe;IACjD,MAAM,OAAO,GAAG,OAAO,CAAC,IAAI,EAAE,CAAC;IAC/B,IAAI,OAAO,KAAK,EAAE;QAAE,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC;IAC/D,KAAK,MAAM,GAAG,IAAI,YAAY,EAAE,CAAC;QAC/B,IAAI,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC;YAAE,OAAO,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,CAAC;IACxE,CAAC;IACD,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,EAAE,iBAAiB,EAAE,CAAC;AACvD,CAAC;AAED;;;;;;;;;;;0EAW0E;AAC1E,MAAM,UAAU,gBAAgB,CAAC,OAAe;IAC9C,MAAM,MAAM,GAAc,EAAE,CAAC;IAC7B,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IAClC,IAAI,MAAM,GAAG,KAAK,CAAC;IACnB,IAAI,GAAG,GAAa,EAAE,CAAC;IACvB,IAAI,SAAS,GAAG,CAAC,CAAC;IAElB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACtC,MAAM,IAAI,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;QACtB,IAAI,CAAC,MAAM,EAAE,CAAC;YACZ,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;YACpC,IAAI,OAAO,KAAK,CAAC,CAAC;gBAAE,SAAS;YAC7B,MAAM,SAAS,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,GAAG,CAAC,CAAC,CAAC;YAC1C,MAAM,QAAQ,GAAG,SAAS,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;YAC1C,IAAI,QAAQ,KAAK,CAAC,CAAC,EAAE,CAAC;gBACpB,sDAAsD;gBACtD,MAAM,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,SAAS,CAAC,KAAK,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC,IAAI,EAAE,EAAE,SAAS,EAAE,CAAC,GAAG,CAAC,EAAE,OAAO,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;gBAC7F,SAAS;YACX,CAAC;YACD,oEAAoE;YACpE,sEAAsE;YACtE,qEAAqE;YACrE,iEAAiE;YACjE,MAAM,GAAG,IAAI,CAAC;YACd,GAAG,GAAG,EAAE,CAAC;YACT,SAAS,GAAG,CAAC,GAAG,CAAC,CAAC;QACpB,CAAC;aAAM,CAAC;YACN,MAAM,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;YACrC,IAAI,QAAQ,KAAK,CAAC,CAAC,EAAE,CAAC;gBACpB,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;gBACf,SAAS;YACX,CAAC;YACD,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC,IAAI,EAAE,CAAC;YAC9C,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC;gBAAE,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;YACxC,MAAM,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,SAAS,EAAE,OAAO,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;YACjE,MAAM,GAAG,KAAK,CAAC;QACjB,CAAC;IACH,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;;0BAE0B;AAC1B,MAAM,UAAU,sBAAsB,CAAC,OAAe;IACpD,MAAM,GAAG,GAAG,gBAAgB,CAAC,OAAO,CAAC,CAAC;IACtC,IAAI,cAAc,GAAG,CAAC,CAAC;IACvB,MAAM,MAAM,GAAG,GAAG,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE;QAC9B,MAAM,MAAM,GAAG,mBAAmB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAC9C,IAAI,MAAM,CAAC,QAAQ;YAAE,cAAc,EAAE,CAAC;QACtC,OAAO,EAAE,GAAG,IAAI,EAAE,GAAG,MAAM,EAAE,CAAC;IAChC,CAAC,CAAC,CAAC;IACH,OAAO,EAAE,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,cAAc,EAAE,MAAM,EAAE,CAAC;AAC7D,CAAC"}
+{"version":3,"file":"native-eligibility.js","sourceRoot":"","sources":["../src/native-eligibility.ts"],"names":[],"mappings":"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"}

package/dist/parser-expression.d.ts

@@ -8,8 +8,10 @@
  *  spec, `none` is the canonical empty-value form in `lang=kern` bodies; `null` is
  *  retained for legacy/round-trip compatibility.
  *
- *  Intentionally NOT yet supported: arithmetic, comparisons, ternary, indexing,
- *  bitwise, assignment. Those land in a later slice. */
+ *  Slice 2c added arithmetic and comparisons; slice α-2 added ternary
+ *  `a ? b : c`. Still NOT supported: indexing (`xs[0]`), bitwise ops,
+ *  assignment — these would require shape changes the body emitter
+ *  doesn't have, so the parser deliberately rejects them. */
 import type { ValueIR } from './value-ir.js';
 export type ExprTokenKind = 'ident' | 'num' | 'str' | 'tmplStart' | 'dot' | 'optDot' | 'nullish' | 'or' | 'and' | 'lparen' | 'rparen' | 'lbrace' | 'rbrace' | 'lbracket' | 'rbracket' | 'colon' | 'comma' | 'spread' | 'qmark' | 'eq' | 'neq' | 'strictEq' | 'strictNeq' | 'bang' | 'lt' | 'lte' | 'gt' | 'gte' | 'plus' | 'minus' | 'star' | 'slash' | 'percent' | 'kwNull' | 'kwUndef' | 'kwTrue' | 'kwFalse' | 'kwAwait' | 'kwNew' | 'eof';
 export interface ExprToken {

package/dist/parser-expression.js

@@ -8,8 +8,39 @@
  *  spec, `none` is the canonical empty-value form in `lang=kern` bodies; `null` is
  *  retained for legacy/round-trip compatibility.
  *
- *  Intentionally NOT yet supported: arithmetic, comparisons, ternary, indexing,
- *  bitwise, assignment. Those land in a later slice. */
+ *  Slice 2c added arithmetic and comparisons; slice α-2 added ternary
+ *  `a ? b : c`. Still NOT supported: indexing (`xs[0]`), bitwise ops,
+ *  assignment — these would require shape changes the body emitter
+ *  doesn't have, so the parser deliberately rejects them. */
+/** Slice α-2: token kinds that can start an expression. Used by parsePostfix
+ *  and the await branch of parseUnary to disambiguate postfix `?`
+ *  (propagation) from ternary `?` (which is always followed by an expression).
+ *  If the token AFTER `?` is in this set, the `?` belongs to the outer
+ *  ternary (parseConditional); otherwise, it's propagation.
+ *
+ *  `plus` is not in the set — KERN's parseUnary doesn't accept unary `+`.
+ *  `kwNew` isn't in the set — `new` is matched by parseUnary as an `ident`
+ *  token with value `'new'`. */
+const EXPR_START_KINDS = new Set([
+    'ident',
+    'num',
+    'str',
+    'tmplStart',
+    'kwTrue',
+    'kwFalse',
+    'kwNull',
+    'kwUndef',
+    'kwAwait',
+    'lparen',
+    'lbrace',
+    'lbracket',
+    'spread',
+    'bang',
+    'minus',
+]);
+function isExprStartKind(kind) {
+    return EXPR_START_KINDS.has(kind);
+}
 const KEYWORDS = {
     null: 'kwNull',
     none: 'kwNull',
@@ -356,13 +387,37 @@ class Parser {
         return this.advance();
     }
     parse() {
-        const result = this.parseNullish();
+        const result = this.parseConditional();
         if (this.peek().kind !== 'eof') {
             const t = this.peek();
             throw new Error(`Unexpected token ${t.kind} ('${t.value}') at column ${t.pos + 1}`);
         }
         return result;
     }
+    // Slice α-2: ternary `test ? consequent : alternate`. Right-associative —
+    // `a ? b : c ? d : e` parses as `a ? b : (c ? d : e)`. Lower precedence
+    // than `??`/`||`/`&&`/binary ops, so it wraps `parseNullish`.
+    //
+    // Disambiguation with propagation `?`: parsePostfix and the await branch
+    // of parseUnary both consume a postfix `?` when the next token is NOT an
+    // expression-start. So when this method sees `?` at the top, it's
+    // unambiguously a ternary `?` (the next token MUST be an expression-start
+    // — otherwise parsePostfix would have consumed the `?` as propagation).
+    parseConditional() {
+        const test = this.parseNullish();
+        if (this.peek().kind !== 'qmark')
+            return test;
+        if (!isExprStartKind(this.peek(1).kind)) {
+            // Defensive: shouldn't happen given the parsePostfix lookahead rule.
+            const t = this.peek();
+            throw new Error(`Unexpected '?' at column ${t.pos + 1}. Postfix '?' (propagation) is recognized inside expressions; ternary '?' must be followed by an expression then ':'.`);
+        }
+        this.advance(); // consume `?`
+        const consequent = this.parseConditional();
+        this.expect('colon');
+        const alternate = this.parseConditional();
+        return { kind: 'conditional', test, consequent, alternate };
+    }
     parseNullish() {
         let left = this.parseOr();
         while (this.peek().kind === 'nullish') {
@@ -463,7 +518,10 @@ class Parser {
             // instead of the semantically-correct `propagate(await(call()))`.
             const argument = this.parseCall();
             const awaited = { kind: 'await', argument };
-            if (this.peek().kind === 'qmark') {
+            // Slice α-2: only consume postfix `?` as propagation if the token
+            // after it is NOT an expression-start. Otherwise leave it for the
+            // outer parseConditional (ternary).
+            if (this.peek().kind === 'qmark' && !isExprStartKind(this.peek(1).kind)) {
                 this.advance();
                 return { kind: 'propagate', argument: awaited, op: '?' };
             }
@@ -481,7 +539,10 @@ class Parser {
     }
     parsePostfix() {
         const node = this.parseCall();
-        if (this.peek().kind === 'qmark') {
+        // Slice α-2: only consume postfix `?` as propagation if the token after
+        // it is NOT an expression-start. Otherwise leave it for the outer
+        // parseConditional (ternary).
+        if (this.peek().kind === 'qmark' && !isExprStartKind(this.peek(1).kind)) {
             this.advance();
             return { kind: 'propagate', argument: node, op: '?' };
         }
@@ -526,10 +587,10 @@ class Parser {
         const args = [];
         if (this.peek().kind === 'rparen')
             return args;
-        args.push(this.parseNullish());
+        args.push(this.parseConditional());
         while (this.peek().kind === 'comma') {
             this.advance();
-            args.push(this.parseNullish());
+            args.push(this.parseConditional());
         }
         return args;
     }
@@ -566,7 +627,7 @@ class Parser {
                 return { kind: 'undefLit' };
             case 'lparen': {
                 this.advance();
-                const inner = this.parseNullish();
+                const inner = this.parseConditional();
                 this.expect('rparen');
                 return inner;
             }
@@ -595,7 +656,7 @@ class Parser {
             const keyTok = this.peek();
             if (keyTok.kind === 'spread') {
                 this.advance();
-                const argument = this.parseNullish();
+                const argument = this.parseConditional();
                 entries.push({ kind: 'spread', argument });
             }
             else {
@@ -623,7 +684,7 @@ class Parser {
                 }
                 else {
                     this.expect('colon');
-                    const value = this.parseNullish();
+                    const value = this.parseConditional();
                     entries.push({ key, value });
                 }
             }
@@ -647,7 +708,7 @@ class Parser {
             return { kind: 'arrayLit', items };
         }
         while (true) {
-            items.push(this.parseNullish());
+            items.push(this.parseConditional());
             if (this.peek().kind === 'comma') {
                 this.advance();
                 if (this.peek().kind === 'rbracket')