stringent 0.0.1 → 0.0.2

package/dist/runtime/parser.js

@@ -0,0 +1,271 @@
+/**
+ * Runtime Parser
+ *
+ * Mirrors the type-level Parse<Grammar, Input, Context> at runtime.
+ * Uses the same precedence-based parsing strategy:
+ *   1. Try operators at current level (lowest precedence first)
+ *   2. Fall back to next level (higher precedence)
+ *   3. Base case: try atoms (last level)
+ */
+import { Token } from "@sinclair/parsebox";
+// =============================================================================
+// Primitive Parsers
+// =============================================================================
+function parseNumber(input) {
+    const result = Token.Number(input);
+    if (result.length === 0)
+        return [];
+    return [
+        {
+            node: "literal",
+            raw: result[0],
+            value: +result[0],
+            outputSchema: "number",
+        },
+        result[1],
+    ];
+}
+function parseString(quotes, input) {
+    const result = Token.String([...quotes], input);
+    if (result.length === 0)
+        return [];
+    return [
+        {
+            node: "literal",
+            raw: result[0],
+            value: result[0],
+            outputSchema: "string",
+        },
+        result[1],
+    ];
+}
+function parseIdent(input, context) {
+    const result = Token.Ident(input);
+    if (result.length === 0)
+        return [];
+    const name = result[0];
+    const valueType = name in context.data
+        ? context.data[name]
+        : "unknown";
+    return [
+        { node: "identifier", name, outputSchema: valueType },
+        result[1],
+    ];
+}
+function parseConst(value, input) {
+    const result = Token.Const(value, input);
+    if (result.length === 0)
+        return [];
+    return [{ node: "const", outputSchema: JSON.stringify(value) }, result[1]];
+}
+// =============================================================================
+// Build Runtime Grammar from Node Schemas
+// =============================================================================
+/**
+ * Build runtime grammar from node schemas.
+ *
+ * Returns a flat tuple of levels:
+ *   [[ops@prec1], [ops@prec2], ..., [atoms]]
+ *
+ * Levels are sorted by precedence ascending (lowest first).
+ * Atoms are always the last level.
+ */
+export function buildGrammar(nodes) {
+    const atoms = [];
+    const operators = new Map();
+    for (const node of nodes) {
+        if (node.precedence === "atom") {
+            atoms.push(node);
+        }
+        else {
+            const prec = node.precedence;
+            if (!operators.has(prec)) {
+                operators.set(prec, []);
+            }
+            operators.get(prec).push(node);
+        }
+    }
+    // Sort precedences ascending
+    const precedences = [...operators.keys()].sort((a, b) => a - b);
+    // Build flat grammar: [[ops@prec1], [ops@prec2], ..., [atoms]]
+    const grammar = [];
+    for (const prec of precedences) {
+        grammar.push(operators.get(prec));
+    }
+    grammar.push(atoms);
+    return grammar;
+}
+// =============================================================================
+// Pattern Element Parsing
+// =============================================================================
+/**
+ * Parse a single pattern element (non-Expr).
+ */
+function parseElement(element, input, context) {
+    switch (element.kind) {
+        case "number":
+            return parseNumber(input);
+        case "string":
+            return parseString(element.quotes, input);
+        case "ident":
+            return parseIdent(input, context);
+        case "const":
+            return parseConst(element.value, input);
+        default:
+            return [];
+    }
+}
+/**
+ * Parse an expression element based on its role.
+ *
+ * Role determines which grammar slice is used:
+ * - "lhs": nextLevels (avoids left-recursion)
+ * - "rhs": currentLevels (maintains precedence, enables right-associativity)
+ * - "expr": fullGrammar (full reset for delimited contexts)
+ */
+function parseElementWithLevel(element, input, context, currentLevels, nextLevels, fullGrammar) {
+    if (element.kind === "expr") {
+        const exprElement = element;
+        const constraint = exprElement.constraint;
+        const role = exprElement.role;
+        if (role === "lhs") {
+            return parseExprWithConstraint(nextLevels, input, context, constraint, fullGrammar);
+        }
+        else if (role === "rhs") {
+            return parseExprWithConstraint(currentLevels, input, context, constraint, fullGrammar);
+        }
+        else {
+            return parseExprWithConstraint(fullGrammar, input, context, constraint, fullGrammar);
+        }
+    }
+    return parseElement(element, input, context);
+}
+/**
+ * Parse a pattern tuple.
+ */
+function parsePatternTuple(pattern, input, context, currentLevels, nextLevels, fullGrammar) {
+    let remaining = input;
+    const children = [];
+    for (const element of pattern) {
+        const result = parseElementWithLevel(element, remaining, context, currentLevels, nextLevels, fullGrammar);
+        if (result.length === 0)
+            return [];
+        children.push(result[0]);
+        remaining = result[1];
+    }
+    return [children, remaining];
+}
+/**
+ * Extract named bindings from pattern and children.
+ * Only includes children where the pattern element has .as(name).
+ */
+function extractBindings(pattern, children) {
+    const bindings = {};
+    for (let i = 0; i < pattern.length; i++) {
+        const element = pattern[i];
+        const child = children[i];
+        // Check if element is a NamedSchema (has __named and name properties)
+        if ("__named" in element && element.__named === true) {
+            bindings[element.name] = child;
+        }
+    }
+    return bindings;
+}
+/**
+ * Build AST node from parsed children.
+ *
+ * Uses named bindings from .as() to determine node fields.
+ * - Single child without names: passthrough (atom behavior)
+ * - If configure() provided: transform bindings to fields
+ * - Otherwise: bindings become node fields directly
+ */
+function buildNodeResult(nodeSchema, children, context) {
+    const bindings = extractBindings(nodeSchema.pattern, children);
+    // Single unnamed child → passthrough (atom behavior)
+    if (Object.keys(bindings).length === 0 && children.length === 1) {
+        return children[0];
+    }
+    // Apply configure() if provided, otherwise use bindings directly
+    const fields = nodeSchema.configure
+        ? nodeSchema.configure(bindings, context)
+        : bindings;
+    // Build node with fields
+    return {
+        node: nodeSchema.name,
+        outputSchema: nodeSchema.resultType,
+        ...fields,
+    };
+}
+/**
+ * Parse a node pattern.
+ */
+function parseNodePattern(node, input, context, currentLevels, nextLevels, fullGrammar) {
+    const result = parsePatternTuple(node.pattern, input, context, currentLevels, nextLevels, fullGrammar);
+    if (result.length === 0)
+        return [];
+    return [buildNodeResult(node, result[0], context), result[1]];
+}
+/**
+ * Parse with expression constraint check.
+ */
+function parseExprWithConstraint(startLevels, input, context, constraint, fullGrammar) {
+    const result = parseLevels(startLevels, input, context, fullGrammar);
+    if (result.length === 0)
+        return [];
+    const [node, remaining] = result;
+    if (constraint !== undefined) {
+        const nodeOutputSchema = node.outputSchema;
+        if (nodeOutputSchema !== constraint) {
+            return [];
+        }
+    }
+    return [node, remaining];
+}
+/**
+ * Try parsing each node in a level.
+ */
+function parseNodes(nodes, input, context, currentLevels, nextLevels, fullGrammar) {
+    for (const node of nodes) {
+        const result = parseNodePattern(node, input, context, currentLevels, nextLevels, fullGrammar);
+        if (result.length === 2)
+            return result;
+    }
+    return [];
+}
+/**
+ * Parse using grammar levels (flat tuple).
+ *
+ * levels[0] is current level, levels[1:] is next levels.
+ * Base case: single level (atoms) - just try those nodes.
+ */
+function parseLevels(levels, input, context, fullGrammar) {
+    if (levels.length === 0) {
+        return [];
+    }
+    const currentNodes = levels[0];
+    const nextLevels = levels.slice(1);
+    // Try nodes at current level
+    const result = parseNodes(currentNodes, input, context, levels, nextLevels, fullGrammar);
+    if (result.length === 2) {
+        return result;
+    }
+    // Fall through to next levels (if any)
+    if (nextLevels.length > 0) {
+        return parseLevels(nextLevels, input, context, fullGrammar);
+    }
+    return [];
+}
+// =============================================================================
+// Public API
+// =============================================================================
+/**
+ * Parse input string using node schemas.
+ *
+ * The return type is computed from the input types using the type-level
+ * Parse<Grammar, Input, Context> type, ensuring runtime and type-level
+ * parsing stay in sync.
+ */
+export function parse(nodes, input, context) {
+    const grammar = buildGrammar(nodes);
+    return parseLevels(grammar, input, context, grammar);
+}

package/dist/schema/index.d.ts

@@ -0,0 +1,273 @@
+/**
+ * Schema Types
+ *
+ * Pattern element schemas for defineNode. These are pure type descriptors
+ * that preserve literal types for compile-time grammar computation.
+ *
+ * The key insight: defineNode returns a schema object whose TYPE carries
+ * all the information needed for type-level parsing. No runtime magic.
+ */
+import type { NumberNode, StringNode, IdentNode, ConstNode } from "../primitive/index.js";
+export interface Schema<TKind extends string> {
+    readonly kind: TKind;
+}
+/** Number literal pattern element */
+export interface NumberSchema extends Schema<"number"> {
+}
+/** String literal pattern element */
+export interface StringSchema<TQuotes extends readonly string[] = readonly string[]> extends Schema<"string"> {
+    readonly quotes: TQuotes;
+}
+/** Identifier pattern element */
+export interface IdentSchema extends Schema<"ident"> {
+}
+/** Constant (exact match) pattern element */
+export interface ConstSchema<TValue extends string = string> extends Schema<"const"> {
+    readonly value: TValue;
+}
+/** Expression role determines which grammar level is used */
+export type ExprRole = "lhs" | "rhs" | "expr";
+/** Recursive expression pattern element with optional type constraint and role */
+export interface ExprSchema<
+/** This technically shouldn't require a string
+ * because JSON or array or other types could be used in the future.
+ * For now, I would prefer that we just keep it open tbh. And validate at the
+ * expr()/lhs()/rhs() usage site by
+ * using arktype.type.validate<> (see createBox example: https://arktype.io/docs/generics).
+ **/
+TConstraint extends string = string, TRole extends ExprRole = ExprRole> extends Schema<"expr"> {
+    readonly constraint?: TConstraint;
+    readonly role: TRole;
+}
+/** Base pattern schema type (without NamedSchema to avoid circular reference) */
+export type PatternSchemaBase = NumberSchema | StringSchema<readonly string[]> | IdentSchema | ConstSchema<string> | ExprSchema<string, ExprRole>;
+/**
+ * A pattern schema with a binding name.
+ * Created by calling .as(name) on any pattern element.
+ *
+ * Uses intersection so schema properties remain accessible without unwrapping.
+ *
+ * @example
+ * lhs("number").as("left")  // ExprSchema<"number", "lhs"> & { __named: true; name: "left" }
+ */
+export type NamedSchema<TSchema extends PatternSchemaBase = PatternSchemaBase, TName extends string = string> = TSchema & {
+    readonly __named: true;
+    readonly name: TName;
+};
+/** Union of all pattern element schemas (including named) */
+export type PatternSchema = PatternSchemaBase | NamedSchema;
+/**
+ * Schema wrapper with .as() method for naming bindings.
+ * All pattern factories return this type.
+ */
+export type SchemaWithAs<TSchema extends PatternSchemaBase> = TSchema & {
+    /** Add a binding name to this pattern element */
+    as<TName extends string>(name: TName): NamedSchema<TSchema, TName>;
+};
+/** Create a number literal pattern element */
+export declare const number: () => NumberSchema & {
+    as<TName extends string>(name: TName): NamedSchema<NumberSchema, TName>;
+};
+/** Create a string literal pattern element */
+export declare const string: <const TQuotes extends readonly string[]>(quotes: TQuotes) => StringSchema<TQuotes> & {
+    as<TName extends string>(name: TName): NamedSchema<StringSchema<TQuotes>, TName>;
+};
+/** Create an identifier pattern element */
+export declare const ident: () => IdentSchema & {
+    as<TName extends string>(name: TName): NamedSchema<IdentSchema, TName>;
+};
+/** Create a constant (exact match) pattern element */
+export declare const constVal: <const TValue extends string>(value: TValue) => ConstSchema<TValue> & {
+    as<TName extends string>(name: TName): NamedSchema<ConstSchema<TValue>, TName>;
+};
+/**
+ * Create a LEFT-HAND SIDE expression element.
+ *
+ * Uses TNextLevel grammar to avoid left-recursion.
+ * Must be at position 0 in a pattern.
+ *
+ * @example
+ * ```ts
+ * const add = defineNode({
+ *   pattern: [lhs("number").as("left"), constVal("+"), rhs("number").as("right")],
+ *   // lhs parses at higher precedence to avoid infinite recursion
+ * });
+ * ```
+ */
+export declare const lhs: <const TConstraint extends string>(constraint?: TConstraint) => ExprSchema<TConstraint, "lhs"> & {
+    as<TName extends string>(name: TName): NamedSchema<ExprSchema<TConstraint, "lhs">, TName>;
+};
+/**
+ * Create a RIGHT-HAND SIDE expression element.
+ *
+ * Uses TCurrentLevel grammar to maintain precedence and enable right-associativity.
+ * Used for right operands of binary operators.
+ *
+ * @example
+ * ```ts
+ * const add = defineNode({
+ *   pattern: [lhs("number").as("left"), constVal("+"), rhs("number").as("right")],
+ *   // rhs parses at same level for right-associativity: 1+2+3 = 1+(2+3)
+ * });
+ * ```
+ */
+export declare const rhs: <const TConstraint extends string>(constraint?: TConstraint) => ExprSchema<TConstraint, "rhs"> & {
+    as<TName extends string>(name: TName): NamedSchema<ExprSchema<TConstraint, "rhs">, TName>;
+};
+/**
+ * Create a FULL expression element.
+ *
+ * Uses TFullGrammar - resets to full grammar (precedence 0).
+ * Used for delimited contexts like parentheses, ternary branches, function arguments.
+ *
+ * @example
+ * ```ts
+ * const parens = defineNode({
+ *   pattern: [constVal("("), expr().as("inner"), constVal(")")],
+ *   // expr() can contain ANY expression, including low-precedence operators
+ * });
+ *
+ * const ternary = defineNode({
+ *   pattern: [lhs("boolean").as("cond"), constVal("?"), expr().as("then"), constVal(":"), expr().as("else")],
+ *   // The branches can contain any expression
+ * });
+ * ```
+ */
+export declare const expr: <const TConstraint extends string>(constraint?: TConstraint) => ExprSchema<TConstraint, "expr"> & {
+    as<TName extends string>(name: TName): NamedSchema<ExprSchema<TConstraint, "expr">, TName>;
+};
+/** Precedence type: number for operators, "atom" for atoms (literals) */
+export type Precedence = number | "atom";
+/**
+ * A node definition schema.
+ *
+ * This is the return type of defineNode. The generic parameters capture
+ * all the literal types needed for compile-time grammar computation:
+ * - TName: The unique node name (e.g., "add", "mul")
+ * - TPattern: The pattern elements as a tuple type
+ * - TPrecedence: The precedence (number for operators, "atom" for atoms)
+ * - TResultType: The result type (e.g., "number", "string")
+ */
+export interface NodeSchema<TName extends string = string, TPattern extends readonly PatternSchema[] = readonly PatternSchema[], TPrecedence extends Precedence = Precedence, TResultType extends string = string> {
+    readonly name: TName;
+    readonly pattern: TPattern;
+    readonly precedence: TPrecedence;
+    readonly resultType: TResultType;
+    /**
+     * Optional: Transform parsed bindings into node fields.
+     * If not provided, bindings are used directly as fields.
+     *
+     * @param bindings - The named values extracted from pattern via .as()
+     * @param ctx - The parse context
+     * @returns The fields to add to the AST node
+     */
+    readonly configure?: ConfigureFn;
+    /**
+     * Optional: Evaluate the AST node to produce a runtime value.
+     *
+     * @param node - The full AST node including name, outputSchema, and fields
+     * @param ctx - The evaluation context
+     * @returns The evaluated value
+     */
+    readonly eval?: EvalFn;
+}
+/** Stored function type for configure - loose for variance compatibility */
+export type ConfigureFn = <$>(bindings: Record<string, unknown>, ctx: $) => Record<string, unknown>;
+/** Stored function type for eval - loose for variance compatibility */
+export type EvalFn = <$>(values: Record<string, unknown>, ctx: $) => unknown;
+/**
+ * Define a node type for the grammar.
+ *
+ * The `const` modifier on generics ensures literal types are preserved:
+ * - name: "add" (not string)
+ * - pattern: readonly [ExprSchema<"number">, ConstSchema<"+">, ExprSchema<"number">]
+ * - precedence: 1 or "atom" (not number | "atom")
+ * - resultType: "number" (not string)
+ *
+ * @example
+ * const add = defineNode({
+ *   name: "add",
+ *   pattern: [lhs("number").as("left"), constVal("+"), rhs("number").as("right")],
+ *   precedence: 1,
+ *   resultType: "number",
+ *   eval: ({ left, right }) => left + right,  // left and right are already numbers
+ * });
+ */
+export declare function defineNode<const TName extends string, const TPattern extends readonly PatternSchema[], const TPrecedence extends Precedence, const TResultType extends string>(config: {
+    readonly name: TName;
+    readonly pattern: TPattern;
+    readonly precedence: TPrecedence;
+    readonly resultType: TResultType;
+    readonly configure?: <$>(bindings: InferBindings<TPattern>, ctx: $) => Record<string, unknown>;
+    readonly eval?: <$>(values: InferEvaluatedBindings<TPattern>, ctx: $) => SchemaToType<TResultType>;
+}): NodeSchema<TName, TPattern, TPrecedence, TResultType>;
+/** Extract the operator from a binary pattern (second element should be ConstSchema) */
+export type ExtractOperator<T extends readonly PatternSchema[]> = T extends readonly [
+    PatternSchema,
+    infer Op extends ConstSchema,
+    PatternSchema
+] ? Op["value"] : never;
+/**
+ * Map a schema type string to its TypeScript runtime type.
+ * Used for eval return types and evaluated bindings.
+ */
+export type SchemaToType<T extends string> = T extends "number" ? number : T extends "string" ? string : T extends "boolean" ? boolean : unknown;
+/**
+ * Infer the AST node type from a pattern schema.
+ * This maps schema types to their corresponding node types.
+ *
+ * Note: ExprSchema maps to `unknown` since the actual type depends on the constraint
+ * and what's parsed. The runtime parser will fill this in.
+ */
+export type InferNodeType<TSchema extends PatternSchemaBase> = TSchema extends NumberSchema ? NumberNode : TSchema extends StringSchema ? StringNode : TSchema extends IdentSchema ? IdentNode : TSchema extends ConstSchema ? ConstNode : TSchema extends ExprSchema<infer C> ? {
+    outputSchema: C;
+} : never;
+/**
+ * Infer the evaluated value type from a pattern schema.
+ * For ExprSchema, uses the constraint to determine the runtime type.
+ */
+export type InferEvaluatedType<TSchema extends PatternSchemaBase> = TSchema extends NumberSchema ? number : TSchema extends StringSchema ? string : TSchema extends IdentSchema ? unknown : TSchema extends ConstSchema ? never : TSchema extends ExprSchema<infer C extends string> ? SchemaToType<C> : never;
+/**
+ * Extract all NamedSchema entries from a pattern tuple as a union.
+ */
+type ExtractNamedSchemas<TPattern extends readonly PatternSchema[]> = TPattern[number] extends infer E ? E extends NamedSchema<infer S, infer N> ? {
+    schema: S;
+    name: N;
+} : never : never;
+/**
+ * Infer bindings object type from a pattern (AST nodes).
+ * Used for configure() - receives parsed AST nodes.
+ *
+ * @example
+ * ```ts
+ * type Pattern = [
+ *   NamedSchema<ExprSchema<"number", "lhs">, "left">,
+ *   ConstSchema<"+">,
+ *   NamedSchema<ExprSchema<"number", "rhs">, "right">
+ * ];
+ * type Bindings = InferBindings<Pattern>;
+ * // { left: { outputSchema: "number" }; right: { outputSchema: "number" } }
+ * ```
+ */
+export type InferBindings<TPattern extends readonly PatternSchema[]> = {
+    [K in ExtractNamedSchemas<TPattern> as K["name"]]: InferNodeType<K["schema"]>;
+};
+/**
+ * Infer evaluated bindings from a pattern (runtime values).
+ * Used for eval() - receives already-evaluated values.
+ *
+ * @example
+ * ```ts
+ * type Pattern = [
+ *   NamedSchema<ExprSchema<"number", "lhs">, "left">,
+ *   ConstSchema<"+">,
+ *   NamedSchema<ExprSchema<"number", "rhs">, "right">
+ * ];
+ * type EvalBindings = InferEvaluatedBindings<Pattern>;
+ * // { left: number; right: number }
+ * ```
+ */
+export type InferEvaluatedBindings<TPattern extends readonly PatternSchema[]> = {
+    [K in ExtractNamedSchemas<TPattern> as K["name"]]: InferEvaluatedType<K["schema"]>;
+};
+export {};

package/dist/schema/index.js

@@ -0,0 +1,111 @@
+/**
+ * Schema Types
+ *
+ * Pattern element schemas for defineNode. These are pure type descriptors
+ * that preserve literal types for compile-time grammar computation.
+ *
+ * The key insight: defineNode returns a schema object whose TYPE carries
+ * all the information needed for type-level parsing. No runtime magic.
+ */
+/** Create a schema wrapper with .as() method */
+function withAs(schema) {
+    return Object.assign(schema, {
+        as(name) {
+            return { ...schema, __named: true, name };
+        },
+    });
+}
+// =============================================================================
+// Pattern Element Factories
+// =============================================================================
+/** Create a number literal pattern element */
+export const number = () => withAs({ kind: "number" });
+/** Create a string literal pattern element */
+export const string = (quotes) => withAs({ kind: "string", quotes });
+/** Create an identifier pattern element */
+export const ident = () => withAs({ kind: "ident" });
+/** Create a constant (exact match) pattern element */
+export const constVal = (value) => withAs({ kind: "const", value });
+/**
+ * Create a LEFT-HAND SIDE expression element.
+ *
+ * Uses TNextLevel grammar to avoid left-recursion.
+ * Must be at position 0 in a pattern.
+ *
+ * @example
+ * ```ts
+ * const add = defineNode({
+ *   pattern: [lhs("number").as("left"), constVal("+"), rhs("number").as("right")],
+ *   // lhs parses at higher precedence to avoid infinite recursion
+ * });
+ * ```
+ */
+export const lhs = (constraint) => withAs({
+    kind: "expr",
+    constraint: constraint,
+    role: "lhs",
+});
+/**
+ * Create a RIGHT-HAND SIDE expression element.
+ *
+ * Uses TCurrentLevel grammar to maintain precedence and enable right-associativity.
+ * Used for right operands of binary operators.
+ *
+ * @example
+ * ```ts
+ * const add = defineNode({
+ *   pattern: [lhs("number").as("left"), constVal("+"), rhs("number").as("right")],
+ *   // rhs parses at same level for right-associativity: 1+2+3 = 1+(2+3)
+ * });
+ * ```
+ */
+export const rhs = (constraint) => withAs({
+    kind: "expr",
+    constraint: constraint,
+    role: "rhs",
+});
+/**
+ * Create a FULL expression element.
+ *
+ * Uses TFullGrammar - resets to full grammar (precedence 0).
+ * Used for delimited contexts like parentheses, ternary branches, function arguments.
+ *
+ * @example
+ * ```ts
+ * const parens = defineNode({
+ *   pattern: [constVal("("), expr().as("inner"), constVal(")")],
+ *   // expr() can contain ANY expression, including low-precedence operators
+ * });
+ *
+ * const ternary = defineNode({
+ *   pattern: [lhs("boolean").as("cond"), constVal("?"), expr().as("then"), constVal(":"), expr().as("else")],
+ *   // The branches can contain any expression
+ * });
+ * ```
+ */
+export const expr = (constraint) => withAs({
+    kind: "expr",
+    constraint: constraint,
+    role: "expr",
+});
+/**
+ * Define a node type for the grammar.
+ *
+ * The `const` modifier on generics ensures literal types are preserved:
+ * - name: "add" (not string)
+ * - pattern: readonly [ExprSchema<"number">, ConstSchema<"+">, ExprSchema<"number">]
+ * - precedence: 1 or "atom" (not number | "atom")
+ * - resultType: "number" (not string)
+ *
+ * @example
+ * const add = defineNode({
+ *   name: "add",
+ *   pattern: [lhs("number").as("left"), constVal("+"), rhs("number").as("right")],
+ *   precedence: 1,
+ *   resultType: "number",
+ *   eval: ({ left, right }) => left + right,  // left and right are already numbers
+ * });
+ */
+export function defineNode(config) {
+    return config;
+}

package/dist/static/infer.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Type-Level Inference
+ *
+ * Infer<AST, Context> computes the result type of a parsed AST.
+ *
+ * With the new architecture, nodes carry their outputSchema directly,
+ * so inference is simpler - just extract the outputSchema field.
+ */
+import type { Context } from "../context.js";
+/**
+ * Infer the result type of an AST node.
+ *
+ * Nodes now carry their outputSchema directly:
+ * - NumberNode has outputSchema: "number"
+ * - BinaryNode<Name, Left, Right, OutputSchema> has outputSchema: OutputSchema
+ * - IdentNode<Name, OutputSchema> has outputSchema: OutputSchema
+ *
+ * @example
+ * ```ts
+ * type Num = Infer<NumberNode<"42">, {}>;  // "number"
+ * type Add = Infer<BinaryNode<"add", NumberNode<"1">, NumberNode<"2">, "number">, {}>; // "number"
+ * ```
+ */
+export type Infer<AST, $ extends Context> = AST extends {
+    outputSchema: infer R extends string;
+} ? R : never;

package/dist/static/infer.js

@@ -0,0 +1,9 @@
+/**
+ * Type-Level Inference
+ *
+ * Infer<AST, Context> computes the result type of a parsed AST.
+ *
+ * With the new architecture, nodes carry their outputSchema directly,
+ * so inference is simpler - just extract the outputSchema field.
+ */
+export {};