@manifesto-ai/compiler 1.8.3 → 1.9.1

package/dist/analyzer/entity-primitives.d.ts

@@ -0,0 +1,3 @@
+import { type Diagnostic } from "../diagnostics/types.js";
+import type { ProgramNode } from "../parser/ast.js";
+export declare function validateEntityPrimitives(program: ProgramNode): Diagnostic[];

package/dist/analyzer/expr-type-surface.d.ts

@@ -0,0 +1,21 @@
+import type { ComputedNode, DomainNode, ExprNode, ParamNode, TypeDeclNode, TypeExprNode } from "../parser/ast.js";
+export type TypeEnv = Map<string, TypeExprNode>;
+export type ComparableSurfaceClass = "primitive" | "nonprimitive" | "unknown";
+export interface DomainTypeSymbols {
+    stateTypes: Map<string, TypeExprNode>;
+    computedDecls: Map<string, ComputedNode>;
+    typeDefs: Map<string, TypeDeclNode>;
+    computedTypeCache: Map<string, TypeExprNode | null>;
+    computedTypeInFlight: Set<string>;
+}
+export declare function collectDomainTypeSymbols(domain: DomainNode): DomainTypeSymbols;
+export declare function createActionTypeEnv(params: readonly ParamNode[]): TypeEnv;
+export declare function inferExprType(expr: ExprNode, env: TypeEnv, symbols: DomainTypeSymbols): TypeExprNode | null;
+export declare function classifyComparableExpr(expr: ExprNode, env: TypeEnv, symbols: DomainTypeSymbols): ComparableSurfaceClass;
+export declare function classifyComparableType(typeExpr: TypeExprNode | null, symbols: DomainTypeSymbols): ComparableSurfaceClass;
+export declare function resolveType(typeExpr: TypeExprNode | null, symbols: DomainTypeSymbols, seen?: Set<string>): TypeExprNode | null;
+export declare function getPropertyType(typeExpr: TypeExprNode | null, property: string, symbols: DomainTypeSymbols): TypeExprNode | null;
+export declare function getIndexType(typeExpr: TypeExprNode | null, symbols: DomainTypeSymbols): TypeExprNode | null;
+export declare function getArrayElementType(typeExpr: TypeExprNode | null, symbols: DomainTypeSymbols): TypeExprNode | null;
+export declare function isPrimitiveEntityIdType(typeExpr: TypeExprNode, symbols: DomainTypeSymbols): boolean;
+export declare function isNullType(typeExpr: TypeExprNode): boolean;

package/dist/analyzer/flow-composition.d.ts

@@ -0,0 +1,7 @@
+import { type Diagnostic } from "../diagnostics/types.js";
+import type { ProgramNode } from "../parser/ast.js";
+export interface FlowExpansionResult {
+    program: ProgramNode;
+    diagnostics: Diagnostic[];
+}
+export declare function validateAndExpandFlows(program: ProgramNode): FlowExpansionResult;

package/dist/analyzer/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Analyzer Module - Semantic analysis for MEL
+ */
+export * from "./scope.js";
+export * from "./validator.js";

package/dist/analyzer/scope.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Scope Analysis for MEL
+ * Tracks variable scopes and resolves identifiers
+ * Based on MEL SPEC v0.3.1 Section 4.10
+ */
+import type { ProgramNode } from "../parser/ast.js";
+import type { Diagnostic } from "../diagnostics/types.js";
+import type { SourceLocation } from "../lexer/source-location.js";
+/**
+ * Symbol kinds
+ */
+export type SymbolKind = "state" | "computed" | "param" | "action" | "iteration";
+/**
+ * Symbol information
+ */
+export interface Symbol {
+    name: string;
+    kind: SymbolKind;
+    location: SourceLocation;
+    type?: string;
+}
+/**
+ * Scope represents a lexical scope
+ */
+export declare class Scope {
+    readonly parent: Scope | null;
+    readonly symbols: Map<string, Symbol>;
+    readonly kind: "domain" | "action" | "guard";
+    constructor(kind: "domain" | "action" | "guard", parent?: Scope | null);
+    /**
+     * Define a new symbol in this scope
+     */
+    define(symbol: Symbol): void;
+    /**
+     * Look up a symbol, searching parent scopes if not found
+     */
+    lookup(name: string): Symbol | undefined;
+    /**
+     * Check if a symbol is defined in this scope (not parent scopes)
+     */
+    isDefined(name: string): boolean;
+}
+/**
+ * Result of scope analysis
+ */
+export interface ScopeAnalysisResult {
+    scopes: Map<string, Scope>;
+    diagnostics: Diagnostic[];
+}
+/**
+ * Scope Analyzer - builds scope tree and checks for errors
+ */
+export declare class ScopeAnalyzer {
+    private diagnostics;
+    private scopes;
+    private currentScope;
+    private domainScope;
+    /**
+     * Analyze a MEL program
+     */
+    analyze(program: ProgramNode): ScopeAnalysisResult;
+    private analyzeDomain;
+    private analyzeComputedExpr;
+    private analyzeAction;
+    private analyzeStmt;
+    private analyzeExpr;
+    private checkIdentifier;
+    private checkSystemIdent;
+    private validatePath;
+    private defineSymbol;
+    private error;
+}
+/**
+ * Analyze a MEL program for scope issues
+ */
+export declare function analyzeScope(program: ProgramNode): ScopeAnalysisResult;

package/dist/analyzer/validator.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Semantic Validator for MEL
+ * Validates semantic rules beyond syntax
+ * Based on MEL SPEC v0.3.3 and FDR-MEL-*
+ */
+import type { ProgramNode } from "../parser/ast.js";
+import type { Diagnostic } from "../diagnostics/types.js";
+/**
+ * Result of semantic validation
+ */
+export interface ValidationResult {
+    valid: boolean;
+    diagnostics: Diagnostic[];
+}
+/**
+ * Semantic Validator
+ */
+export declare class SemanticValidator {
+    private ctx;
+    private symbols;
+    /**
+     * Validate a MEL program
+     */
+    validate(program: ProgramNode): ValidationResult;
+    private validateDomain;
+    /**
+     * v0.3.3: Validate state fields for W012 (anonymous object types)
+     */
+    private validateState;
+    /**
+     * v0.3.3: Validate state field - check for anonymous object types (W012)
+     */
+    private validateStateField;
+    private validateStateInitializer;
+    /**
+     * v0.3.3: Check if a type expression contains anonymous object types
+     * Issues W012 warning for inline object types in state fields
+     */
+    private checkAnonymousObjectType;
+    private validateAction;
+    /**
+     * v0.3.3: Validate available expression is pure (E005)
+     * No $system.*, no effects, no $input.*
+     */
+    private validateAvailableExpr;
+    private validateGuardedStmt;
+    private validateWhen;
+    private validateOnce;
+    private validateOnceIntent;
+    private validatePatch;
+    private validateEffect;
+    private validateFail;
+    private validateStop;
+    private validateCondition;
+    private validateExpr;
+    private validateFunctionCall;
+    private validatePrimitiveEquality;
+    private inferType;
+    private requireAssignable;
+    private requireArrayCompatible;
+    private requireLenCompatible;
+    private validateCoalesceTypes;
+    private error;
+    private warn;
+}
+/**
+ * Validate a MEL program semantically
+ */
+export declare function validateSemantics(program: ProgramNode): ValidationResult;

package/dist/api/compile-mel-patch-collector.d.ts

@@ -0,0 +1,33 @@
+import type { Diagnostic } from "../diagnostics/types.js";
+import type { MelExprNode } from "../lowering/lower-expr.js";
+import type { MelIRPatchPath } from "../lowering/lower-runtime-patch.js";
+import type { GuardedStmtNode, InnerStmtNode, PatchStmtNode } from "../parser/ast.js";
+import { toMelExpr } from "./compile-mel-patch-expr.js";
+export interface PatchCollectContext {
+    actionName: string;
+    onceCounter: number;
+    onceIntentCounter: number;
+    whenCounter: number;
+}
+export type ConditionedPatchStatement = {
+    patch: PatchStmtNode;
+    condition?: MelExprNode;
+};
+export interface PatchCollectorDeps {
+    toMelExpr: (expr: Parameters<typeof toMelExpr>[0]) => MelExprNode;
+    mapLocation: (location: Diagnostic["location"]) => Diagnostic["location"];
+}
+export declare class PatchStatementCollector {
+    private readonly deps;
+    private readonly conditionComposer;
+    private readonly exprValidator;
+    constructor(deps: PatchCollectorDeps);
+    collect(stmts: GuardedStmtNode[] | InnerStmtNode[], errors: Diagnostic[], context: PatchCollectContext, parentCondition: MelExprNode | undefined): ConditionedPatchStatement[];
+    private collectPatchStatements;
+}
+export declare function compilePatchStmtToMelRuntime(patchStatement: ConditionedPatchStatement): {
+    op: "set" | "unset" | "merge";
+    path: MelIRPatchPath;
+    value?: MelExprNode;
+    condition?: MelExprNode;
+};

package/dist/api/compile-mel-patch-expr.d.ts

@@ -0,0 +1,8 @@
+import type { ExprNode } from "../parser/ast.js";
+import type { MelExprNode } from "../lowering/lower-expr.js";
+export declare function isSyntheticPatchCondition(condition: ExprNode): condition is (ExprNode & {
+    kind: "literal";
+    literalType: "boolean";
+    value: true;
+});
+export declare function toMelExpr(input: ExprNode): MelExprNode;

package/dist/api/compile-mel-patch-location.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Location mapping helpers for compile-mel-patch synthetic wrapper diagnostics.
+ */
+import type { Diagnostic } from "../diagnostics/types.js";
+export declare const SYNTHETIC_PATCH_PREFIX_LINES = 3;
+export declare const SYNTHETIC_PATCH_PREFIX_COLUMNS = 6;
+export declare function computeLineStartOffsets(lines: string[]): number[];
+export declare function makePatchLocationMapper(patchLines: string[], patchLineStarts: number[]): (location: Diagnostic["location"]) => Diagnostic["location"];
+export declare function remapDiagnosticsToPatchSource(diagnostics: Diagnostic[], patchLines: string[], patchLineStarts: number[]): Diagnostic[];

package/dist/api/compile-mel-patch.d.ts

@@ -0,0 +1,5 @@
+import type { CompileMelPatchOptions, CompileMelPatchResult } from "./compile-mel.js";
+/**
+ * Compile MEL patch text into RuntimeConditionalPatchOps.
+ */
+export declare function compileMelPatchText(melText: string, options: CompileMelPatchOptions): CompileMelPatchResult;

package/dist/api/compile-mel.d.ts

@@ -0,0 +1,125 @@
+/**
+ * MEL Text Ingest API
+ *
+ * Compiles MEL text to DomainSchema or RuntimeConditionalPatchOp[].
+ *
+ * @see SPEC v0.4.0 §19
+ */
+import type { Diagnostic } from "../diagnostics/types.js";
+import type { DomainSchema } from "../generator/ir.js";
+import type { RuntimeConditionalPatchOp } from "../lowering/lower-runtime-patch.js";
+/**
+ * Trace entry for compilation steps.
+ */
+export interface CompileTrace {
+    phase: "lex" | "parse" | "analyze" | "generate" | "lower";
+    durationMs: number;
+    details?: Record<string, unknown>;
+}
+/**
+ * Domain compilation options.
+ */
+export interface CompileMelDomainOptions {
+    mode: "domain";
+    fnTableVersion?: string;
+}
+/**
+ * Domain compilation result.
+ *
+ * @see SPEC v0.4.0 §19.1
+ */
+export interface CompileMelDomainResult {
+    /**
+     * Compiled schema, or null if errors occurred.
+     */
+    schema: DomainSchema | null;
+    /**
+     * Compilation trace.
+     */
+    trace: CompileTrace[];
+    /**
+     * Warning diagnostics.
+     */
+    warnings: Diagnostic[];
+    /**
+     * Error diagnostics.
+     */
+    errors: Diagnostic[];
+}
+/**
+ * Patch compilation options.
+ */
+export interface CompileMelPatchOptions {
+    mode: "patch";
+    /**
+     * Action name for context.
+     */
+    actionName: string;
+    /**
+     * Allowed system path prefixes.
+     * Default: ["meta", "input"] (system is forbidden per §20.3).
+     */
+    allowSysPaths?: {
+        prefixes: ("meta" | "input")[];
+    };
+    /**
+     * Function table version.
+     */
+    fnTableVersion?: string;
+}
+/**
+ * Patch compilation result.
+ *
+ * @see SPEC v0.4.0 §19.2
+ */
+export interface CompileMelPatchResult {
+    /**
+     * Compiled patch operations.
+     * These still contain Core IR expressions that need evaluation.
+     */
+    ops: RuntimeConditionalPatchOp[];
+    /**
+     * Compilation trace.
+     */
+    trace: CompileTrace[];
+    /**
+     * Warning diagnostics.
+     */
+    warnings: Diagnostic[];
+    /**
+     * Error diagnostics.
+     */
+    errors: Diagnostic[];
+}
+/**
+ * Compile MEL text to DomainSchema.
+ *
+ * Takes a complete MEL domain definition and produces a DomainSchema
+ * suitable for use with core.compute().
+ *
+ * @param melText - MEL domain source text
+ * @param options - Compilation options
+ * @returns Compilation result with schema or errors
+ *
+ * @see SPEC v0.4.0 §19.1
+ */
+export declare function compileMelDomain(melText: string, options?: CompileMelDomainOptions): CompileMelDomainResult;
+/**
+ * Compile MEL patch text to RuntimeConditionalPatchOp[].
+ *
+ * Takes MEL patch statements (set, unset, merge) and produces
+ * RuntimeConditionalPatchOp[] with Core IR expressions.
+ *
+ * The returned ops still contain expressions that need to be evaluated
+ * by evaluateRuntimePatches() to get concrete values.
+ *
+ * Constraints:
+ * - §20.3: $system.* is forbidden in Translator path
+ *
+ * @param melText - MEL patch source text
+ * @param options - Compilation options
+ * @returns Compilation result with ops or errors
+ *
+ * @see SPEC v0.4.0 §19.2
+ */
+export declare function compileMelPatch(melText: string, options: CompileMelPatchOptions): CompileMelPatchResult;

package/dist/api/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Compile API
+ *
+ * MEL text ingest functions.
+ *
+ * @see SPEC v0.4.0 §19
+ */
+export type { CompileTrace, CompileMelDomainOptions, CompileMelDomainResult, CompileMelPatchOptions, CompileMelPatchResult, } from "./compile-mel.js";
+export { compileMelDomain, compileMelPatch } from "./compile-mel.js";

package/dist/{chunk-4JJQCFJH.js → chunk-7TT6Y5ZC.js}

@@ -4923,7 +4923,11 @@ function toMelBinaryOp(op) {
 }
 
 // src/generator/ir.ts
-import { hashSchemaSync, semanticPathToPatchPath, sha256Sync } from "@manifesto-ai/core";
+import {
+  hashSchemaSync,
+  semanticPathToPatchPath,
+  sha256Sync
+} from "@manifesto-ai/core";
 
 // src/generator/runtime-lowering.ts
 var ENTITY_PRIMITIVES = /* @__PURE__ */ new Set(["findById", "existsById", "updateById", "removeById"]);
@@ -7628,4 +7632,4 @@ export {
   compileMelDomain,
   compileMelPatch
 };
-//# sourceMappingURL=chunk-4JJQCFJH.js.map
+//# sourceMappingURL=chunk-7TT6Y5ZC.js.map