@manifesto-ai/codegen 0.1.4 → 0.2.1

package/README.md

@@ -1,6 +1,6 @@
 # @manifesto-ai/codegen
 
-> **Codegen** generates TypeScript types and Zod schemas from a Manifesto DomainSchema through a deterministic plugin pipeline.
+> **Codegen** generates canonical domain facade types from a Manifesto DomainSchema through a deterministic plugin pipeline.
 
 ---
 
@@ -23,7 +23,8 @@ DomainSchema -> CODEGEN -> Generated Files
 
 | Responsibility | Description |
 |----------------|-------------|
-| Generate TypeScript types | DomainSchema types -> `export interface` / `export type` |
+| Generate canonical domain facades | DomainSchema -> `<domain>.mel.ts` with `state` / `computed` / `actions` |
+| Generate legacy TS/Zod artifacts | Optional low-level `types.ts` / `base.ts` output |
 | Generate Zod schemas | DomainSchema types -> Zod validators with type annotations |
 | Plugin pipeline | Run plugins sequentially with shared artifacts |
 | Path safety | Validate and normalize output file paths |
@@ -58,7 +59,7 @@ npm install @manifesto-ai/codegen
 ## Quick Example
 
 ```typescript
-import { generate, createTsPlugin, createZodPlugin } from "@manifesto-ai/codegen";
+import { generate, createDomainPlugin } from "@manifesto-ai/codegen";
 import type { DomainSchema } from "@manifesto-ai/core";
 
 const schema: DomainSchema = { /* your domain schema */ };
@@ -66,36 +67,52 @@ const schema: DomainSchema = { /* your domain schema */ };
 const result = await generate({
   schema,
   outDir: "./generated",
-  plugins: [createTsPlugin(), createZodPlugin()],
+  sourceId: "src/domain/hello.mel",
+  plugins: [createDomainPlugin()],
 });
 
-// result.files -> [{ path: "types.ts", content: "..." }, { path: "base.ts", content: "..." }]
+// result.files -> [{ path: "src/domain/hello.mel.ts", content: "..." }]
 // result.diagnostics -> [] (empty = no warnings or errors)
 ```
 
-This produces two files:
+For bundler-time emission, inject Codegen explicitly into the compiler plugin:
 
-**types.ts** -- TypeScript type definitions:
 ```typescript
-export interface Todo {
-  completed: boolean;
-  id: string;
-  title: string;
-}
+import { defineConfig } from "vite";
+import { melPlugin } from "@manifesto-ai/compiler/vite";
+import { createCompilerCodegen } from "@manifesto-ai/codegen";
+
+export default defineConfig({
+  plugins: [
+    melPlugin({
+      codegen: createCompilerCodegen(),
+    }),
+  ],
+});
 ```
 
-**base.ts** -- Zod schemas with type annotations:
-```typescript
-import { z } from "zod";
-import type { Todo } from "./types";
+This produces a canonical domain facade:
 
-export const TodoSchema: z.ZodType<Todo> = z.object({
-  completed: z.boolean(),
-  id: z.string(),
-  title: z.string(),
-});
+**src/domain/hello.mel.ts**
+```typescript
+export interface HelloDomain {
+  readonly state: {
+    counter: number
+    hello: string
+  }
+  readonly computed: {
+    canDecrement: boolean
+    doubled: number
+  }
+  readonly actions: {
+    decrement: () => void
+    increment: () => void
+  }
+}
 ```
 
+Legacy `createTsPlugin()` and `createZodPlugin()` remain available, but are deprecated in favor of `createDomainPlugin()`.
+
 > See [GUIDE.md](docs/GUIDE.md) for the full tutorial.
 
 ---
@@ -107,9 +124,13 @@ export const TodoSchema: z.ZodType<Todo> = z.object({
 ```typescript
 // Entry point
 function generate(options: GenerateOptions): Promise<GenerateResult>;
+function createCompilerCodegen(options?: CompilerCodegenOptions): CompilerCodegenEmitter;
 
 // Built-in plugins
+function createDomainPlugin(options?: DomainPluginOptions): CodegenPlugin;
+/** @deprecated */
 function createTsPlugin(options?: TsPluginOptions): CodegenPlugin;
+/** @deprecated */
 function createZodPlugin(options?: ZodPluginOptions): CodegenPlugin;
 
 // Key types
@@ -127,6 +148,12 @@ type GenerateResult = {
   diagnostics: Diagnostic[];
 };
 
+type CompilerCodegenOptions = {
+  outDir?: string;      // Default: "."
+  plugins?: CodegenPlugin[]; // Default: [createDomainPlugin()]
+  stamp?: boolean;
+};
+
 type CodegenPlugin = {
   name: string;
   generate(ctx: CodegenContext): CodegenOutput;
@@ -141,7 +168,7 @@ type CodegenPlugin = {
 
 ### Plugin Pipeline
 
-Plugins run in array order. Each plugin receives a context containing the schema and artifacts from all previous plugins. The TS plugin publishes type names; the Zod plugin reads them to generate type-annotated schemas.
+Plugins run in array order. Each plugin receives a context containing the schema and artifacts from all previous plugins. The canonical domain plugin is self-contained; the legacy TS plugin publishes type names and the legacy Zod plugin reads them to generate type-annotated schemas.
 
 ### Artifacts
 
@@ -169,6 +196,7 @@ Same DomainSchema always produces byte-identical output files. Fields and types
 ## When to Use Codegen
 
 Use Codegen when:
+- You want a canonical `<domain>.mel.ts` facade for `createManifesto<T>()`
 - You want type-safe TypeScript interfaces from your DomainSchema
 - You want Zod runtime validators that match your schema types
 - You need deterministic, reproducible code generation in CI

package/dist/compiler-codegen.d.ts

@@ -0,0 +1,15 @@
+import type { DomainSchema } from "@manifesto-ai/core";
+import type { CodegenPlugin, GenerateResult } from "./types.js";
+export interface CompilerCodegenInput {
+    readonly schema: DomainSchema;
+    readonly sourceId: string;
+}
+export interface CompilerCodegenOptions {
+    readonly outDir?: string;
+    readonly plugins?: readonly CodegenPlugin[];
+    readonly stamp?: boolean;
+}
+export interface CompilerCodegenEmitter {
+    (input: CompilerCodegenInput): Promise<GenerateResult>;
+}
+export declare function createCompilerCodegen(options?: CompilerCodegenOptions): CompilerCodegenEmitter;

package/dist/header.d.ts

@@ -0,0 +1,12 @@
+export interface HeaderOptions {
+    readonly sourceId?: string;
+    readonly schemaHash: string;
+    readonly stamp?: boolean;
+}
+/**
+ * Generate the @generated file header (DET-2, DET-3, DET-4).
+ *
+ * Default mode: no timestamp (deterministic).
+ * With stamp=true: appends ISO 8601 timestamp line.
+ */
+export declare function generateHeader(options: HeaderOptions): string;

package/dist/index.d.ts

@@ -1,114 +1,11 @@
-import { DomainSchema } from '@manifesto-ai/core';
-
-type Diagnostic = {
-    readonly level: "warn" | "error";
-    readonly plugin: string;
-    readonly message: string;
-};
-type FilePatch = {
-    readonly op: "set";
-    readonly path: string;
-    readonly content: string;
-} | {
-    readonly op: "delete";
-    readonly path: string;
-};
-interface CodegenHelpers {
-    stableHash(input: unknown): string;
-}
-interface CodegenContext {
-    readonly schema: DomainSchema;
-    readonly sourceId?: string;
-    readonly outDir: string;
-    readonly artifacts: Readonly<Record<string, unknown>>;
-    readonly helpers: CodegenHelpers;
-}
-interface CodegenOutput {
-    readonly patches: readonly FilePatch[];
-    readonly artifacts?: Readonly<Record<string, unknown>>;
-    readonly diagnostics?: readonly Diagnostic[];
-}
-interface CodegenPlugin {
-    readonly name: string;
-    generate(ctx: CodegenContext): CodegenOutput | Promise<CodegenOutput>;
-}
-interface GenerateOptions {
-    readonly schema: DomainSchema;
-    readonly outDir: string;
-    readonly plugins: readonly CodegenPlugin[];
-    readonly sourceId?: string;
-    readonly stamp?: boolean;
-}
-interface GenerateResult {
-    readonly files: ReadonlyArray<{
-        readonly path: string;
-        readonly content: string;
-    }>;
-    readonly artifacts: Readonly<Record<string, unknown>>;
-    readonly diagnostics: readonly Diagnostic[];
-}
-
-/**
- * Generate typed artifacts from a DomainSchema using plugins.
- *
- * This is the sole entry point for codegen. It orchestrates:
- * - Plugin name uniqueness validation (GEN-2)
- * - Sequential plugin execution (GEN-3, GEN-7)
- * - FilePatch composition with collision detection
- * - Error gating (GEN-5, GEN-8)
- * - outDir clean + file flush (GEN-1)
- */
-declare function generate(opts: GenerateOptions): Promise<GenerateResult>;
-
-interface TsPluginOptions {
-    readonly typesFile?: string;
-    readonly actionsFile?: string;
-}
-interface TsPluginArtifacts {
-    readonly typeNames: string[];
-    readonly typeImportPath: string;
-}
-declare function createTsPlugin(options?: TsPluginOptions): CodegenPlugin;
-
-interface ZodPluginOptions {
-    readonly schemasFile?: string;
-}
-declare function createZodPlugin(options?: ZodPluginOptions): CodegenPlugin;
-
-type PathValidationResult = {
-    valid: true;
-    normalized: string;
-} | {
-    valid: false;
-    reason: string;
-};
-/**
- * Validate and normalize a file path per FP-1, FP-2, GEN-6.
- *
- * - MUST be a POSIX relative path
- * - MUST NOT contain `..`, absolute prefixes, drive letters, or null bytes
- * - Normalizes backslashes, multiple slashes, and leading `./`
- */
-declare function validatePath(path: string): PathValidationResult;
-
-/**
- * Deterministic hash function (DET-1).
- * Same input always produces the same output.
- * Uses Core's canonical form (sorted keys, no undefined) + SHA-256.
- */
-declare function stableHash(input: unknown): string;
-
-interface HeaderOptions {
-    readonly sourceId?: string;
-    readonly schemaHash: string;
-    readonly stamp?: boolean;
-}
-/**
- * Generate the @generated file header (DET-2, DET-3, DET-4).
- *
- * Default mode: no timestamp (deterministic).
- * With stamp=true: appends ISO 8601 timestamp line.
- */
-declare function generateHeader(options: HeaderOptions): string;
-
-export { type CodegenContext, type CodegenHelpers, type CodegenOutput, type CodegenPlugin, type Diagnostic, type FilePatch, type GenerateOptions, type GenerateResult, type HeaderOptions, type PathValidationResult, type TsPluginArtifacts, type TsPluginOptions, type ZodPluginOptions, createTsPlugin, createZodPlugin, generate, generateHeader, stableHash, validatePath };
+export type { Diagnostic, FilePatch, CodegenPlugin, CodegenContext, CodegenOutput, CodegenHelpers, GenerateOptions, GenerateResult, } from "./types.js";
+export { generate } from "./runner.js";
+export { createCompilerCodegen } from "./compiler-codegen.js";
+export type { CompilerCodegenInput, CompilerCodegenOptions, CompilerCodegenEmitter, } from "./compiler-codegen.js";
+export { createDomainPlugin, createTsPlugin, createZodPlugin, } from "./plugins/index.js";
+export type { DomainPluginOptions, TsPluginOptions, TsPluginArtifacts, ZodPluginOptions, } from "./plugins/index.js";
+export { validatePath } from "./path-safety.js";
+export type { PathValidationResult } from "./path-safety.js";
+export { stableHash } from "./stable-hash.js";
+export { generateHeader } from "./header.js";
+export type { HeaderOptions } from "./header.js";