@manifesto-ai/compiler 3.8.0 → 5.0.0

package/README.md

@@ -21,7 +21,7 @@ MEL source -> Compiler -> DomainSchema -> Core
 | Parse MEL | Tokenize and parse MEL into an AST |
 | Validate | Scope, typing, and semantic checks aligned to the current compiler contract |
 | Generate IR | Produce DomainSchema for Core |
-| Lower system values | Optional lowering of $system.* into explicit effects |
+| Lower runtime/context expressions | Lower ADR-027 `$runtime.*` and `$context.*` references into Core expressions |
 
 ---
 
@@ -216,7 +216,7 @@ type CompileOptions = {
 | [MEL Syntax](../../docs/mel/SYNTAX.md) | Grammar and syntax |
 | [MEL Examples](../../docs/mel/EXAMPLES.md) | Example library |
 | [MEL Error Guide](../../docs/mel/ERROR-GUIDE.md) | Error codes and fixes |
-| [Compiler Spec](docs/SPEC-v1.1.0.md) | Current full compiler and MEL spec |
+| [Compiler Spec](docs/SPEC-v1.2.0.md) | Current full compiler and MEL spec |
 | [Compiler FDR](docs/FDR-v0.5.0.md) | Design rationale |
 | [Compiler Compliance Suite](docs/compiler-SPEC-compilance-test-suite.md) | CCTS structure, rule modes, and execution guide |
 

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

@@ -6,6 +6,7 @@ export type TypeEnv = Map<string, TypeExprNode>;
 export type ComparableSurfaceClass = "primitive" | "nonprimitive" | "unknown";
 export interface DomainTypeSymbols {
     stateTypes: Map<string, TypeExprNode>;
+    contextTypes: Map<string, TypeExprNode>;
     computedDecls: Map<string, ComputedNode>;
     typeDefs: Map<string, TypeDeclNode>;
     computedTypeCache: Map<string, TypeExprNode | null>;

package/dist/analyzer/validator.d.ts

@@ -31,6 +31,7 @@ export declare class SemanticValidator {
      * v0.3.3: Validate state field - check for anonymous object types (W012)
      */
     private validateStateField;
+    private validateContext;
     private validateStateInitializer;
     /**
      * v0.3.3: Check if a type expression contains anonymous object types
@@ -39,13 +40,13 @@ export declare class SemanticValidator {
     private checkAnonymousObjectType;
     private validateAction;
     /**
-     * v0.3.3: Validate available expression is pure (E005)
-     * No $system.*, no effects, no $input.*
+     * v0.3.3: Validate available expression is pure (E005).
+     * No dollar namespace reads or action parameters.
      */
     private validateAvailableExpr;
     /**
-     * v0.9.0: Validate dispatchable expression is pure (E047)
-     * Allows state/computed/action params, but forbids direct $input.*, $meta.*, and $system.*.
+     * v0.9.0: Validate dispatchable expression is pure (E047).
+     * Allows state/computed/action params, but forbids direct dollar namespace reads.
      */
     private validateDispatchableExpr;
     private validateGuardedStmt;
@@ -58,6 +59,8 @@ export declare class SemanticValidator {
     private validateStop;
     private validateCondition;
     private validateExpr;
+    private validateDollarIdent;
+    private validateContextPath;
     private validateFunctionCall;
     private validatePrimitiveEquality;
     private inferType;

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/compile-mel-patch-collector.d.ts

@@ -4,11 +4,9 @@ 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;
+    readonly actionName: string;
 }
+type AllowedSysPrefix = "input" | "runtime" | "context";
 export type ConditionedPatchStatement = {
     patch: PatchStmtNode;
     condition?: MelExprNode;
@@ -19,11 +17,11 @@ export interface PatchCollectorDeps {
 }
 export declare class PatchStatementCollector {
     private readonly deps;
-    private readonly conditionComposer;
     private readonly exprValidator;
-    constructor(deps: PatchCollectorDeps);
+    constructor(deps: PatchCollectorDeps, allowSysPrefixes?: readonly AllowedSysPrefix[]);
     collect(stmts: GuardedStmtNode[] | InnerStmtNode[], errors: Diagnostic[], context: PatchCollectContext, parentCondition: MelExprNode | undefined): ConditionedPatchStatement[];
     private collectPatchStatements;
+    private pushUnsupportedControlError;
 }
 export declare function compilePatchStmtToMelRuntime(patchStatement: ConditionedPatchStatement): {
     op: "set" | "unset" | "merge";
@@ -31,3 +29,4 @@ export declare function compilePatchStmtToMelRuntime(patchStatement: Conditioned
     value?: MelExprNode;
     condition?: MelExprNode;
 };
+export {};

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

@@ -81,11 +81,11 @@ export interface CompileMelPatchOptions {
      */
     actionName: string;
     /**
-     * Allowed system path prefixes.
-     * Default: ["meta", "input"] (system is forbidden per §20.3).
+     * Allowed dollar namespace prefixes.
+     * Default: ["input", "runtime", "context"].
      */
     allowSysPaths?: {
-        prefixes: ("meta" | "input")[];
+        prefixes: ("input" | "runtime" | "context")[];
     };
     /**
      * Function table version.
@@ -140,7 +140,7 @@ export declare function compileMelModule(melText: string, options?: CompileMelMo
  * by evaluateRuntimePatches() to get concrete values.
  *
  * Constraints:
- * - §20.3: $system.* is forbidden in Translator path
+ * - ADR-027: `$system.*` and `$meta.*` are retired in current v5 MEL.
  *
  * @param melText - MEL patch source text
  * @param options - Compilation options

package/dist/api/index.d.ts

@@ -5,5 +5,7 @@
  *
  * @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 { compileMelDomain, compileMelModule, compileMelPatch } from "./compile-mel.js";
+export type { Annotation, AnnotationIndex, CompileTrace, CompileMelDomainOptions, CompileMelDomainResult, CompileMelModuleOptions, CompileMelModuleResult, 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 } from "./compile-mel.js";
+export { compileFragmentInContext } from "./compile-fragment-in-context.js";

package/dist/{chunk-MB43CHXV.js → chunk-A356Y7I6.js}

@@ -1,3 +1,3 @@
-import{a as f,b as g}from"./chunk-M3P5RIDR.js";import{da as d}from"./chunk-PEO2YZ2Y.js";import{createHash as p}from"crypto";import*as i from"path";import{createUnplugin as h}from"unplugin";var M=new Set(["transform","build","both"]);function l(e){return e.split("?",1)[0]}function b(e,t){return e.lastIndex=0,e.test(t)}function y(e){let t=l(e).replace(/\\/g,"/");if(!t)return"domain.mel";if(!i.isAbsolute(e))return t.replace(/^\.\//,"");let n=i.relative(process.cwd(),e);return!n||n.startsWith("..")||i.isAbsolute(n)?w(t):n.split(i.sep).join("/")}function w(e){let t=i.posix.basename(e)||"domain.mel",n=i.posix.extname(t),o=t.slice(0,t.length-n.length)||"domain",r=p("sha256").update(e).digest("hex").slice(0,12);return`external/${x(o)}--${r}${n}`}function x(e){return e.replace(/[^a-zA-Z0-9._-]+/g,"-").replace(/^-+|-+$/g,"")||"domain"}function E(e){if(!e)return null;if(typeof e=="function")return{emit:e,timing:"transform"};if(typeof e=="object"&&typeof e.emit=="function"){let t=e.timing??"transform";if(!M.has(t))throw new TypeError(`manifesto:mel codegen timing must be one of "transform", "build", or "both" (received ${JSON.stringify(t)})`);return{emit:e.emit,timing:t}}throw new TypeError("manifesto:mel codegen must be a function or an object with a callable emit field")}var O=h((e={})=>{let t=e.include??/\.mel$/,n=new Map,o=E(e.codegen);return{name:"manifesto:mel",enforce:"pre",transformInclude(r){return b(t,l(r))},async transform(r,s){let m=l(s),a=d(r,{mode:"domain"});if(a.errors.length>0){let u=a.errors.map(f).join(`
+import{a as f,b as g}from"./chunk-HOS3TLHW.js";import{aa as d}from"./chunk-JYNK3VUK.js";import{createHash as p}from"crypto";import*as i from"path";import{createUnplugin as h}from"unplugin";var M=new Set(["transform","build","both"]);function l(e){return e.split("?",1)[0]}function b(e,t){return e.lastIndex=0,e.test(t)}function y(e){let t=l(e).replace(/\\/g,"/");if(!t)return"domain.mel";if(!i.isAbsolute(e))return t.replace(/^\.\//,"");let n=i.relative(process.cwd(),e);return!n||n.startsWith("..")||i.isAbsolute(n)?w(t):n.split(i.sep).join("/")}function w(e){let t=i.posix.basename(e)||"domain.mel",n=i.posix.extname(t),o=t.slice(0,t.length-n.length)||"domain",r=p("sha256").update(e).digest("hex").slice(0,12);return`external/${x(o)}--${r}${n}`}function x(e){return e.replace(/[^a-zA-Z0-9._-]+/g,"-").replace(/^-+|-+$/g,"")||"domain"}function E(e){if(!e)return null;if(typeof e=="function")return{emit:e,timing:"transform"};if(typeof e=="object"&&typeof e.emit=="function"){let t=e.timing??"transform";if(!M.has(t))throw new TypeError(`manifesto:mel codegen timing must be one of "transform", "build", or "both" (received ${JSON.stringify(t)})`);return{emit:e.emit,timing:t}}throw new TypeError("manifesto:mel codegen must be a function or an object with a callable emit field")}var O=h((e={})=>{let t=e.include??/\.mel$/,n=new Map,o=E(e.codegen);return{name:"manifesto:mel",enforce:"pre",transformInclude(r){return b(t,l(r))},async transform(r,s){let m=l(s),a=d(r,{mode:"domain"});if(a.errors.length>0){let u=a.errors.map(f).join(`
 `);throw new Error(`MEL compilation failed for ${m}
 ${u}`)}if(!a.schema)throw new Error(`MEL compilation produced no schema for ${m}`);let c=y(m);return o&&((o.timing==="transform"||o.timing==="both")&&await o.emit({schema:a.schema,sourceId:c}),(o.timing==="build"||o.timing==="both")&&n.set(c,a.schema)),g(a.schema)},async buildEnd(){if(!(!o||n.size===0))for(let[r,s]of n)await o.emit({schema:s,sourceId:r})}}});export{O as a};

package/dist/{chunk-M3P5RIDR.js → chunk-HOS3TLHW.js}

@@ -1,4 +1,4 @@
-import{da as t}from"./chunk-PEO2YZ2Y.js";function i(o){let e=o.location;if(!e)return`[${o.code}] ${o.message}`;let{line:r,column:n}=e.start;return`[${o.code}] ${o.message} (${r}:${n})`}function s(o){return`export default ${JSON.stringify(o,null,2)};
+import{aa as t}from"./chunk-JYNK3VUK.js";function i(o){let e=o.location;if(!e)return`[${o.code}] ${o.message}`;let{line:r,column:n}=e.start;return`[${o.code}] ${o.message} (${r}:${n})`}function s(o){return`export default ${JSON.stringify(o,null,2)};
 `}function a(o,e){let r=t(o,{mode:"domain"});if(r.errors.length>0){let n=r.errors.map(i).join(`
 `);throw new Error(`MEL compilation failed for ${e}
 ${n}`)}if(!r.schema)throw new Error(`MEL compilation produced no schema for ${e}`);return s(r.schema)}export{i as a,s as b,a as c};