@manifesto-ai/compiler 3.7.1 → 3.9.0

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

@@ -1,4 +1,7 @@
 import type { ComputedNode, DomainNode, ExprNode, ParamNode, TypeDeclNode, TypeExprNode } from "../parser/ast.js";
+import type { SpreadOperandClassification } from "./object-contribution-types.js";
+export type { SpreadOperandClassification, } from "./object-contribution-types.js";
+export { mayYieldArrayExpr } from "./object-contribution-types.js";
 export type TypeEnv = Map<string, TypeExprNode>;
 export type ComparableSurfaceClass = "primitive" | "nonprimitive" | "unknown";
 export interface DomainTypeSymbols {
@@ -19,3 +22,4 @@ export declare function getIndexType(typeExpr: TypeExprNode | null, symbols: Dom
 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;
+export declare function classifySpreadOperandType(typeExpr: TypeExprNode | null, symbols: DomainTypeSymbols): SpreadOperandClassification;

package/dist/analyzer/object-contribution-types.d.ts

@@ -0,0 +1,19 @@
+import type { ExprNode, TypeExprNode } from "../parser/ast.js";
+export type SpreadOperandClassification = "object" | "nullable-object" | "invalid" | "unknown";
+type InferExprType<Env, Symbols> = (expr: ExprNode, env: Env, symbols: Symbols) => TypeExprNode | null;
+type ResolveType<Symbols> = (typeExpr: TypeExprNode | null, symbols: Symbols) => TypeExprNode | null;
+type ExprTypeContext<Env, Symbols> = {
+    env: Env;
+    symbols: Symbols;
+    inferExprType: InferExprType<Env, Symbols>;
+    resolveType: ResolveType<Symbols>;
+};
+export declare function inferObjectLiteralContributionType<Env, Symbols>(expr: Extract<ExprNode, {
+    kind: "objectLiteral";
+}>, env: Env, symbols: Symbols, inferExprType: InferExprType<Env, Symbols>, resolveType: ResolveType<Symbols>): TypeExprNode | null;
+export declare function inferMergeContributionType<Env, Symbols>(expr: Extract<ExprNode, {
+    kind: "functionCall";
+}>, env: Env, symbols: Symbols, inferExprType: InferExprType<Env, Symbols>, resolveType: ResolveType<Symbols>): TypeExprNode | null;
+export declare function classifySpreadOperandType<Symbols>(typeExpr: TypeExprNode | null, symbols: Symbols, resolveType: ResolveType<Symbols>): SpreadOperandClassification;
+export declare function mayYieldArrayExpr<Env, Symbols>(expr: ExprNode | undefined, context?: ExprTypeContext<Env, Symbols>): boolean;
+export {};

package/dist/analyzer/validator.d.ts

@@ -64,6 +64,7 @@ export declare class SemanticValidator {
     private requireAssignable;
     private requireArrayCompatible;
     private requireLenCompatible;
+    private requireSpreadOperand;
     private validateCoalesceTypes;
     private validateMatchCall;
     private validateArgSelectionCall;

package/dist/api/compile-fragment-edit-result.d.ts

@@ -0,0 +1,12 @@
+import type { LocalTargetKey } from "../annotations.js";
+import type { Diagnostic } from "../diagnostics/types.js";
+import type { MelEditResult, MelTextEdit } from "./compile-fragment-types.js";
+export type MaterializedEdit = {
+    readonly edits: readonly MelTextEdit[];
+    readonly changedTargets: readonly LocalTargetKey[];
+    readonly diagnostics: readonly Diagnostic[];
+};
+export declare function validateThenEdit(diagnostics: readonly Diagnostic[], makeEdit: () => MaterializedEdit): MaterializedEdit;
+export declare function preMaterializationFailure(baseSource: string, diagnostics: readonly Diagnostic[]): MelEditResult;
+export declare function materializationSuccess(edits: readonly MelTextEdit[], changedTargets: readonly LocalTargetKey[]): MaterializedEdit;
+export declare function materializationFailure(...diagnostics: Diagnostic[]): MaterializedEdit;

package/dist/api/compile-fragment-in-context.d.ts

@@ -0,0 +1,3 @@
+import type { CompileFragmentInContextOptions, MelEditOp, MelEditResult } from "./compile-fragment-types.js";
+export type { CompileFragmentInContextOptions, MelEditAddActionOp, MelEditAddAvailableOp, MelEditAddComputedOp, MelEditAddDispatchableOp, MelEditAddStateFieldOp, MelEditAddTypeOp, MelEditOp, MelEditRemoveDeclarationOp, MelEditRenameDeclarationOp, MelEditReplaceActionBodyOp, MelEditReplaceAvailableOp, MelEditReplaceComputedExprOp, MelEditReplaceDispatchableOp, MelEditReplaceStateDefaultOp, MelEditReplaceTypeFieldOp, MelEditResult, MelParamSource, MelTextEdit, SchemaDiff, SchemaModifiedTarget, } from "./compile-fragment-types.js";
+export declare function compileFragmentInContext(baseSource: string, op: MelEditOp, options?: CompileFragmentInContextOptions): MelEditResult;

package/dist/api/compile-fragment-json-validation.d.ts

@@ -0,0 +1,13 @@
+import type { JsonLiteral } from "../annotations.js";
+import type { Diagnostic } from "../diagnostics/types.js";
+type JsonLiteralSnapshot = {
+    readonly ok: true;
+    readonly value: JsonLiteral;
+    readonly diagnostics: readonly Diagnostic[];
+} | {
+    readonly ok: false;
+    readonly diagnostics: readonly Diagnostic[];
+};
+export declare function validateJsonLiteralFragment(value: unknown, label: string): Diagnostic[];
+export declare function snapshotJsonLiteralFragment(value: unknown, label: string): JsonLiteralSnapshot;
+export {};

package/dist/api/compile-fragment-options-validation.d.ts

@@ -0,0 +1,15 @@
+import type { Diagnostic } from "../diagnostics/types.js";
+export type CompileFragmentOptionsSnapshot = {
+    readonly baseModuleSourceHash: string | null;
+    readonly includeModule: boolean;
+    readonly includeSchemaDiff: boolean;
+};
+type OptionsSnapshotRead = {
+    readonly ok: true;
+    readonly value: CompileFragmentOptionsSnapshot;
+} | {
+    readonly ok: false;
+    readonly diagnostic: Diagnostic;
+};
+export declare function snapshotCompileFragmentOptions(options: unknown): OptionsSnapshotRead;
+export {};

package/dist/api/compile-fragment-reference-collector.d.ts

@@ -0,0 +1,3 @@
+import type { ProgramNode } from "../parser/index.js";
+import type { OffsetRange, ReferenceSpan, TargetInfo } from "./compile-fragment-reference-types.js";
+export declare function collectTargetReferences(source: string, program: ProgramNode, target: TargetInfo, ignoreRange?: OffsetRange): ReferenceSpan[];

package/dist/api/compile-fragment-reference-types.d.ts

@@ -0,0 +1,40 @@
+import type { LocalTargetKey } from "../annotations.js";
+import type { ProgramNode } from "../parser/index.js";
+import type { MelTextEdit } from "./compile-fragment-types.js";
+export type DeclarationEditPlan = {
+    readonly ok: true;
+    readonly edits: readonly MelTextEdit[];
+    readonly changedTargets: readonly LocalTargetKey[];
+} | {
+    readonly ok: false;
+    readonly code: DeclarationEditFailureCode;
+    readonly message: string;
+    readonly location: ProgramNode["location"];
+};
+export type DeclarationEditFailureCode = "E_REMOVE_BLOCKED_BY_REFERENCES" | "E_UNSAFE_RENAME_AMBIGUOUS" | "E_TARGET_NOT_FOUND" | "E_FRAGMENT_SCOPE_VIOLATION";
+export type TargetInfo = {
+    readonly kind: "type";
+    readonly name: string;
+} | {
+    readonly kind: "state_field";
+    readonly name: string;
+} | {
+    readonly kind: "computed";
+    readonly name: string;
+} | {
+    readonly kind: "action";
+    readonly name: string;
+} | {
+    readonly kind: "type_field";
+    readonly typeName: string;
+    readonly fieldName: string;
+};
+export type ReferenceSpan = {
+    readonly range: OffsetRange;
+    readonly location: ProgramNode["location"];
+    readonly rewrite: boolean;
+};
+export type OffsetRange = {
+    readonly start: number;
+    readonly end: number;
+};

package/dist/api/compile-fragment-reference-utils.d.ts

@@ -0,0 +1,5 @@
+import type { LocalTargetKey } from "../annotations.js";
+import type { ProgramNode } from "../parser/index.js";
+import type { DeclarationEditPlan } from "./compile-fragment-reference-types.js";
+export declare function planRemoveDeclaration(source: string, program: ProgramNode, target: LocalTargetKey): DeclarationEditPlan;
+export declare function planRenameDeclaration(source: string, program: ProgramNode, target: LocalTargetKey, newName: string): DeclarationEditPlan;

package/dist/api/compile-fragment-source-utils.d.ts

@@ -0,0 +1,36 @@
+import type { JsonLiteral, LocalTargetKey } from "../annotations.js";
+import type { DomainSchema } from "../generator/ir.js";
+import { type Token } from "../lexer/index.js";
+import type { ActionNode, ComputedNode, ProgramNode, StateFieldNode, TypeDeclNode, TypeFieldNode } from "../parser/index.js";
+import { type SourcePoint } from "../source-map.js";
+import type { MelEditAddActionOp, MelTextEdit, SchemaDiff } from "./compile-fragment-types.js";
+export declare function findAction(program: ProgramNode, name: string): ActionNode | null;
+export declare function findComputed(program: ProgramNode, name: string): ComputedNode | null;
+export declare function findStateField(program: ProgramNode, name: string): StateFieldNode | null;
+export declare function findTypeDecl(program: ProgramNode, name: string): TypeDeclNode | null;
+export declare function findTypeField(program: ProgramNode, typeName: string, fieldName: string): TypeFieldNode | null;
+export declare function parseTypeFieldTarget(target: `type_field:${string}.${string}`): {
+    typeName: string;
+    fieldName: string;
+} | null;
+export declare function targetLocation(program: ProgramNode, target: LocalTargetKey): ProgramNode["location"];
+export declare function findActionBodyBraces(source: string, action: ActionNode): {
+    open: Token;
+    close: Token;
+} | null;
+export declare function findActionToken(source: string, action: ActionNode, kind: Token["kind"]): Token | null;
+export declare function insertBeforeClosingLine(source: string, closeOffset: number, text: string): MelTextEdit;
+export declare function textEdit(source: string, start: number, end: number, replacement: string): MelTextEdit;
+export declare function applyTextEdits(source: string, edits: readonly MelTextEdit[]): string;
+export declare function requiredOffset(point: SourcePoint): number;
+export declare function lineIndentAt(source: string, offset: number): string;
+export declare function indentLines(source: string, indent: string): string;
+export declare function renderAction(op: MelEditAddActionOp): string;
+export declare function renderBodyReplacement(body: string, bodyIndent: string, actionIndent: string): string;
+export declare function renderJsonLiteral(value: JsonLiteral): string;
+export declare function diffSchemas(before: DomainSchema, after: DomainSchema): SchemaDiff;
+export declare function sortTargets(targets: readonly LocalTargetKey[]): LocalTargetKey[];
+export declare function isEditObject(value: unknown): value is {
+    readonly kind: string;
+};
+export declare function describeUnknown(value: unknown): string;

package/dist/api/compile-fragment-types.d.ts

@@ -0,0 +1,109 @@
+import type { DomainModule, JsonLiteral, LocalTargetKey } from "../annotations.js";
+import type { SourceSpan } from "../source-map.js";
+import type { Diagnostic } from "../diagnostics/types.js";
+export interface CompileFragmentInContextOptions {
+    readonly baseModule?: DomainModule;
+    readonly includeModule?: boolean;
+    readonly includeSchemaDiff?: boolean;
+}
+export interface MelEditResult {
+    readonly ok: boolean;
+    readonly newSource: string;
+    readonly diagnostics: readonly Diagnostic[];
+    readonly module?: DomainModule;
+    readonly changedTargets: readonly LocalTargetKey[];
+    readonly edits: readonly MelTextEdit[];
+    readonly schemaDiff?: SchemaDiff;
+}
+export interface MelTextEdit {
+    readonly range: SourceSpan;
+    readonly replacement: string;
+}
+export interface SchemaDiff {
+    readonly addedTargets: readonly LocalTargetKey[];
+    readonly removedTargets: readonly LocalTargetKey[];
+    readonly modifiedTargets: readonly SchemaModifiedTarget[];
+}
+export interface SchemaModifiedTarget {
+    readonly target: LocalTargetKey;
+    readonly beforeHash: string;
+    readonly afterHash: string;
+    readonly before?: unknown;
+    readonly after?: unknown;
+}
+export type MelParamSource = {
+    readonly name: string;
+    readonly type: string;
+};
+export type MelEditOp = MelEditAddTypeOp | MelEditAddStateFieldOp | MelEditAddComputedOp | MelEditAddActionOp | MelEditAddAvailableOp | MelEditAddDispatchableOp | MelEditReplaceActionBodyOp | MelEditReplaceComputedExprOp | MelEditReplaceAvailableOp | MelEditReplaceDispatchableOp | MelEditReplaceStateDefaultOp | MelEditReplaceTypeFieldOp | MelEditRemoveDeclarationOp | MelEditRenameDeclarationOp;
+export type MelEditAddTypeOp = {
+    readonly kind: "addType";
+    readonly name: string;
+    readonly expr: string;
+};
+export type MelEditAddStateFieldOp = {
+    readonly kind: "addStateField";
+    readonly name: string;
+    readonly type: string;
+    readonly defaultValue: JsonLiteral;
+};
+export type MelEditAddComputedOp = {
+    readonly kind: "addComputed";
+    readonly name: string;
+    readonly expr: string;
+};
+export type MelEditAddActionOp = {
+    readonly kind: "addAction";
+    readonly name: string;
+    readonly params: readonly MelParamSource[];
+    readonly body: string;
+};
+export type MelEditAddAvailableOp = {
+    readonly kind: "addAvailable";
+    readonly target: `action:${string}`;
+    readonly expr: string;
+};
+export type MelEditAddDispatchableOp = {
+    readonly kind: "addDispatchable";
+    readonly target: `action:${string}`;
+    readonly expr: string;
+};
+export type MelEditReplaceActionBodyOp = {
+    readonly kind: "replaceActionBody";
+    readonly target: `action:${string}`;
+    readonly body: string;
+};
+export type MelEditReplaceComputedExprOp = {
+    readonly kind: "replaceComputedExpr";
+    readonly target: `computed:${string}`;
+    readonly expr: string;
+};
+export type MelEditReplaceAvailableOp = {
+    readonly kind: "replaceAvailable";
+    readonly target: `action:${string}`;
+    readonly expr: string | null;
+};
+export type MelEditReplaceDispatchableOp = {
+    readonly kind: "replaceDispatchable";
+    readonly target: `action:${string}`;
+    readonly expr: string | null;
+};
+export type MelEditReplaceStateDefaultOp = {
+    readonly kind: "replaceStateDefault";
+    readonly target: `state_field:${string}`;
+    readonly value: JsonLiteral;
+};
+export type MelEditReplaceTypeFieldOp = {
+    readonly kind: "replaceTypeField";
+    readonly target: `type_field:${string}.${string}`;
+    readonly type: string;
+};
+export type MelEditRemoveDeclarationOp = {
+    readonly kind: "removeDeclaration";
+    readonly target: LocalTargetKey;
+};
+export type MelEditRenameDeclarationOp = {
+    readonly kind: "renameDeclaration";
+    readonly target: LocalTargetKey;
+    readonly newName: string;
+};

package/dist/api/compile-fragment-validation.d.ts

@@ -0,0 +1,52 @@
+import type { DomainModule, LocalTargetKey } from "../annotations.js";
+import { type Diagnostic } from "../diagnostics/types.js";
+import { type ProgramNode } from "../parser/index.js";
+import type { MelParamSource } from "./compile-fragment-types.js";
+export declare const EMPTY_LOCATION: {
+    start: {
+        line: number;
+        column: number;
+        offset: number;
+    };
+    end: {
+        line: number;
+        column: number;
+        offset: number;
+    };
+};
+export declare function editError(code: string, message: string, location?: ProgramNode["location"]): Diagnostic;
+export declare function diagnosticsOf(result: {
+    warnings: readonly Diagnostic[];
+    errors: readonly Diagnostic[];
+}): Diagnostic[];
+export declare function parseProgram(source: string): {
+    program: ProgramNode | null;
+    diagnostics: Diagnostic[];
+};
+export declare function validateExpressionFragment(expr: unknown): Diagnostic[];
+export declare function validateTypeFragment(typeSource: unknown): Diagnostic[];
+export declare function validateStateFieldFragment(typeSource: unknown, defaultSource: string): Diagnostic[];
+export declare function validateActionBodyFragment(body: unknown): Diagnostic[];
+export declare function validateIdentifierFragment(value: unknown, label: string): Diagnostic[];
+export declare function validateParamsFragment(params: unknown): Diagnostic[];
+type ParamsFragmentSnapshot = {
+    readonly ok: true;
+    readonly value: readonly MelParamSource[];
+    readonly diagnostics: readonly Diagnostic[];
+} | {
+    readonly ok: false;
+    readonly diagnostics: readonly Diagnostic[];
+};
+export declare function snapshotParamsFragment(params: unknown): ParamsFragmentSnapshot;
+type EditOperationKindRead = {
+    readonly ok: true;
+    readonly value: string;
+} | {
+    readonly ok: false;
+    readonly diagnostic: Diagnostic;
+};
+export declare function readEditOperationKind(value: unknown): EditOperationKindRead;
+export declare function validateTarget(baseModule: DomainModule, target: unknown, allowedKinds: readonly string[]): Diagnostic | null;
+export declare function targetNotFound(target: LocalTargetKey): Diagnostic;
+export declare function targetKind(target: string): string | null;
+export {};

package/dist/api/index.d.ts

@@ -6,4 +6,6 @@
  * @see SPEC v0.4.0 §19
  */
 export type { Annotation, AnnotationIndex, CompileTrace, CompileMelDomainOptions, CompileMelDomainResult, CompileMelModuleOptions, CompileMelModuleResult, CompileMelPatchOptions, CompileMelPatchResult, DomainModule, JsonLiteral, LocalTargetKey, SourceMapEmissionContext, SourceMapEntry, SourceMapIndex, SourceMapPath, SourcePoint, SourceSpan, } from "./compile-mel.js";
+export type { CompileFragmentInContextOptions, MelEditAddActionOp, MelEditAddAvailableOp, MelEditAddComputedOp, MelEditAddDispatchableOp, MelEditAddStateFieldOp, MelEditAddTypeOp, MelEditOp, MelEditRemoveDeclarationOp, MelEditRenameDeclarationOp, MelEditReplaceActionBodyOp, MelEditReplaceAvailableOp, MelEditReplaceComputedExprOp, MelEditReplaceDispatchableOp, MelEditReplaceStateDefaultOp, MelEditReplaceTypeFieldOp, MelEditResult, MelParamSource, MelTextEdit, SchemaDiff, SchemaModifiedTarget, } from "./compile-fragment-in-context.js";
 export { compileMelDomain, compileMelModule, compileMelPatch } from "./compile-mel.js";
+export { compileFragmentInContext } from "./compile-fragment-in-context.js";