typekro 0.4.0 → 0.5.0

package/dist/core/expressions/analysis/fn-toString-self-test.js

@@ -0,0 +1,243 @@
+/**
+ * fn.toString() Self-Test
+ *
+ * TypeKro relies on `fn.toString()` producing parseable JavaScript source code in
+ * multiple critical code paths (status builder analysis, composition body analysis,
+ * imperative composition analysis, readyWhen callback conversion, and expression
+ * classification). This module provides a self-test that verifies the current runtime
+ * environment produces parseable output.
+ *
+ * ## Why this matters
+ *
+ * The `Function.prototype.toString()` output varies by runtime and build configuration:
+ *
+ * | Environment              | Arrow function toString()                     | Parseable? |
+ * |--------------------------|-----------------------------------------------|------------|
+ * | Node.js / Bun (no build) | `(x) => x + 1`                               | Yes        |
+ * | Bun (transpiled)         | `(x) => x + 1` (quotes normalized to double)  | Yes        |
+ * | esbuild (minified)       | `x=>x+1` (whitespace removed)                 | Yes        |
+ * | esbuild (mangled)        | `a=>a+1` (names mangled)                      | Partial*   |
+ * | Terser (mangled)         | `a=>a+1`                                      | Partial*   |
+ * | Webpack mode=production  | May inline or remove function bodies            | No         |
+ * | Closure Compiler ADVANCED | Removes/renames everything                    | No         |
+ *
+ * *Partial: AST parses, but parameter names are mangled so `schema.spec.name`
+ * becomes `a.spec.name` — the composition analyzer needs the original names.
+ *
+ * ## Build configurations that break TypeKro
+ *
+ * 1. **Variable name mangling** (`esbuild --mangle`, `terser --mangle-props`):
+ *    Renames function parameters. Status builder analysis depends on parameter names
+ *    matching resource keys (e.g., `(schema, resources) => ...`).
+ *
+ * 2. **Dead code elimination** with tree-shaking that removes function bodies:
+ *    The composition analyzer needs the full function body to detect if/for/ternary
+ *    patterns.
+ *
+ * 3. **Advanced minification** (Closure Compiler ADVANCED, UglifyJS with `compress`):
+ *    May restructure control flow, inline functions, or evaluate expressions at
+ *    compile time, making the source unparseable or semantically different.
+ *
+ * 4. **Source-to-source transforms** that don't preserve function structure:
+ *    SWC with certain plugins, Babel transforms that rewrite arrow functions to
+ *    regular functions with different parameter patterns.
+ *
+ * ## Safe configurations
+ *
+ * - **No bundler** (direct TypeScript execution via Bun or ts-node): Always works
+ * - **esbuild with `--minify-whitespace` only** (no `--mangle`): Works
+ * - **Webpack mode=development**: Works
+ * - **Vite dev mode**: Works
+ * - **Any bundler with `Function.prototype.toString` polyfill that preserves source**: Works
+ *
+ * ## Call sites that depend on fn.toString()
+ *
+ * | File                                | Usage                                    |
+ * |-------------------------------------|------------------------------------------|
+ * | `serialization/yaml.ts`             | readyWhen callback → CEL conversion      |
+ * | `deployment/debug-logger.ts`        | Evaluator type inspection (non-critical) |
+ * | `expressions/factory/status-builder-analyzer.ts` | Status builder AST parsing    |
+ * | `expressions/context/context-detector.ts`        | Expression complexity analysis|
+ * | `expressions/analysis/expression-classifier.ts`  | Function body analysis        |
+ * | `expressions/composition/composition-analyzer.ts` | Composition body detection   |
+ * | `expressions/composition/imperative-analyzer.ts`  | Imperative composition parse |
+ * | `expressions/composition/expression-analyzer.ts`  | Pattern detection            |
+ *
+ * ## Future alternative: TypeScript Compiler API
+ *
+ * As an opt-in alternative to `fn.toString()` + acorn parsing, the TypeScript Compiler
+ * API (`typescript` package) could be used to analyze user-supplied functions at build
+ * time or at schema-registration time. This would eliminate the runtime dependency on
+ * `fn.toString()` producing parseable output entirely.
+ *
+ * ### How it would work
+ *
+ * 1. **At `toResourceGraph()` call time**, capture the source file path and position of
+ *    the status builder / composition function using `Error().stack` or a build plugin.
+ * 2. **Use `ts.createProgram()`** to parse the original TypeScript source (not the
+ *    transpiled output) with full type information.
+ * 3. **Walk the AST** using `ts.forEachChild()` to find the function node at the
+ *    captured position and extract parameter types, return types, and body structure.
+ * 4. **Cache results** keyed by file path + position so re-analysis is free.
+ *
+ * ### Advantages
+ *
+ * - Works regardless of bundler/minifier configuration
+ * - Has access to full TypeScript type information (not just runtime values)
+ * - Can detect type errors in status builders at registration time
+ * - No runtime `fn.toString()` calls needed
+ *
+ * ### Challenges (estimated 2+ weeks to implement)
+ *
+ * - **Source location capture**: Reliably mapping a runtime function call back to its
+ *   source file position is non-trivial. `Error().stack` line numbers may not match
+ *   original TS source after transpilation. A build plugin (Bun plugin, esbuild plugin)
+ *   could inject source locations at compile time.
+ * - **TypeScript as a dependency**: The `typescript` package is ~45MB. It should be an
+ *   optional peer dependency, loaded dynamically with `import('typescript')`.
+ * - **Performance**: `ts.createProgram()` is expensive (~500ms-2s for a medium project).
+ *   Must be lazy and cached. Could use `ts.createLanguageService()` for incremental
+ *   parsing.
+ * - **Monorepo / workspace support**: Source files may be in different packages with
+ *   different tsconfig.json files. The API would need to resolve the correct config.
+ * - **Runtime-only environments**: Users running TypeKro without access to source files
+ *   (e.g., in a Docker container with only compiled JS) would still need the
+ *   `fn.toString()` fallback.
+ * - **Test coverage**: All 12 call sites would need dual-path testing (TS API path +
+ *   fn.toString() fallback path).
+ *
+ * ### Recommendation
+ *
+ * Keep `fn.toString()` as the default path with the self-test as a safety net. The TS
+ * Compiler API approach should be a future opt-in for users who need bundler-safe
+ * analysis. Implementation should wait until there is concrete user demand from a
+ * production deployment that uses aggressive minification.
+ */
+import { getComponentLogger } from '../../logging/index.js';
+// Import from parse-core instead of parser to break the circular dependency:
+// parser.ts → fn-toString-self-test.ts → parser.ts
+import { parseScriptCore } from './parse-core.js';
+const logger = getComponentLogger('fn-toString-self-test');
+/**
+ * Known reference function used for self-testing.
+ * The body must contain identifiable tokens that the parser can find.
+ */
+// biome-ignore lint/complexity/useArrowFunction: Must test regular function toString
+const REFERENCE_FUNCTION = function referenceTestFunction(schema) {
+    return { ready: true, name: schema.spec.name };
+};
+/**
+ * Known reference arrow function.
+ */
+const REFERENCE_ARROW = (self) => self.status.readyReplicas > 0;
+/**
+ * Run the fn.toString() self-test.
+ *
+ * Call this early in the application lifecycle to detect incompatible
+ * build configurations before they cause subtle analysis failures.
+ *
+ * @returns Self-test results with compatibility assessment
+ */
+export function runFnToStringSelfTest() {
+    const diagnostics = [];
+    let parseable = false;
+    let parameterNamesPreserved = false;
+    let functionBodiesPreserved = false;
+    let arrowSyntaxPreserved = false;
+    // Test 1: Regular function toString() is parseable
+    try {
+        const fnSource = REFERENCE_FUNCTION.toString();
+        diagnostics.push(`Regular function toString(): ${fnSource.slice(0, 100)}...`);
+        const ast = parseScriptCore(fnSource);
+        parseable = ast.type === 'Program' || ast.type === 'FunctionDeclaration';
+        if (!parseable) {
+            // Try wrapping — parseScriptCore may return the body node
+            parseable = true; // If parseScriptCore didn't throw, the source was parseable
+        }
+        diagnostics.push('Regular function: parseable');
+    }
+    catch (error) {
+        diagnostics.push(`Regular function: NOT parseable — ${error.message}`);
+    }
+    // Test 2: Arrow function toString() is parseable
+    try {
+        const arrowSource = REFERENCE_ARROW.toString();
+        diagnostics.push(`Arrow function toString(): ${arrowSource.slice(0, 100)}...`);
+        parseScriptCore(`(${arrowSource})`);
+        arrowSyntaxPreserved = true;
+        diagnostics.push('Arrow function: parseable');
+    }
+    catch (error) {
+        diagnostics.push(`Arrow function: NOT parseable — ${error.message}`);
+    }
+    // Test 3: Parameter names are preserved
+    try {
+        const fnSource = REFERENCE_FUNCTION.toString();
+        parameterNamesPreserved = fnSource.includes('schema');
+        if (!parameterNamesPreserved) {
+            diagnostics.push('WARNING: Parameter name "schema" not found in fn.toString() output — ' +
+                'names may be mangled. Status builder analysis will not work correctly.');
+        }
+        else {
+            diagnostics.push('Parameter names: preserved');
+        }
+    }
+    catch {
+        diagnostics.push('Parameter name check: failed');
+    }
+    // Test 4: Function bodies are preserved
+    try {
+        const fnSource = REFERENCE_FUNCTION.toString();
+        functionBodiesPreserved = fnSource.includes('schema.spec.name') && fnSource.includes('ready');
+        if (!functionBodiesPreserved) {
+            diagnostics.push('WARNING: Function body content not found in fn.toString() output — ' +
+                'body may be stripped or transformed. Composition analysis will not work.');
+        }
+        else {
+            diagnostics.push('Function bodies: preserved');
+        }
+    }
+    catch {
+        diagnostics.push('Function body check: failed');
+    }
+    const compatible = parseable && parameterNamesPreserved && functionBodiesPreserved;
+    return {
+        parseable,
+        parameterNamesPreserved,
+        functionBodiesPreserved,
+        arrowSyntaxPreserved,
+        compatible,
+        diagnostics,
+    };
+}
+/**
+ * Validate the runtime environment and log warnings if fn.toString() analysis
+ * will not work correctly. This is a no-op if the environment is compatible.
+ *
+ * Call once during application initialization.
+ */
+export function validateFnToStringEnvironment() {
+    const result = runFnToStringSelfTest();
+    if (result.compatible) {
+        logger.debug('fn.toString() self-test passed — runtime environment is compatible', {
+            parseable: result.parseable,
+            parameterNamesPreserved: result.parameterNamesPreserved,
+            functionBodiesPreserved: result.functionBodiesPreserved,
+            arrowSyntaxPreserved: result.arrowSyntaxPreserved,
+        });
+        return;
+    }
+    // Log detailed warnings
+    logger.warn('fn.toString() self-test detected potential issues — TypeKro analysis features ' +
+        'may not work correctly in this build environment', {
+        compatible: false,
+        parseable: result.parseable,
+        parameterNamesPreserved: result.parameterNamesPreserved,
+        functionBodiesPreserved: result.functionBodiesPreserved,
+        arrowSyntaxPreserved: result.arrowSyntaxPreserved,
+        diagnostics: result.diagnostics,
+        recommendation: 'Ensure your bundler does not mangle variable names or strip function bodies. ' +
+            'See TypeKro documentation for compatible build configurations.',
+    });
+}
+//# sourceMappingURL=fn-toString-self-test.js.map

package/dist/core/expressions/analysis/fn-toString-self-test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fn-toString-self-test.js","sourceRoot":"","sources":["../../../../src/core/expressions/analysis/fn-toString-self-test.ts"],"names":[],"mappings":"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"}

package/dist/core/expressions/analysis/operator-utils.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Operator mapping, precedence, and boolean-test utilities.
+ *
+ * All functions are pure (stateless) – extracted from JavaScriptToCelAnalyzer
+ * to reduce the class to a slim orchestrator.
+ */
+/** Map a JavaScript logical/comparison operator to its CEL equivalent. */
+export declare function mapOperatorToCel(operator: string): string;
+/** Map a JavaScript binary operator (including arithmetic) to CEL. Throws for unsupported ops. */
+export declare function convertBinaryOperator(operator: string): string;
+/** Get numeric precedence for an operator (lower = binds less tightly). */
+export declare function getOperatorPrecedence(operator: string): number;
+/** Whether an operator is left-associative. Ternary (`?`) is the only right-associative one. */
+export declare function isLeftAssociative(operator: string): boolean;
+/**
+ * Find the "main" (lowest-precedence) operator at depth-0 in an expression string.
+ */
+export declare function getMainOperator(expression: string): string | null;
+/**
+ * Wrap `expression` in parentheses when its main operator has lower precedence
+ * than `parentOperator`, or when it is a right operand with equal precedence
+ * for left-associative operators.
+ */
+export declare function addParenthesesIfNeeded(expression: string, parentOperator?: string, isLeftOperand?: boolean): string;
+/** Check whether an expression string already contains a boolean comparison. */
+export declare function isBooleanExpression(expression: string): boolean;
+/**
+ * Convert a CEL expression to a boolean test.
+ * If the expression is already boolean, return it unchanged;
+ * otherwise wrap it in truthy-check conditions.
+ */
+export declare function convertToBooleanTest(expression: string): string;
+/** Infer a representative zero-value from a Kubernetes field path. */
+export declare function inferTypeFromFieldPath(fieldPath: string): string | number | boolean | Record<string, unknown> | unknown[];
+//# sourceMappingURL=operator-utils.d.ts.map

package/dist/core/expressions/analysis/operator-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"operator-utils.d.ts","sourceRoot":"","sources":["../../../../src/core/expressions/analysis/operator-utils.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAmBH,0EAA0E;AAC1E,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAEzD;AAkBD,kGAAkG;AAClG,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAU9D;AAsBD,2EAA2E;AAC3E,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAE9D;AAED,gGAAgG;AAChG,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAE3D;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CA4BjE;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CACpC,UAAU,EAAE,MAAM,EAClB,cAAc,CAAC,EAAE,MAAM,EACvB,aAAa,CAAC,EAAE,OAAO,GACtB,MAAM,CAiBR;AAID,gFAAgF;AAChF,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAG/D;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAG/D;AAID,sEAAsE;AACtE,wBAAgB,sBAAsB,CACpC,SAAS,EAAE,MAAM,GAChB,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,EAAE,CA6BjE"}

package/dist/core/expressions/analysis/operator-utils.js

@@ -0,0 +1,167 @@
+/**
+ * Operator mapping, precedence, and boolean-test utilities.
+ *
+ * All functions are pure (stateless) – extracted from JavaScriptToCelAnalyzer
+ * to reduce the class to a slim orchestrator.
+ */
+import { ConversionError } from '../../errors.js';
+// ── Operator mapping ───────────────────────────────────────────────
+const JS_TO_CEL_OPERATOR = {
+    '===': '==',
+    '!==': '!=',
+    '&&': '&&',
+    '||': '||',
+    '>': '>',
+    '<': '<',
+    '>=': '>=',
+    '<=': '<=',
+    '==': '==',
+    '!=': '!=',
+};
+/** Map a JavaScript logical/comparison operator to its CEL equivalent. */
+export function mapOperatorToCel(operator) {
+    return JS_TO_CEL_OPERATOR[operator] ?? operator;
+}
+const BINARY_OPERATOR_MAP = {
+    '===': '==',
+    '!==': '!=',
+    '==': '==',
+    '!=': '!=',
+    '<': '<',
+    '<=': '<=',
+    '>': '>',
+    '>=': '>=',
+    '+': '+',
+    '-': '-',
+    '*': '*',
+    '/': '/',
+    '%': '%',
+};
+/** Map a JavaScript binary operator (including arithmetic) to CEL. Throws for unsupported ops. */
+export function convertBinaryOperator(operator) {
+    const celOperator = BINARY_OPERATOR_MAP[operator];
+    if (!celOperator) {
+        throw new ConversionError(`Unsupported binary operator: ${operator}`, String(operator), 'binary-operation');
+    }
+    return celOperator;
+}
+// ── Precedence ─────────────────────────────────────────────────────
+const OPERATOR_PRECEDENCE = {
+    '||': 1,
+    '&&': 2,
+    '==': 3,
+    '!=': 3,
+    '<': 4,
+    '<=': 4,
+    '>': 4,
+    '>=': 4,
+    '+': 5,
+    '-': 5,
+    '*': 6,
+    '/': 6,
+    '%': 6,
+    '??': 1,
+    '?': 0,
+};
+/** Get numeric precedence for an operator (lower = binds less tightly). */
+export function getOperatorPrecedence(operator) {
+    return OPERATOR_PRECEDENCE[operator] ?? 10;
+}
+/** Whether an operator is left-associative. Ternary (`?`) is the only right-associative one. */
+export function isLeftAssociative(operator) {
+    return operator !== '?';
+}
+/**
+ * Find the "main" (lowest-precedence) operator at depth-0 in an expression string.
+ */
+export function getMainOperator(expression) {
+    const operators = ['||', '&&', '==', '!=', '<=', '>=', '<', '>', '+', '-', '*', '/', '%'];
+    let depth = 0;
+    let mainOp = null;
+    let lowestPrec = Infinity;
+    for (let i = 0; i < expression.length; i++) {
+        const char = expression[i];
+        if (char === '(') {
+            depth++;
+        }
+        else if (char === ')') {
+            depth--;
+        }
+        else if (depth === 0) {
+            for (const op of operators) {
+                if (expression.substring(i, i + op.length) === op) {
+                    const prec = getOperatorPrecedence(op);
+                    if (prec <= lowestPrec) {
+                        lowestPrec = prec;
+                        mainOp = op;
+                    }
+                    i += op.length - 1;
+                    break;
+                }
+            }
+        }
+    }
+    return mainOp;
+}
+/**
+ * Wrap `expression` in parentheses when its main operator has lower precedence
+ * than `parentOperator`, or when it is a right operand with equal precedence
+ * for left-associative operators.
+ */
+export function addParenthesesIfNeeded(expression, parentOperator, isLeftOperand) {
+    if (!parentOperator)
+        return expression;
+    const exprOp = getMainOperator(expression);
+    if (!exprOp)
+        return expression;
+    const parentPrec = getOperatorPrecedence(parentOperator);
+    const exprPrec = getOperatorPrecedence(exprOp);
+    if (exprPrec < parentPrec ||
+        (exprPrec === parentPrec && !isLeftOperand && isLeftAssociative(parentOperator))) {
+        return `(${expression})`;
+    }
+    return expression;
+}
+// ── Boolean test helpers ───────────────────────────────────────────
+/** Check whether an expression string already contains a boolean comparison. */
+export function isBooleanExpression(expression) {
+    const comparisonOperators = ['==', '!=', '>', '<', '>=', '<=', '&&', '||'];
+    return comparisonOperators.some((op) => expression.includes(` ${op} `));
+}
+/**
+ * Convert a CEL expression to a boolean test.
+ * If the expression is already boolean, return it unchanged;
+ * otherwise wrap it in truthy-check conditions.
+ */
+export function convertToBooleanTest(expression) {
+    if (isBooleanExpression(expression))
+        return expression;
+    return `${expression} != null && ${expression} != "" && ${expression} != false && ${expression} != 0`;
+}
+// ── Type inference helper ──────────────────────────────────────────
+/** Infer a representative zero-value from a Kubernetes field path. */
+export function inferTypeFromFieldPath(fieldPath) {
+    if (fieldPath.includes('replicas') || fieldPath.includes('count') || fieldPath.includes('port')) {
+        return 0;
+    }
+    if (fieldPath.includes('ready') ||
+        fieldPath.includes('available') ||
+        fieldPath.includes('enabled')) {
+        return false;
+    }
+    if (fieldPath.includes('name') ||
+        fieldPath.includes('image') ||
+        fieldPath.includes('namespace')) {
+        return '';
+    }
+    if (fieldPath.includes('labels') || fieldPath.includes('annotations')) {
+        return {};
+    }
+    if (fieldPath.includes('conditions') ||
+        fieldPath.includes('ingress') ||
+        fieldPath.includes('containers')) {
+        return [];
+    }
+    return '';
+}
+//# sourceMappingURL=operator-utils.js.map

package/dist/core/expressions/analysis/operator-utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"operator-utils.js","sourceRoot":"","sources":["../../../../src/core/expressions/analysis/operator-utils.ts"],"names":[],"mappings":"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"}

package/dist/core/expressions/analysis/parse-core.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Core Acorn Parse Utilities
+ *
+ * Low-level parsing functions and error classes that do NOT depend on the
+ * fn.toString() self-test. This module exists to break the circular dependency
+ * between parser.ts and fn-toString-self-test.ts: the self-test needs to parse
+ * code, but the parser calls the self-test on first use. By extracting the raw
+ * parse logic and ParserError here, both modules can import from this file
+ * without creating a cycle.
+ *
+ * Dependency graph:
+ *   parse-core.ts  ← parser.ts (re-exports + adds self-test guard)
+ *   parse-core.ts  ← fn-toString-self-test.ts (uses parseScriptCore)
+ *   fn-toString-self-test.ts ← parser.ts (calls validate on first parse)
+ *
+ * @module parse-core
+ * @internal
+ */
+import { type Options } from 'acorn';
+import type { Node as ESTreeNode } from 'estree';
+import { TypeKroError } from '../../errors.js';
+/**
+ * Custom error class for parser errors with enhanced information
+ */
+export declare class ParserError extends TypeKroError {
+    /** Line number where the error occurred (1-indexed) */
+    readonly line: number;
+    /** Column number where the error occurred (0-indexed) */
+    readonly column: number;
+    /** The original expression that failed to parse */
+    readonly originalExpression: string;
+    /** Suggestions for fixing the error */
+    readonly suggestions: string[];
+    constructor(message: string, line: number, column: number, originalExpression: string, suggestions?: string[]);
+    /**
+     * Create a ParserError from an acorn SyntaxError
+     */
+    static fromAcornError(error: SyntaxError & {
+        loc?: {
+            line: number;
+            column: number;
+        };
+        pos?: number;
+    }, expression: string): ParserError;
+    /**
+     * Format the error with context for debugging
+     */
+    toDetailedString(): string;
+}
+/**
+ * Default parser options for TypeKro expression analysis
+ */
+export declare const DEFAULT_PARSER_OPTIONS: Options;
+/**
+ * Parse a complete JavaScript program/script without the fn.toString() self-test.
+ *
+ * This is the raw acorn parse call used by fn-toString-self-test.ts to avoid
+ * the circular dependency with parser.ts.
+ *
+ * @internal
+ */
+export declare function parseScriptCore(source: string, options?: Partial<Options>): ESTreeNode;
+//# sourceMappingURL=parse-core.d.ts.map

package/dist/core/expressions/analysis/parse-core.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-core.d.ts","sourceRoot":"","sources":["../../../../src/core/expressions/analysis/parse-core.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EAAE,KAAK,OAAO,EAAU,MAAM,OAAO,CAAC;AAC7C,OAAO,KAAK,EAAE,IAAI,IAAI,UAAU,EAAE,MAAM,QAAQ,CAAC;AACjD,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAE/C;;GAEG;AACH,qBAAa,WAAY,SAAQ,YAAY;IAC3C,uDAAuD;IACvD,SAAgB,IAAI,EAAE,MAAM,CAAC;IAE7B,yDAAyD;IACzD,SAAgB,MAAM,EAAE,MAAM,CAAC;IAE/B,mDAAmD;IACnD,SAAgB,kBAAkB,EAAE,MAAM,CAAC;IAE3C,uCAAuC;IACvC,SAAgB,WAAW,EAAE,MAAM,EAAE,CAAC;gBAGpC,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,EACd,kBAAkB,EAAE,MAAM,EAC1B,WAAW,GAAE,MAAM,EAAO;IAoB5B;;OAEG;IACH,MAAM,CAAC,cAAc,CACnB,KAAK,EAAE,WAAW,GAAG;QAAE,GAAG,CAAC,EAAE;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,MAAM,EAAE,MAAM,CAAA;SAAE,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAA;KAAE,EAC7E,UAAU,EAAE,MAAM,GACjB,WAAW;IAgBd;;OAEG;IACH,gBAAgB,IAAI,MAAM;CAgB3B;AAED;;GAEG;AACH,eAAO,MAAM,sBAAsB,EAAE,OAKpC,CAAC;AAEF;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,CAAC,OAAO,CAAC,GAAG,UAAU,CAiBtF"}

package/dist/core/expressions/analysis/parse-core.js

@@ -0,0 +1,115 @@
+/**
+ * Core Acorn Parse Utilities
+ *
+ * Low-level parsing functions and error classes that do NOT depend on the
+ * fn.toString() self-test. This module exists to break the circular dependency
+ * between parser.ts and fn-toString-self-test.ts: the self-test needs to parse
+ * code, but the parser calls the self-test on first use. By extracting the raw
+ * parse logic and ParserError here, both modules can import from this file
+ * without creating a cycle.
+ *
+ * Dependency graph:
+ *   parse-core.ts  ← parser.ts (re-exports + adds self-test guard)
+ *   parse-core.ts  ← fn-toString-self-test.ts (uses parseScriptCore)
+ *   fn-toString-self-test.ts ← parser.ts (calls validate on first parse)
+ *
+ * @module parse-core
+ * @internal
+ */
+import { Parser } from 'acorn';
+import { TypeKroError } from '../../errors.js';
+/**
+ * Custom error class for parser errors with enhanced information
+ */
+export class ParserError extends TypeKroError {
+    /** Line number where the error occurred (1-indexed) */
+    line;
+    /** Column number where the error occurred (0-indexed) */
+    column;
+    /** The original expression that failed to parse */
+    originalExpression;
+    /** Suggestions for fixing the error */
+    suggestions;
+    constructor(message, line, column, originalExpression, suggestions = []) {
+        super(message, 'PARSER_ERROR', {
+            line,
+            column,
+            originalExpression,
+            suggestions,
+        });
+        this.name = 'ParserError';
+        this.line = line;
+        this.column = column;
+        this.originalExpression = originalExpression;
+        this.suggestions = suggestions;
+        // Maintain proper stack trace in V8 environments
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, ParserError);
+        }
+    }
+    /**
+     * Create a ParserError from an acorn SyntaxError
+     */
+    static fromAcornError(error, expression) {
+        const line = error.loc?.line ?? 1;
+        const column = error.loc?.column ?? 0;
+        const suggestions = [
+            'Check for syntax errors in your expression',
+            'Consider using the explicit Cel API: Cel.expr(), Cel.template(), Cel.conditional()',
+            'Ensure all brackets and parentheses are balanced',
+            'Verify that all string literals are properly quoted',
+        ];
+        const enhancedMessage = `Parse error at line ${line}, column ${column}: ${error.message}`;
+        return new ParserError(enhancedMessage, line, column, expression, suggestions);
+    }
+    /**
+     * Format the error with context for debugging
+     */
+    toDetailedString() {
+        const lines = [
+            `ParserError: ${this.message}`,
+            `  at line ${this.line}, column ${this.column}`,
+            `  Expression: ${this.originalExpression.substring(0, 100)}${this.originalExpression.length > 100 ? '...' : ''}`,
+        ];
+        if (this.suggestions.length > 0) {
+            lines.push('  Suggestions:');
+            for (const suggestion of this.suggestions) {
+                lines.push(`    - ${suggestion}`);
+            }
+        }
+        return lines.join('\n');
+    }
+}
+/**
+ * Default parser options for TypeKro expression analysis
+ */
+export const DEFAULT_PARSER_OPTIONS = {
+    ecmaVersion: 2022,
+    sourceType: 'script',
+    locations: true,
+    ranges: true,
+};
+/**
+ * Parse a complete JavaScript program/script without the fn.toString() self-test.
+ *
+ * This is the raw acorn parse call used by fn-toString-self-test.ts to avoid
+ * the circular dependency with parser.ts.
+ *
+ * @internal
+ */
+export function parseScriptCore(source, options) {
+    const mergedOptions = {
+        ...DEFAULT_PARSER_OPTIONS,
+        ...options,
+    };
+    try {
+        return Parser.parse(source, mergedOptions);
+    }
+    catch (error) {
+        if (error instanceof SyntaxError) {
+            throw ParserError.fromAcornError(error, source);
+        }
+        throw error;
+    }
+}
+//# sourceMappingURL=parse-core.js.map

package/dist/core/expressions/analysis/parse-core.js.map

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