@kernlang/core 4.0.0 → 4.0.1-canary.224.1.1a92ac0a

package/dist/assignment-operators-ts.d.ts

@@ -0,0 +1,12 @@
+/** Slice 0.9 — TypeScript-AST helper split out of `assignment-operators.ts`.
+ *
+ *  `supportedCompoundAssignmentOperator` maps a `ts.SyntaxKind` token to a KERN
+ *  compound-assignment operator. It is the ONLY assignment-operator helper that
+ *  depends on `typescript`, so it lives here (the Node/codegen side) rather than
+ *  in `assignment-operators.ts`. That keeps `assignment-operators.ts` — and the
+ *  `@kernlang/core` barrel that re-exports its string predicates — free of the
+ *  `typescript` import (R1 barrel-isolation). Reachable only via the Node subpath
+ *  (`@kernlang/core/node`) or direct module import. */
+import ts from 'typescript';
+import type { SupportedAssignOperator } from './generated/utils/assignment-operators.js';
+export declare function supportedCompoundAssignmentOperator(kind: ts.SyntaxKind): SupportedAssignOperator | null;

package/dist/assignment-operators-ts.js

@@ -0,0 +1,39 @@
+/** Slice 0.9 — TypeScript-AST helper split out of `assignment-operators.ts`.
+ *
+ *  `supportedCompoundAssignmentOperator` maps a `ts.SyntaxKind` token to a KERN
+ *  compound-assignment operator. It is the ONLY assignment-operator helper that
+ *  depends on `typescript`, so it lives here (the Node/codegen side) rather than
+ *  in `assignment-operators.ts`. That keeps `assignment-operators.ts` — and the
+ *  `@kernlang/core` barrel that re-exports its string predicates — free of the
+ *  `typescript` import (R1 barrel-isolation). Reachable only via the Node subpath
+ *  (`@kernlang/core/node`) or direct module import. */
+import ts from 'typescript';
+export function supportedCompoundAssignmentOperator(kind) {
+    switch (kind) {
+        case ts.SyntaxKind.PlusEqualsToken:
+            return '+=';
+        case ts.SyntaxKind.MinusEqualsToken:
+            return '-=';
+        case ts.SyntaxKind.AsteriskEqualsToken:
+            return '*=';
+        case ts.SyntaxKind.SlashEqualsToken:
+            return '/=';
+        case ts.SyntaxKind.PercentEqualsToken:
+            return '%=';
+        case ts.SyntaxKind.AsteriskAsteriskEqualsToken:
+            return '**=';
+        case ts.SyntaxKind.AmpersandEqualsToken:
+            return '&=';
+        case ts.SyntaxKind.BarEqualsToken:
+            return '|=';
+        case ts.SyntaxKind.CaretEqualsToken:
+            return '^=';
+        case ts.SyntaxKind.LessThanLessThanEqualsToken:
+            return '<<=';
+        case ts.SyntaxKind.GreaterThanGreaterThanEqualsToken:
+            return '>>=';
+        default:
+            return null;
+    }
+}
+//# sourceMappingURL=assignment-operators-ts.js.map

package/dist/assignment-operators-ts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"assignment-operators-ts.js","sourceRoot":"","sources":["../src/assignment-operators-ts.ts"],"names":[],"mappings":"AAAA;;;;;;;;uDAQuD;AAEvD,OAAO,EAAE,MAAM,YAAY,CAAC;AAG5B,MAAM,UAAU,mCAAmC,CAAC,IAAmB;IACrE,QAAQ,IAAI,EAAE,CAAC;QACb,KAAK,EAAE,CAAC,UAAU,CAAC,eAAe;YAChC,OAAO,IAAI,CAAC;QACd,KAAK,EAAE,CAAC,UAAU,CAAC,gBAAgB;YACjC,OAAO,IAAI,CAAC;QACd,KAAK,EAAE,CAAC,UAAU,CAAC,mBAAmB;YACpC,OAAO,IAAI,CAAC;QACd,KAAK,EAAE,CAAC,UAAU,CAAC,gBAAgB;YACjC,OAAO,IAAI,CAAC;QACd,KAAK,EAAE,CAAC,UAAU,CAAC,kBAAkB;YACnC,OAAO,IAAI,CAAC;QACd,KAAK,EAAE,CAAC,UAAU,CAAC,2BAA2B;YAC5C,OAAO,KAAK,CAAC;QACf,KAAK,EAAE,CAAC,UAAU,CAAC,oBAAoB;YACrC,OAAO,IAAI,CAAC;QACd,KAAK,EAAE,CAAC,UAAU,CAAC,cAAc;YAC/B,OAAO,IAAI,CAAC;QACd,KAAK,EAAE,CAAC,UAAU,CAAC,gBAAgB;YACjC,OAAO,IAAI,CAAC;QACd,KAAK,EAAE,CAAC,UAAU,CAAC,2BAA2B;YAC5C,OAAO,KAAK,CAAC;QACf,KAAK,EAAE,CAAC,UAAU,CAAC,iCAAiC;YAClD,OAAO,KAAK,CAAC;QACf;YACE,OAAO,IAAI,CAAC;IAChB,CAAC;AACH,CAAC"}

package/dist/assignment-operators.d.ts

@@ -1,7 +1,5 @@
-import ts from 'typescript';
 import type { PostfixMutationOperator, SupportedAssignOperator } from './generated/utils/assignment-operators.js';
 export type { PostfixMutationOperator, SupportedAssignOperator, } from './generated/utils/assignment-operators.js';
 export declare const SUPPORTED_ASSIGN_OPERATORS: readonly SupportedAssignOperator[];
 export declare function isSupportedAssignOperator(op: string): op is SupportedAssignOperator;
 export declare function isPostfixMutationOperator(op: string): op is PostfixMutationOperator;
-export declare function supportedCompoundAssignmentOperator(kind: ts.SyntaxKind): SupportedAssignOperator | null;

package/dist/assignment-operators.js

@@ -1,5 +1,3 @@
-// Facade. Source of truth: packages/core/src/kern/utils/assignment-operators.kern.
-import ts from 'typescript';
 import { SUPPORTED_ASSIGN_OPERATORS as GENERATED_SUPPORTED_ASSIGN_OPERATORS, isPostfixMutationOperator as isGeneratedPostfixMutationOperator, isSupportedAssignOperator as isGeneratedSupportedAssignOperator, } from './generated/utils/assignment-operators.js';
 export const SUPPORTED_ASSIGN_OPERATORS = GENERATED_SUPPORTED_ASSIGN_OPERATORS;
 export function isSupportedAssignOperator(op) {
@@ -8,32 +6,4 @@ export function isSupportedAssignOperator(op) {
 export function isPostfixMutationOperator(op) {
     return isGeneratedPostfixMutationOperator(op);
 }
-export function supportedCompoundAssignmentOperator(kind) {
-    switch (kind) {
-        case ts.SyntaxKind.PlusEqualsToken:
-            return '+=';
-        case ts.SyntaxKind.MinusEqualsToken:
-            return '-=';
-        case ts.SyntaxKind.AsteriskEqualsToken:
-            return '*=';
-        case ts.SyntaxKind.SlashEqualsToken:
-            return '/=';
-        case ts.SyntaxKind.PercentEqualsToken:
-            return '%=';
-        case ts.SyntaxKind.AsteriskAsteriskEqualsToken:
-            return '**=';
-        case ts.SyntaxKind.AmpersandEqualsToken:
-            return '&=';
-        case ts.SyntaxKind.BarEqualsToken:
-            return '|=';
-        case ts.SyntaxKind.CaretEqualsToken:
-            return '^=';
-        case ts.SyntaxKind.LessThanLessThanEqualsToken:
-            return '<<=';
-        case ts.SyntaxKind.GreaterThanGreaterThanEqualsToken:
-            return '>>=';
-        default:
-            return null;
-    }
-}
 //# sourceMappingURL=assignment-operators.js.map

package/dist/assignment-operators.js.map

@@ -1 +1 @@
-{"version":3,"file":"assignment-operators.js","sourceRoot":"","sources":["../src/assignment-operators.ts"],"names":[],"mappings":"AAAA,mFAAmF;AACnF,OAAO,EAAE,MAAM,YAAY,CAAC;AAE5B,OAAO,EACL,0BAA0B,IAAI,oCAAoC,EAClE,yBAAyB,IAAI,kCAAkC,EAC/D,yBAAyB,IAAI,kCAAkC,GAChE,MAAM,2CAA2C,CAAC;AAOnD,MAAM,CAAC,MAAM,0BAA0B,GAAG,oCAA0E,CAAC;AAErH,MAAM,UAAU,yBAAyB,CAAC,EAAU;IAClD,OAAO,kCAAkC,CAAC,EAAE,CAAC,CAAC;AAChD,CAAC;AAED,MAAM,UAAU,yBAAyB,CAAC,EAAU;IAClD,OAAO,kCAAkC,CAAC,EAAE,CAAC,CAAC;AAChD,CAAC;AAED,MAAM,UAAU,mCAAmC,CAAC,IAAmB;IACrE,QAAQ,IAAI,EAAE,CAAC;QACb,KAAK,EAAE,CAAC,UAAU,CAAC,eAAe;YAChC,OAAO,IAAI,CAAC;QACd,KAAK,EAAE,CAAC,UAAU,CAAC,gBAAgB;YACjC,OAAO,IAAI,CAAC;QACd,KAAK,EAAE,CAAC,UAAU,CAAC,mBAAmB;YACpC,OAAO,IAAI,CAAC;QACd,KAAK,EAAE,CAAC,UAAU,CAAC,gBAAgB;YACjC,OAAO,IAAI,CAAC;QACd,KAAK,EAAE,CAAC,UAAU,CAAC,kBAAkB;YACnC,OAAO,IAAI,CAAC;QACd,KAAK,EAAE,CAAC,UAAU,CAAC,2BAA2B;YAC5C,OAAO,KAAK,CAAC;QACf,KAAK,EAAE,CAAC,UAAU,CAAC,oBAAoB;YACrC,OAAO,IAAI,CAAC;QACd,KAAK,EAAE,CAAC,UAAU,CAAC,cAAc;YAC/B,OAAO,IAAI,CAAC;QACd,KAAK,EAAE,CAAC,UAAU,CAAC,gBAAgB;YACjC,OAAO,IAAI,CAAC;QACd,KAAK,EAAE,CAAC,UAAU,CAAC,2BAA2B;YAC5C,OAAO,KAAK,CAAC;QACf,KAAK,EAAE,CAAC,UAAU,CAAC,iCAAiC;YAClD,OAAO,KAAK,CAAC;QACf;YACE,OAAO,IAAI,CAAC;IAChB,CAAC;AACH,CAAC"}
+{"version":3,"file":"assignment-operators.js","sourceRoot":"","sources":["../src/assignment-operators.ts"],"names":[],"mappings":"AAMA,OAAO,EACL,0BAA0B,IAAI,oCAAoC,EAClE,yBAAyB,IAAI,kCAAkC,EAC/D,yBAAyB,IAAI,kCAAkC,GAChE,MAAM,2CAA2C,CAAC;AAOnD,MAAM,CAAC,MAAM,0BAA0B,GAAG,oCAA0E,CAAC;AAErH,MAAM,UAAU,yBAAyB,CAAC,EAAU;IAClD,OAAO,kCAAkC,CAAC,EAAE,CAAC,CAAC;AAChD,CAAC;AAED,MAAM,UAAU,yBAAyB,CAAC,EAAU;IAClD,OAAO,kCAAkC,CAAC,EAAE,CAAC,CAAC;AAChD,CAAC"}

package/dist/closure-classifier.d.ts

@@ -0,0 +1,54 @@
+/** Slice 0.9 — browser-safe closure-classifier capability seam.
+ *
+ *  Block-bodied arrow functions (`(x) => { … }`) need a TypeScript-AST analysis
+ *  to (a) confirm the raw text parses as a single statement block and (b) decide
+ *  whether the v1 closure gate accepts it. That analysis lives in
+ *  `closure-eligibility.ts`, which statically imports `typescript` (~10MB).
+ *
+ *  To keep the parser browser-safe, `parser-expression.ts` depends ONLY on this
+ *  dependency-free capability interface — never on `closure-eligibility.ts`. The
+ *  TypeScript-backed implementation is provided out-of-band by
+ *  `typescript-closure-classifier.ts` (Node/codegen side) and injected through
+ *  `parseExpression(input, { closureClassifier })`.
+ *
+ *  When no classifier is injected, the default `unavailableClosureClassifier` is
+ *  active: ordinary expressions and expression-bodied arrows parse normally, and
+ *  ONLY block-bodied arrows fail closed with `closure-parser-unavailable`. */
+/** A synchronous capability for analyzing the raw text of a block-bodied arrow
+ *  body (`{ … }`, braces included). Intentionally minimal and target-agnostic:
+ *  the interface is expressed in core-own types so no `ts.*` type leaks into the
+ *  browser-safe surface (the parsed-block value is opaque `unknown`). */
+export interface ClosureClassifier {
+    /** Whether this classifier can actually analyze block bodies. The default
+     *  unavailable classifier reports `false`, which makes the parser fail closed
+     *  on block-bodied arrows before any parse/classify call. */
+    readonly available: boolean;
+    /** Parse the raw block into an opaque AST node, or `null` if it does not
+     *  parse cleanly as a single statement block. */
+    parseBlock(raw: string): unknown | null;
+    /** Return the v1 closure-gate reject reason (e.g. `closure-this`), or `null`
+     *  if the block is accepted. */
+    classifyBlock(raw: string): string | null;
+}
+/** Target-agnostic fail-closed reason for block-bodied arrows when no closure
+ *  classifier capability is injected (R2). Must NOT name a runtime
+ *  (typescript/node/browser/deno/bun) — it describes the missing CAPABILITY. */
+export declare const CLOSURE_PARSER_UNAVAILABLE_REASON = "closure-parser-unavailable";
+/** The full fail-closed diagnostic message thrown by the parser when a
+ *  block-bodied arrow is encountered without a classifier capability. */
+export declare const CLOSURE_PARSER_UNAVAILABLE_MESSAGE: string;
+/** Dependency-free default. Active whenever no classifier is injected — keeps
+ *  the parser spine free of `typescript`. `available: false` makes the parser
+ *  fail closed on block-bodied arrows; `classifyBlock` reports the
+ *  target-agnostic reason for any caller that inspects it directly. */
+export declare const unavailableClosureClassifier: ClosureClassifier;
+/** Analysis-only classifier: ACCEPTS every block-bodied arrow without
+ *  validating it (review fix, slice 0.9 r2). For re-parse-for-shape-analysis
+ *  sites — the semantic validator and the `super(...)`-detection predicate —
+ *  which inspect the expression STRUCTURE around a block arrow in text the
+ *  main parse pipeline has already gated. Without it, those sites' swallowing
+ *  catches turned a block-bodied arrow into silently-skipped diagnostics /
+ *  misclassified constructors. The lambda IR it produces is NOT
+ *  emission-trusted: never inject this where the parsed result flows to a
+ *  code generator — emitters keep the real (TypeScript-backed) classifier. */
+export declare const analysisClosureClassifier: ClosureClassifier;

package/dist/closure-classifier.js

@@ -0,0 +1,58 @@
+/** Slice 0.9 — browser-safe closure-classifier capability seam.
+ *
+ *  Block-bodied arrow functions (`(x) => { … }`) need a TypeScript-AST analysis
+ *  to (a) confirm the raw text parses as a single statement block and (b) decide
+ *  whether the v1 closure gate accepts it. That analysis lives in
+ *  `closure-eligibility.ts`, which statically imports `typescript` (~10MB).
+ *
+ *  To keep the parser browser-safe, `parser-expression.ts` depends ONLY on this
+ *  dependency-free capability interface — never on `closure-eligibility.ts`. The
+ *  TypeScript-backed implementation is provided out-of-band by
+ *  `typescript-closure-classifier.ts` (Node/codegen side) and injected through
+ *  `parseExpression(input, { closureClassifier })`.
+ *
+ *  When no classifier is injected, the default `unavailableClosureClassifier` is
+ *  active: ordinary expressions and expression-bodied arrows parse normally, and
+ *  ONLY block-bodied arrows fail closed with `closure-parser-unavailable`. */
+/** Target-agnostic fail-closed reason for block-bodied arrows when no closure
+ *  classifier capability is injected (R2). Must NOT name a runtime
+ *  (typescript/node/browser/deno/bun) — it describes the missing CAPABILITY. */
+export const CLOSURE_PARSER_UNAVAILABLE_REASON = 'closure-parser-unavailable';
+/** The full fail-closed diagnostic message thrown by the parser when a
+ *  block-bodied arrow is encountered without a classifier capability. */
+export const CLOSURE_PARSER_UNAVAILABLE_MESSAGE = `${CLOSURE_PARSER_UNAVAILABLE_REASON}: block-bodied arrow functions require a closure classifier ` +
+    `capability, which is not provided in this environment. Use an expression-bodied arrow, or pass a ` +
+    `closure classifier to parseExpression.`;
+/** Dependency-free default. Active whenever no classifier is injected — keeps
+ *  the parser spine free of `typescript`. `available: false` makes the parser
+ *  fail closed on block-bodied arrows; `classifyBlock` reports the
+ *  target-agnostic reason for any caller that inspects it directly. */
+export const unavailableClosureClassifier = {
+    available: false,
+    parseBlock() {
+        return null;
+    },
+    classifyBlock() {
+        return CLOSURE_PARSER_UNAVAILABLE_REASON;
+    },
+};
+/** Analysis-only classifier: ACCEPTS every block-bodied arrow without
+ *  validating it (review fix, slice 0.9 r2). For re-parse-for-shape-analysis
+ *  sites — the semantic validator and the `super(...)`-detection predicate —
+ *  which inspect the expression STRUCTURE around a block arrow in text the
+ *  main parse pipeline has already gated. Without it, those sites' swallowing
+ *  catches turned a block-bodied arrow into silently-skipped diagnostics /
+ *  misclassified constructors. The lambda IR it produces is NOT
+ *  emission-trusted: never inject this where the parsed result flows to a
+ *  code generator — emitters keep the real (TypeScript-backed) classifier. */
+export const analysisClosureClassifier = {
+    available: true,
+    parseBlock(raw) {
+        // Opaque non-null: shape analysis never reads the parsed block itself.
+        return raw;
+    },
+    classifyBlock() {
+        return null;
+    },
+};
+//# sourceMappingURL=closure-classifier.js.map

package/dist/closure-classifier.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"closure-classifier.js","sourceRoot":"","sources":["../src/closure-classifier.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;8EAe8E;AAmB9E;;gFAEgF;AAChF,MAAM,CAAC,MAAM,iCAAiC,GAAG,4BAA4B,CAAC;AAE9E;yEACyE;AACzE,MAAM,CAAC,MAAM,kCAAkC,GAC7C,GAAG,iCAAiC,8DAA8D;IAClG,mGAAmG;IACnG,wCAAwC,CAAC;AAE3C;;;uEAGuE;AACvE,MAAM,CAAC,MAAM,4BAA4B,GAAsB;IAC7D,SAAS,EAAE,KAAK;IAChB,UAAU;QACR,OAAO,IAAI,CAAC;IACd,CAAC;IACD,aAAa;QACX,OAAO,iCAAiC,CAAC;IAC3C,CAAC;CACF,CAAC;AAEF;;;;;;;;8EAQ8E;AAC9E,MAAM,CAAC,MAAM,yBAAyB,GAAsB;IAC1D,SAAS,EAAE,IAAI;IACf,UAAU,CAAC,GAAW;QACpB,uEAAuE;QACvE,OAAO,GAAG,CAAC;IACb,CAAC;IACD,aAAa;QACX,OAAO,IAAI,CAAC;IACd,CAAC;CACF,CAAC"}

package/dist/closure-eligibility.d.ts

@@ -50,6 +50,122 @@ import ts from 'typescript';
  *  closure-python-lowering.ts (which now imports this). Route behavior is
  *  unchanged: the lowerer still validates the same way. */
 export declare function parseClosureBlockAst(raw: string): ts.Block | null;
+export interface LegacyParamSignature {
+    /** Simple identifier binding name, or `null` for destructuring / non-identifier
+     *  patterns (which contribute no single legacy-param name — structured bindings
+     *  flow through the `param` child path instead). */
+    name: string | null;
+    /** Default-value expression text (`param.initializer`), or `null` when absent. */
+    default: string | null;
+}
+/** BLOCKER 2 + IMPORTANT 3 — parse a legacy `params="..."` string with the REAL
+ *  TypeScript parser and return one entry per parameter. Owns the
+ *  `ts.createSourceFile` call (this module already statically imports
+ *  `typescript`) so `host-namespace-ir.ts` need not — that keeps the core
+ *  barrel's `typescript`-importer pin at 5 (browser-spine-import-graph.test.ts).
+ *
+ *  Wrapping the raw list in `function _(<params>){}` and reading each
+ *  `ParameterDeclaration` auto-handles every case a hand-rolled char-scanner
+ *  mis-split: `==`/`===`/`<=`/`>=` inside a default, regex literals with commas,
+ *  nested generics, template literals.
+ *
+ *  Fails CLOSED on malformed input: if `source.parseDiagnostics` is non-empty
+ *  (e.g. `params="process = ("`), returns `null` instead of producing phantom
+ *  recovery-AST bindings — so a caller never treats a host root (`process`) as
+ *  shadowed by a binding the user never actually wrote. A successful-but-empty
+ *  parse (no params) returns `[]`. */
+export declare function parseLegacyParamSignature(raw: string): LegacyParamSignature[] | null;
+export interface ClosureBlockMemberAccess {
+    root: string;
+    member: string;
+    locallyShadowed: boolean;
+}
+export declare function collectClosureBlockLocalBindingNames(raw: string): Set<string>;
+export declare function collectClosureBlockMemberAccesses(raw: string): ClosureBlockMemberAccess[];
+/** Slice 2 review fix (round 3) — a regex-host violation found INSIDE a
+ *  block-bodied arrow. Carries the EXACT fail-close `message` the EXPRESSION-level
+ *  path would emit, so the TS-verbatim block leg agrees with that path (and with
+ *  the Python leg, which lowers the body through the IR) BY CONSTRUCTION rather
+ *  than re-deriving the truth table:
+ *   - `bareRegexp` — a bare VALUE reference to `RegExp` (`return RegExp`,
+ *     `const R = RegExp`, `{ x: RegExp }`, `({ RegExp })`, `[RegExp]`, a ternary
+ *     branch, an argument). The generic member scan never sees these (no
+ *     identifier-rooted `Root.member`), so they slip the verbatim TS leg. The
+ *     MEMBER-OBJECT position (`RegExp.prototype`, `RegExp[$1]`) is deliberately
+ *     EXCLUDED — the generic scan owns it and emits the GENERIC host-namespace
+ *     message there (matching the expression-level member-receiver screen).
+ *     `message` is always `REGEX_HOST_REGEXP_FAILCLOSE`. `locallyShadowed`
+ *     reports a block-scope re-declaration so the caller can also honor an outer
+ *     user binding.
+ *   - `regexLiteralAccess` — a property/element access on a regex LITERAL
+ *     (`/x/.source`, `/x/["flags"]`, `/x/.test(s)`, `/x/.exec(s)`,
+ *     `/x/.compile(y)`). The receiver is a literal (never user-bindable), so it
+ *     never honors a binding (`locallyShadowed` is always false). `message` is
+ *     the shared classifier's verdict: `null` when the access is PORTABLE
+ *     (`/x/.test(s)` — NO violation pushed) or the exact fail-close message
+ *     otherwise (regex-host for reads/non-portable methods, `REGEX_EXEC_FAILCLOSE`
+ *     for `.exec`, `REGEX_TEST_G_FAILCLOSE` for `/g`-literal `.test`). */
+export interface ClosureBlockRegexHostViolation {
+    kind: 'bareRegexp' | 'regexLiteralAccess';
+    root: string;
+    locallyShadowed: boolean;
+    /** The exact fail-close message to throw (mirrors the expression-level path). */
+    message: string;
+}
+/** Walk a closure block's TS AST and collect the regex-host violations the
+ *  generic member-access scan cannot see (bare `RegExp` VALUE references and
+ *  regex-LITERAL property/element accesses). Tracks REAL JS block scope: each
+ *  block predeclares its top-level let/const/function/class names BEFORE visiting
+ *  its refs, so a name shadows only within its own block + nested blocks. A
+ *  parse failure yields an empty list (the gate already rejected such bodies). */
+export declare function collectClosureBlockRegexHostViolations(raw: string): ClosureBlockRegexHostViolation[];
+/** A bare-identifier operand of a `typeof` expression found inside a closure
+ *  block (`typeof Date`, `typeof process`). The host-root decision is made by the
+ *  CONSUMER (`typescript-closure-classifier.ts`), so this collector stays free of
+ *  host-namespace coupling — it only reports the operand `name` and whether a
+ *  block-scope local shadows it. RegExp is NOT special-cased here: a bare `RegExp`
+ *  in `typeof` position is already a value reference caught by
+ *  `collectClosureBlockRegexHostViolations` (round-6 removed the `typeof` exemption
+ *  in `isRegExpNonValuePosition`), so it fails-close there with the regex message.
+ *  This collector covers the OTHER reserved host roots with the generic message. */
+export interface ClosureBlockTypeofOperand {
+    name: string;
+    locallyShadowed: boolean;
+}
+/** Walk a closure block and collect every `typeof <bare identifier>` operand,
+ *  tracking REAL JS block scope identically to
+ *  {@link collectClosureBlockRegexHostViolations}: each block predeclares its
+ *  top-level let/const/function/class names (incl. destructuring) BEFORE visiting
+ *  its refs, so a block-local shadow is honored for the whole block. Only the
+ *  bare-identifier operand of a `typeof` is reported, AFTER recursively peeling
+ *  the transparent TS-AST wrappers via {@link unwrapRegexReceiverTS} — so a
+ *  WRAPPED operand (`typeof (Date as any)`, `typeof (Date!)`, parenthesized
+ *  `typeof (Date)`, nested `typeof (Date as any as unknown)`) records the
+ *  underlying `Date` name, identically to the ValueIR legs that peel
+ *  `typeAssert`/`nonNull` via `unwrapTransparentReceiverIR` (round-7 closes the
+ *  wrapped-operand bypass on this leg too). `typeof Date.now` (a member operand)
+ *  is owned by the generic member-access scan, and any operand that does NOT
+ *  unwrap to a bare identifier records nothing. A parse failure yields an empty
+ *  list (the gate already rejected such bodies). */
+export declare function collectClosureBlockTypeofOperands(raw: string): ClosureBlockTypeofOperand[];
+/** Flatten a binding NAME (plain identifier OR an object/array destructuring
+ *  pattern) to the identifier names it binds. `const { RegExp } = x` →
+ *  `['RegExp']`, `const [a, , b] = arr` → `['a','b']`. Exported so the Python
+ *  closure lowerer's block-scope tracker (`blockTopLevelDeclaredNames` in
+ *  closure-python-lowering.ts) extracts shadow names the SAME way as the TS-AST
+ *  closure walk here — a destructured `RegExp` shadow is then honored
+ *  symmetrically on both legs (no fail-open on one target). */
+export declare function bindingPatternIdentifierNames(name: ts.BindingName): string[];
+/** Collect the raw source text of every CALL expression nested anywhere in a
+ *  closure block, via the shared TS AST (`parseClosureBlockAst`) — never a
+ *  string scan. Returned to consumers that re-parse each call into their own
+ *  IR (the TS body emitter's bound-regex-method fail-close), so those callers
+ *  need no static `typescript` import of their own. Keeping the `ts` AST walk
+ *  quarantined in this Node-only module is what keeps `body-ts.js` OFF the
+ *  browser-spine TS-importer pin (`browser-spine-import-graph.test.ts`). A
+ *  parse failure yields an empty list (the gate already rejected such bodies,
+ *  so this is defensive). */
+export declare function collectClosureBlockCallTexts(raw: string): string[];
 /** Collect the set of free identifier NAMES referenced in a closure block —
  *  identifiers used in the block that are NOT declared inside the block and
  *  NOT in `paramNames` (the closure's own parameters). These are exactly the