@mindees/compiler 0.1.0

package/LICENSE

@@ -0,0 +1,31 @@
+# License
+
+MindeesNative is dual-licensed under either of:
+
+- **Apache License, Version 2.0** ([LICENSE-APACHE](./LICENSE-APACHE) or
+  <https://www.apache.org/licenses/LICENSE-2.0>)
+- **MIT license** ([LICENSE-MIT](./LICENSE-MIT) or
+  <https://opensource.org/licenses/MIT>)
+
+at your option.
+
+This `MIT OR Apache-2.0` dual-license is the same model used by the Rust
+ecosystem and many modern open-source projects. It gives downstream users
+maximum flexibility: the MIT option is short and permissive, while the Apache
+option adds an explicit patent grant.
+
+## SPDX identifier
+
+```
+SPDX-License-Identifier: MIT OR Apache-2.0
+```
+
+## Contribution
+
+Unless you explicitly state otherwise, any contribution intentionally
+submitted for inclusion in the work by you, as defined in the Apache-2.0
+license, shall be dual-licensed as above, without any additional terms or
+conditions.
+
+Contributions are accepted under the **Developer Certificate of Origin (DCO)**.
+See [CONTRIBUTING.md](./CONTRIBUTING.md) for details on signing off your commits.

package/README.md

@@ -0,0 +1,77 @@
+# @mindees/compiler
+
+**MDC** — the Mindees Compiler. A build-time optimizer built on the TypeScript
+Compiler API: a strict **type-check gate**, a **TSX → `createElement`** transform
+(matching `@mindees/core`), **tree-flattening**, a per-route **code-splitting**
+manifest, and a **plugin API**.
+
+> **Status: 🧪 Experimental (Phase 4).** Implemented and tested. The working
+> emit path is **TS → optimized JavaScript**. **TS → native machine code (AOT)**
+> is a research track (`compileToNative` throws `NotImplementedError`). APIs may
+> change before `1.0`.
+
+## Why the TypeScript Compiler API?
+
+Only TypeScript can **type-check** — the compiler's #1 job. It also does JSX
+lowering, transforms, and source maps in one tool, with **zero native binaries**
+(deterministic, reproducible CI). See
+[ADR-0002](../../docs/adr/0002-compiler-foundation.md). An SWC/oxc-accelerated
+*emit* path is a documented future optimization.
+
+## Quick start
+
+```ts
+import { compileChecked, buildRouteManifest } from '@mindees/compiler'
+
+// Type-check gate: a build must not ship type errors.
+const bad = compileChecked('export const a: number = "oops"')
+bad.code         // '' — refused to emit
+bad.diagnostics  // [{ code: 'TS2322', severity: 'error', ... }]
+
+// Compile valid TSX → createElement, with tree-flattening + a source map.
+const ok = compileChecked('export const v = <view id="x"><text>hi</text></view>')
+ok.code          // '..._static(createElement("view", { id: "x" }, ...))...'
+ok.stats         // { flattenedNodes: 1, totalElements: 2 }
+ok.map           // JSON source map
+
+// Per-route code-splitting manifest (file-based routing).
+buildRouteManifest(['index.tsx', 'blog/[slug].tsx'])
+// → { routes: [{ routePath: '/', ... },
+//              { routePath: '/blog/:slug', params: ['slug'], chunk: 'route_blog_slug' }] }
+```
+
+## What the optimizer does
+
+- **Type-check gate** (`typecheck` / `compileChecked`) — strict (`strict`,
+  `noUncheckedIndexedAccess`, `exactOptionalPropertyTypes`); structured
+  `Diagnostic`s with `TSxxxx` codes + positions. `compileChecked` refuses to emit
+  on any `error`.
+- **TSX → `createElement`** — JSX lowered to the `@mindees/core` factory, with
+  source maps.
+- **Tree-flattening** — fully-static element subtrees are wrapped once as
+  `_static(createElement(...))`, a create-once / never-diff constant. Purely
+  additive (never drops or reorders nodes). `stats.flattenedNodes` /
+  `stats.totalElements` quantify it.
+- **Per-route manifest** (`buildRouteManifest`) — maps a file tree to lazily
+  loadable chunks (`index` → `/`, `[param]` → `:param`, `[...rest]` catch-all,
+  `(group)` layout groups dropped from the URL).
+- **Plugin API** (`MdcPlugin`) — plugins receive the `typescript` module and
+  return a transformer that runs **after** JSX desugaring (so they see
+  `createElement(...)` calls, not raw JSX).
+
+## API
+
+| Export | Kind | Description |
+| --- | --- | --- |
+| `typecheck(source, fileName?)` | fn | Type-check → `Diagnostic[]`. |
+| `hasErrors(diagnostics)` | fn | Any `error`-severity diagnostic? |
+| `compile(source, options?)` | fn | TSX → JS (+ flatten, plugins, source map). |
+| `compileChecked(source, options?)` | fn | Gate, then compile; no emit on errors. |
+| `buildRouteManifest(files)` / `fileToRoute` / `chunkName` | fn | Per-route manifest. |
+| `createFlattenTransformer` / `STATIC_MARKER` | fn | The flatten pass. |
+| `compileToNative` | fn | 🔬 research track — throws `NotImplementedError`. |
+| `CompileOptions`, `CompileResult`, `Diagnostic`, `MdcPlugin`, … | type | Public types. |
+
+## License
+
+`MIT OR Apache-2.0`

package/dist/aot.d.ts

@@ -0,0 +1,30 @@
+//#region src/aot.d.ts
+/**
+ * TypeScript → native machine code (AOT) — 🔬 **research track**.
+ *
+ * The framework spec's north star is compiling typed TS to native (ARM64/x86-64)
+ * for native-grade throughput (à la Static Hermes / Valdi's TS→native pipeline).
+ * That is **not implemented**: it's at the frontier and unproven across the full
+ * dynamic-TS surface.
+ *
+ * Per the Working-Code Doctrine, this module is honest about that. The **working
+ * fallback is the standard {@link compile} path** (TS → optimized JavaScript),
+ * which runs everywhere today. {@link compileToNative} throws
+ * {@link NotImplementedError} so nothing silently pretends to emit native code.
+ *
+ * @module
+ */
+/** Target architecture for a future native AOT backend. */
+type NativeTarget = 'arm64' | 'x86-64';
+/**
+ * 🔬 Research track — not implemented. Throws {@link NotImplementedError}.
+ *
+ * Use {@link compile} (TS → optimized JS) today; that is the working path and
+ * the documented fallback for any code that can't (yet) be AOT-compiled.
+ *
+ * @experimental
+ */
+declare function compileToNative(_source: string, _target: NativeTarget): never;
+//#endregion
+export { NativeTarget, compileToNative };
+//# sourceMappingURL=aot.d.ts.map

package/dist/aot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aot.d.ts","names":[],"sources":["../src/aot.ts"],"mappings":";;AAmBA;;;;AAAwB;AAUxB;;;;;;;;AAAsE;;KAV1D,YAAA;;;;;;;;;iBAUI,eAAA,CAAgB,OAAA,UAAiB,OAAA,EAAS,YAAY"}

package/dist/aot.js

@@ -0,0 +1,32 @@
+import { NotImplementedError } from "@mindees/core";
+//#region src/aot.ts
+/**
+* TypeScript → native machine code (AOT) — 🔬 **research track**.
+*
+* The framework spec's north star is compiling typed TS to native (ARM64/x86-64)
+* for native-grade throughput (à la Static Hermes / Valdi's TS→native pipeline).
+* That is **not implemented**: it's at the frontier and unproven across the full
+* dynamic-TS surface.
+*
+* Per the Working-Code Doctrine, this module is honest about that. The **working
+* fallback is the standard {@link compile} path** (TS → optimized JavaScript),
+* which runs everywhere today. {@link compileToNative} throws
+* {@link NotImplementedError} so nothing silently pretends to emit native code.
+*
+* @module
+*/
+/**
+* 🔬 Research track — not implemented. Throws {@link NotImplementedError}.
+*
+* Use {@link compile} (TS → optimized JS) today; that is the working path and
+* the documented fallback for any code that can't (yet) be AOT-compiled.
+*
+* @experimental
+*/
+function compileToNative(_source, _target) {
+	throw new NotImplementedError("TypeScript → native machine code (AOT)");
+}
+//#endregion
+export { compileToNative };
+
+//# sourceMappingURL=aot.js.map

package/dist/aot.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"aot.js","names":[],"sources":["../src/aot.ts"],"sourcesContent":["/**\n * TypeScript → native machine code (AOT) — 🔬 **research track**.\n *\n * The framework spec's north star is compiling typed TS to native (ARM64/x86-64)\n * for native-grade throughput (à la Static Hermes / Valdi's TS→native pipeline).\n * That is **not implemented**: it's at the frontier and unproven across the full\n * dynamic-TS surface.\n *\n * Per the Working-Code Doctrine, this module is honest about that. The **working\n * fallback is the standard {@link compile} path** (TS → optimized JavaScript),\n * which runs everywhere today. {@link compileToNative} throws\n * {@link NotImplementedError} so nothing silently pretends to emit native code.\n *\n * @module\n */\n\nimport { NotImplementedError } from '@mindees/core'\n\n/** Target architecture for a future native AOT backend. */\nexport type NativeTarget = 'arm64' | 'x86-64'\n\n/**\n * 🔬 Research track — not implemented. Throws {@link NotImplementedError}.\n *\n * Use {@link compile} (TS → optimized JS) today; that is the working path and\n * the documented fallback for any code that can't (yet) be AOT-compiled.\n *\n * @experimental\n */\nexport function compileToNative(_source: string, _target: NativeTarget): never {\n  throw new NotImplementedError('TypeScript → native machine code (AOT)')\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AA6BA,SAAgB,gBAAgB,SAAiB,SAA8B;CAC7E,MAAM,IAAI,oBAAoB,wCAAwC;AACxE"}

package/dist/flatten.d.ts

@@ -0,0 +1,17 @@
+import { CompileStats } from "./types.js";
+import ts from "typescript";
+
+//#region src/flatten.d.ts
+/** Name the runtime exposes for the static-subtree marker. */
+declare const STATIC_MARKER = "_static";
+/**
+ * Build the flatten transformer. Returns a TS `TransformerFactory` plus a live
+ * `stats` object updated as the transform runs.
+ */
+declare function createFlattenTransformer(tsmod: typeof ts): {
+  factory: ts.TransformerFactory<ts.SourceFile>;
+  stats: CompileStats;
+};
+//#endregion
+export { STATIC_MARKER, createFlattenTransformer };
+//# sourceMappingURL=flatten.d.ts.map

package/dist/flatten.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flatten.d.ts","names":[],"sources":["../src/flatten.ts"],"mappings":";;;;AAuCqB;AAAA,cARR,aAAA;;;;;iBAMG,wBAAA,CAAyB,KAAA,SAAc,EAAA;EACrD,OAAA,EAAS,EAAA,CAAG,kBAAA,CAAmB,EAAA,CAAG,UAAA;EAClC,KAAA,EAAO,YAAA;AAAA"}

package/dist/flatten.js

@@ -0,0 +1,103 @@
+//#region src/flatten.ts
+/** Name the runtime exposes for the static-subtree marker. */
+const STATIC_MARKER = "_static";
+/**
+* Build the flatten transformer. Returns a TS `TransformerFactory` plus a live
+* `stats` object updated as the transform runs.
+*/
+function createFlattenTransformer(tsmod) {
+	const stats = {
+		flattenedNodes: 0,
+		totalElements: 0
+	};
+	const isCreateElementCall = (node) => tsmod.isCallExpression(node) && tsmod.isIdentifier(node.expression) && node.expression.text === "createElement";
+	const isStaticExpression = (node) => {
+		switch (node.kind) {
+			case tsmod.SyntaxKind.StringLiteral:
+			case tsmod.SyntaxKind.NumericLiteral:
+			case tsmod.SyntaxKind.TrueKeyword:
+			case tsmod.SyntaxKind.FalseKeyword:
+			case tsmod.SyntaxKind.NullKeyword: return true;
+			default: return isCreateElementCall(node) && isStaticElement(node);
+		}
+	};
+	const isStaticProps = (node) => {
+		if (!node) return true;
+		if (node.kind === tsmod.SyntaxKind.NullKeyword) return true;
+		if (tsmod.isIdentifier(node) && node.text === "undefined") return true;
+		if (tsmod.isObjectLiteralExpression(node)) return node.properties.every((p) => tsmod.isPropertyAssignment(p) && !tsmod.isComputedPropertyName(p.name) && isStaticExpression(p.initializer));
+		return false;
+	};
+	const isStaticElement = (call) => {
+		const [type, props, ...children] = call.arguments;
+		if (!type || !tsmod.isStringLiteral(type)) return false;
+		if (!isStaticProps(props)) return false;
+		return children.every((c) => isStaticExpression(c));
+	};
+	/** Count every createElement call in a subtree (for accurate totals). */
+	const countElements = (node) => {
+		if (isCreateElementCall(node)) stats.totalElements++;
+		tsmod.forEachChild(node, countElements);
+	};
+	/** Whether a binding name (incl. destructuring patterns) binds `name`. */
+	const bindingHasName = (binding, name) => {
+		if (tsmod.isIdentifier(binding)) return binding.text === name;
+		return binding.elements.some((el) => tsmod.isBindingElement(el) && bindingHasName(el.name, name));
+	};
+	/** Whether the module already binds `name` at the top level (var/fn/class/import). */
+	const bindsTopLevel = (sf, name) => sf.statements.some((s) => {
+		if (tsmod.isVariableStatement(s)) return s.declarationList.declarations.some((d) => bindingHasName(d.name, name));
+		if (tsmod.isFunctionDeclaration(s) || tsmod.isClassDeclaration(s)) return s.name?.text === name;
+		if (tsmod.isImportDeclaration(s) && s.importClause) {
+			const clause = s.importClause;
+			if (clause.name?.text === name) return true;
+			const named = clause.namedBindings;
+			if (named) {
+				if (tsmod.isNamespaceImport(named)) return named.name.text === name;
+				return named.elements.some((e) => e.name.text === name);
+			}
+		}
+		return false;
+	});
+	/** `const _static = (node) => node` — the hoisted create-once marker. */
+	const makeMarkerDecl = (f) => f.createVariableStatement(void 0, f.createVariableDeclarationList([f.createVariableDeclaration(f.createIdentifier(STATIC_MARKER), void 0, void 0, f.createArrowFunction(void 0, void 0, [f.createParameterDeclaration(void 0, void 0, f.createIdentifier("node"))], void 0, f.createToken(tsmod.SyntaxKind.EqualsGreaterThanToken), f.createIdentifier("node")))], tsmod.NodeFlags.Const));
+	const factory = (context) => {
+		const { factory: f } = context;
+		return (sourceFile) => {
+			const visit = (node) => {
+				if (isCreateElementCall(node) && isStaticElement(node)) {
+					stats.flattenedNodes++;
+					return f.createCallExpression(f.createIdentifier(STATIC_MARKER), void 0, [node]);
+				}
+				return tsmod.visitEachChild(node, visit, context);
+			};
+			countElements(sourceFile);
+			if (bindsTopLevel(sourceFile, "_static")) return sourceFile;
+			const visited = tsmod.visitNode(sourceFile, visit);
+			if (stats.flattenedNodes === 0) return visited;
+			const statements = visited.statements;
+			let insertAt = 0;
+			while (insertAt < statements.length) {
+				const stmt = statements[insertAt];
+				if (!stmt) break;
+				const isImport = tsmod.isImportDeclaration(stmt);
+				const isDirective = tsmod.isExpressionStatement(stmt) && tsmod.isStringLiteral(stmt.expression);
+				if (!isImport && !isDirective) break;
+				insertAt++;
+			}
+			return f.updateSourceFile(visited, [
+				...statements.slice(0, insertAt),
+				makeMarkerDecl(f),
+				...statements.slice(insertAt)
+			]);
+		};
+	};
+	return {
+		factory,
+		stats
+	};
+}
+//#endregion
+export { STATIC_MARKER, createFlattenTransformer };
+
+//# sourceMappingURL=flatten.js.map

package/dist/flatten.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"flatten.js","names":[],"sources":["../src/flatten.ts"],"sourcesContent":["/**\n * Tree-flattening optimizer pass.\n *\n * Operates on the **desugared** `createElement(type, props, ...children)` call\n * form. TS lowers JSX during the `after` phase, so this runs as an **`after`**\n * transformer (a `before` transformer would see raw JSX and match no\n * `createElement` calls) — see transform.ts and ADR-0002.\n *\n * What it does (v0, conservative + correct): a `createElement` call is\n * **static** when its `type` is a string literal, its props are a static object\n * literal (or null/undefined), and all its children are themselves static. The\n * **outermost** static call is wrapped once as `_static(createElement(...))`.\n * When any wrapping happens, the pass also **injects a self-contained\n * `const _static = (node) => node`** at the top of the module (after imports), so\n * the emitted code is runnable standalone — `_static` is a create-once marker\n * that is an identity passthrough today (the element is created once at the call\n * site regardless); a future reconciler fast-path may special-case it for\n * never-diff. Nested static children are left untouched (created once as part of\n * the wrapped root). The transform is purely additive (wraps a root + hoists the\n * marker; never drops or reorders nodes), so it can't change behavior.\n *\n * `stats.flattenedNodes` counts static roots wrapped; `stats.totalElements`\n * counts every `createElement` call. These feed tests and the perf budget.\n *\n * @module\n */\n\nimport type ts from 'typescript'\nimport type { CompileStats } from './types'\n\n/** Name the runtime exposes for the static-subtree marker. */\nexport const STATIC_MARKER = '_static'\n\n/**\n * Build the flatten transformer. Returns a TS `TransformerFactory` plus a live\n * `stats` object updated as the transform runs.\n */\nexport function createFlattenTransformer(tsmod: typeof ts): {\n  factory: ts.TransformerFactory<ts.SourceFile>\n  stats: CompileStats\n} {\n  const stats: CompileStats = { flattenedNodes: 0, totalElements: 0 }\n\n  const isCreateElementCall = (node: ts.Node): node is ts.CallExpression =>\n    tsmod.isCallExpression(node) &&\n    tsmod.isIdentifier(node.expression) &&\n    node.expression.text === 'createElement'\n\n  const isStaticExpression = (node: ts.Expression): boolean => {\n    switch (node.kind) {\n      case tsmod.SyntaxKind.StringLiteral:\n      case tsmod.SyntaxKind.NumericLiteral:\n      case tsmod.SyntaxKind.TrueKeyword:\n      case tsmod.SyntaxKind.FalseKeyword:\n      case tsmod.SyntaxKind.NullKeyword:\n        return true\n      default:\n        return isCreateElementCall(node) && isStaticElement(node)\n    }\n  }\n\n  const isStaticProps = (node: ts.Expression | undefined): boolean => {\n    if (!node) return true\n    if (node.kind === tsmod.SyntaxKind.NullKeyword) return true\n    if (tsmod.isIdentifier(node) && node.text === 'undefined') return true\n    if (tsmod.isObjectLiteralExpression(node)) {\n      return node.properties.every(\n        (p) =>\n          // Only plain `key: value` props with a NON-computed key count as\n          // static. A computed key (`{[k]: 1}`) can be dynamic/side-effectful,\n          // and shorthand/spread/method/accessor members are not statically\n          // analyzable here — any of these makes the element non-static.\n          tsmod.isPropertyAssignment(p) &&\n          !tsmod.isComputedPropertyName(p.name) &&\n          isStaticExpression(p.initializer),\n      )\n    }\n    return false\n  }\n\n  const isStaticElement = (call: ts.CallExpression): boolean => {\n    const [type, props, ...children] = call.arguments\n    if (!type || !tsmod.isStringLiteral(type)) return false\n    if (!isStaticProps(props)) return false\n    return children.every((c) => isStaticExpression(c))\n  }\n\n  /** Count every createElement call in a subtree (for accurate totals). */\n  const countElements = (node: ts.Node): void => {\n    if (isCreateElementCall(node)) stats.totalElements++\n    tsmod.forEachChild(node, countElements)\n  }\n\n  /** Whether a binding name (incl. destructuring patterns) binds `name`. */\n  const bindingHasName = (binding: ts.BindingName, name: string): boolean => {\n    if (tsmod.isIdentifier(binding)) return binding.text === name\n    // Object/Array binding pattern: recurse into each element's binding name.\n    return binding.elements.some(\n      (el) => tsmod.isBindingElement(el) && bindingHasName(el.name, name),\n    )\n  }\n\n  /** Whether the module already binds `name` at the top level (var/fn/class/import). */\n  const bindsTopLevel = (sf: ts.SourceFile, name: string): boolean =>\n    sf.statements.some((s) => {\n      if (tsmod.isVariableStatement(s)) {\n        return s.declarationList.declarations.some((d) => bindingHasName(d.name, name))\n      }\n      if (tsmod.isFunctionDeclaration(s) || tsmod.isClassDeclaration(s)) {\n        return s.name?.text === name\n      }\n      if (tsmod.isImportDeclaration(s) && s.importClause) {\n        const clause = s.importClause\n        if (clause.name?.text === name) return true\n        const named = clause.namedBindings\n        if (named) {\n          if (tsmod.isNamespaceImport(named)) return named.name.text === name\n          return named.elements.some((e) => e.name.text === name)\n        }\n      }\n      return false\n    })\n\n  /** `const _static = (node) => node` — the hoisted create-once marker. */\n  const makeMarkerDecl = (f: ts.NodeFactory): ts.Statement =>\n    f.createVariableStatement(\n      undefined,\n      f.createVariableDeclarationList(\n        [\n          f.createVariableDeclaration(\n            f.createIdentifier(STATIC_MARKER),\n            undefined,\n            undefined,\n            f.createArrowFunction(\n              undefined,\n              undefined,\n              [f.createParameterDeclaration(undefined, undefined, f.createIdentifier('node'))],\n              undefined,\n              f.createToken(tsmod.SyntaxKind.EqualsGreaterThanToken),\n              f.createIdentifier('node'),\n            ),\n          ),\n        ],\n        tsmod.NodeFlags.Const,\n      ),\n    )\n\n  const factory: ts.TransformerFactory<ts.SourceFile> = (context) => {\n    const { factory: f } = context\n    return (sourceFile) => {\n      const visit = (node: ts.Node): ts.Node => {\n        if (isCreateElementCall(node) && isStaticElement(node)) {\n          // Outermost static root: wrap once and DON'T recurse (the whole\n          // subtree is static and created as part of this wrapped constant).\n          stats.flattenedNodes++\n          return f.createCallExpression(f.createIdentifier(STATIC_MARKER), undefined, [node])\n        }\n        return tsmod.visitEachChild(node, visit, context)\n      }\n      // Count all elements up front (separately from the wrapping logic), so the\n      // total is accurate even though we stop recursion at static roots.\n      countElements(sourceFile)\n      // If the module already binds `_static` at the top level, injecting our marker\n      // would redeclare it (a SyntaxError) and our wrap calls would rebind the user's\n      // binding. Skip flattening this module rather than emit broken code.\n      if (bindsTopLevel(sourceFile, STATIC_MARKER)) return sourceFile\n      const visited = tsmod.visitNode(sourceFile, visit) as ts.SourceFile\n      if (stats.flattenedNodes === 0) return visited\n\n      // Inject the `_static` marker once, after any leading **directive prologue**\n      // (`\"use client\"`/`\"use server\"`/`\"use strict\"`) AND leading imports, so the\n      // emitted module is self-contained and runnable AND the marker never lands\n      // before a directive (which would demote it to a no-op string expression).\n      const statements = visited.statements\n      let insertAt = 0\n      while (insertAt < statements.length) {\n        const stmt = statements[insertAt]\n        if (!stmt) break\n        const isImport = tsmod.isImportDeclaration(stmt)\n        const isDirective =\n          tsmod.isExpressionStatement(stmt) && tsmod.isStringLiteral(stmt.expression)\n        if (!isImport && !isDirective) break\n        insertAt++\n      }\n      return f.updateSourceFile(visited, [\n        ...statements.slice(0, insertAt),\n        makeMarkerDecl(f),\n        ...statements.slice(insertAt),\n      ])\n    }\n  }\n\n  return { factory, stats }\n}\n"],"mappings":"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"}

package/dist/index.d.ts

@@ -0,0 +1,29 @@
+import { NativeTarget, compileToNative } from "./aot.js";
+import { CompileOptions, CompileResult, CompileStats, Diagnostic, DiagnosticSeverity, MdcPlugin, SourcePosition } from "./types.js";
+import { STATIC_MARKER, createFlattenTransformer } from "./flatten.js";
+import { RouteEntry, RouteManifest, buildRouteManifest, chunkName, fileToRoute } from "./routes.js";
+import { compile, compileChecked } from "./transform.js";
+import { hasErrors, typecheck } from "./typecheck.js";
+import { Maturity, NotImplementedError, PackageInfo, notImplemented } from "@mindees/core";
+
+//#region src/index.d.ts
+/** The npm package name. */
+declare const name = "@mindees/compiler";
+/** The package version. All `@mindees/*` packages share one locked version line. */
+declare const VERSION = "0.1.0";
+/**
+ * Current maturity. The build-time optimizer — type-check gate, TSX→createElement
+ * transform, tree-flattening, per-route manifest, plugin API — is implemented
+ * and tested on the TypeScript Compiler API. TS→native AOT is a research track
+ * (throws `NotImplementedError`); the working path is TS → optimized JS.
+ */
+declare const maturity: Maturity;
+/**
+ * Static identity + maturity metadata for this package. Frozen so the
+ * self-reported identity tooling introspects cannot be mutated at runtime,
+ * matching the `readonly` fields of {@link PackageInfo}.
+ */
+declare const info: PackageInfo;
+//#endregion
+export { type CompileOptions, type CompileResult, type CompileStats, type Diagnostic, type DiagnosticSeverity, type Maturity, type MdcPlugin, type NativeTarget, NotImplementedError, type PackageInfo, type RouteEntry, type RouteManifest, STATIC_MARKER, type SourcePosition, VERSION, buildRouteManifest, chunkName, compile, compileChecked, compileToNative, createFlattenTransformer, fileToRoute, hasErrors, info, maturity, name, notImplemented, typecheck };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/index.ts"],"mappings":";;;;;;;;;AAkCA;AAAA,cAHa,IAAA;;cAGA,OAAA;AAAO;AAQpB;;;;AAAgD;AAR5B,cAQP,QAAA,EAAU,QAAyB;;;;AAOoC;;cAAvE,IAAA,EAAM,WAAiE"}

package/dist/index.js

@@ -0,0 +1,32 @@
+import { compileToNative } from "./aot.js";
+import { STATIC_MARKER, createFlattenTransformer } from "./flatten.js";
+import { buildRouteManifest, chunkName, fileToRoute } from "./routes.js";
+import { hasErrors, typecheck } from "./typecheck.js";
+import { compile, compileChecked } from "./transform.js";
+import { NotImplementedError, notImplemented } from "@mindees/core";
+//#region src/index.ts
+/** The npm package name. */
+const name = "@mindees/compiler";
+/** The package version. All `@mindees/*` packages share one locked version line. */
+const VERSION = "0.1.0";
+/**
+* Current maturity. The build-time optimizer — type-check gate, TSX→createElement
+* transform, tree-flattening, per-route manifest, plugin API — is implemented
+* and tested on the TypeScript Compiler API. TS→native AOT is a research track
+* (throws `NotImplementedError`); the working path is TS → optimized JS.
+*/
+const maturity = "experimental";
+/**
+* Static identity + maturity metadata for this package. Frozen so the
+* self-reported identity tooling introspects cannot be mutated at runtime,
+* matching the `readonly` fields of {@link PackageInfo}.
+*/
+const info = Object.freeze({
+	name,
+	version: VERSION,
+	maturity
+});
+//#endregion
+export { NotImplementedError, STATIC_MARKER, VERSION, buildRouteManifest, chunkName, compile, compileChecked, compileToNative, createFlattenTransformer, fileToRoute, hasErrors, info, maturity, name, notImplemented, typecheck };
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../src/index.ts"],"sourcesContent":["import type { Maturity, PackageInfo } from '@mindees/core'\nimport { NotImplementedError, notImplemented } from '@mindees/core'\n\n/** TS → native AOT (research track). */\nexport { compileToNative, type NativeTarget } from './aot'\n/** Tree-flattening optimizer pass. */\nexport { createFlattenTransformer, STATIC_MARKER } from './flatten'\n/** Per-route code-splitting manifest. */\nexport {\n  buildRouteManifest,\n  chunkName,\n  fileToRoute,\n  type RouteEntry,\n  type RouteManifest,\n} from './routes'\n/** Compile pipeline (TSX → optimized JS). */\nexport { compile, compileChecked } from './transform'\n/** The type-check gate. */\nexport { hasErrors, typecheck } from './typecheck'\n/** Shared types. */\nexport type {\n  CompileOptions,\n  CompileResult,\n  CompileStats,\n  Diagnostic,\n  DiagnosticSeverity,\n  MdcPlugin,\n  SourcePosition,\n} from './types'\n\n/** The npm package name. */\nexport const name = '@mindees/compiler'\n\n/** The package version. All `@mindees/*` packages share one locked version line. */\nexport const VERSION = '0.1.0'\n\n/**\n * Current maturity. The build-time optimizer — type-check gate, TSX→createElement\n * transform, tree-flattening, per-route manifest, plugin API — is implemented\n * and tested on the TypeScript Compiler API. TS→native AOT is a research track\n * (throws `NotImplementedError`); the working path is TS → optimized JS.\n */\nexport const maturity: Maturity = 'experimental'\n\n/**\n * Static identity + maturity metadata for this package. Frozen so the\n * self-reported identity tooling introspects cannot be mutated at runtime,\n * matching the `readonly` fields of {@link PackageInfo}.\n */\nexport const info: PackageInfo = Object.freeze({ name, version: VERSION, maturity })\n\nexport type { Maturity, PackageInfo }\nexport { NotImplementedError, notImplemented }\n"],"mappings":";;;;;;;;AA+BA,MAAa,OAAO;;AAGpB,MAAa,UAAU;;;;;;;AAQvB,MAAa,WAAqB;;;;;;AAOlC,MAAa,OAAoB,OAAO,OAAO;CAAE;CAAM,SAAS;CAAS;AAAS,CAAC"}

package/dist/routes.d.ts

@@ -0,0 +1,58 @@
+//#region src/routes.d.ts
+/**
+ * Per-route code-splitting: build a route manifest from a file tree.
+ *
+ * MDC maps a routes directory (file-based routing, à la the Quantum Router) to a
+ * **manifest** of chunks — one lazily-loadable entry per route — so the bundler
+ * can split per route and the runtime can load a route's code on demand. This
+ * pass is platform-agnostic: it produces the manifest; wiring it to a specific
+ * bundler/runtime is the CLI's job (Phase 5) and the router's job (Phase 6).
+ *
+ * @module
+ */
+/** A single route in the manifest. */
+interface RouteEntry {
+  /** URL path, e.g. `/`, `/about`, `/blog/[slug]`. */
+  routePath: string;
+  /** Source file implementing the route, relative to the routes dir. */
+  file: string;
+  /** Stable chunk name for the split bundle, e.g. `route_blog_slug`. */
+  chunk: string;
+  /** Dynamic param names parsed from the path, e.g. `["slug"]`. */
+  params: string[];
+  /** True for a catch-all segment (`[...rest]`). */
+  catchAll: boolean;
+}
+/** The route manifest: every route plus a not-found fallback if present. */
+interface RouteManifest {
+  routes: RouteEntry[];
+  /** The `+not-found` route file, if any. */
+  notFound?: string;
+}
+/**
+ * Convert a file path (relative, POSIX separators) to a route path + params.
+ *
+ * Conventions (subset of the Quantum Router, see ROADMAP Phase 6):
+ * - `index` → the directory's path (`index.tsx` → `/`).
+ * - `[param]` → a dynamic segment (`:param`); collected into `params`.
+ * - `[...rest]` → a catch-all segment; sets `catchAll`.
+ * - `(group)` → a layout group that does NOT affect the URL (removed).
+ */
+declare function fileToRoute(file: string): {
+  routePath: string;
+  params: string[];
+  catchAll: boolean;
+};
+/** Build a stable chunk name from a route file (filesystem-safe identifier). */
+declare function chunkName(file: string): string;
+/**
+ * Build a {@link RouteManifest} from a list of route files (relative paths,
+ * POSIX `/` separators). Routes are sorted for deterministic output.
+ *
+ * @example
+ * buildRouteManifest(['index.tsx', 'about.tsx', 'blog/[slug].tsx', '+not-found.tsx'])
+ */
+declare function buildRouteManifest(files: readonly string[]): RouteManifest;
+//#endregion
+export { RouteEntry, RouteManifest, buildRouteManifest, chunkName, fileToRoute };
+//# sourceMappingURL=routes.d.ts.map

package/dist/routes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routes.d.ts","names":[],"sources":["../src/routes.ts"],"mappings":";;AAaA;;;;;;;;;;AAUU;AAAA,UAVO,UAAA;EAca;EAZ5B,SAAA;EAakB;EAXlB,IAAA;EAWQ;EATR,KAAA;EAWQ;EATR,MAAA;EA4Bc;EA1Bd,QAAA;AAAA;;UAIe,aAAA;EACf,MAAA,EAAQ,UAAU;EAuBlB;EArBA,QAAA;AAAA;AAsBQ;AA4CV;;;;AAAsC;AAmBtC;;;AA/DU,iBAHM,WAAA,CAAY,IAAA;EAC1B,SAAA;EACA,MAAA;EACA,QAAA;AAAA;;iBA4Cc,SAAA,CAAU,IAAY;;;;;;;;iBAmBtB,kBAAA,CAAmB,KAAA,sBAA2B,aAAa"}

package/dist/routes.js

@@ -0,0 +1,89 @@
+//#region src/routes.ts
+const ROUTE_FILE = /\.(tsx|ts|jsx|js)$/;
+/** Strip the file extension. */
+function stripExt(file) {
+	return file.replace(ROUTE_FILE, "");
+}
+/**
+* Convert a file path (relative, POSIX separators) to a route path + params.
+*
+* Conventions (subset of the Quantum Router, see ROADMAP Phase 6):
+* - `index` → the directory's path (`index.tsx` → `/`).
+* - `[param]` → a dynamic segment (`:param`); collected into `params`.
+* - `[...rest]` → a catch-all segment; sets `catchAll`.
+* - `(group)` → a layout group that does NOT affect the URL (removed).
+*/
+function fileToRoute(file) {
+	const params = [];
+	let catchAll = false;
+	const segments = stripExt(file).split("/").filter((s) => s.length > 0).filter((s) => !(s.startsWith("(") && s.endsWith(")"))).map((s) => {
+		if (s === "index") return "";
+		const restMatch = s.match(/^\[\.\.\.(.+)\]$/);
+		if (restMatch?.[1]) {
+			catchAll = true;
+			params.push(restMatch[1]);
+			return `:${restMatch[1]}*`;
+		}
+		const paramMatch = s.match(/^\[(.+)\]$/);
+		if (paramMatch?.[1]) {
+			params.push(paramMatch[1]);
+			return `:${paramMatch[1]}`;
+		}
+		return s;
+	}).filter((s) => s.length > 0);
+	const catchAllIndex = segments.findIndex((s) => s.endsWith("*"));
+	if (catchAllIndex !== -1 && catchAllIndex !== segments.length - 1) throw new Error(`Invalid route file "${file}": a catch-all segment ([...x]) must be the last segment.`);
+	return {
+		routePath: segments.length === 0 ? "/" : `/${segments.join("/")}`,
+		params,
+		catchAll
+	};
+}
+/** Build a stable chunk name from a route file (filesystem-safe identifier). */
+function chunkName(file) {
+	return `route_${stripExt(file).replace(/[/\\]/g, "_").replace(/\[\.\.\.(.+?)\]/g, "rest_$1").replace(/\[(.+?)\]/g, "$1").replace(/[()]/g, "").replace(/[^a-zA-Z0-9_]/g, "_").replace(/_+/g, "_").replace(/^_|_$/g, "") || "index"}`;
+}
+/**
+* Build a {@link RouteManifest} from a list of route files (relative paths,
+* POSIX `/` separators). Routes are sorted for deterministic output.
+*
+* @example
+* buildRouteManifest(['index.tsx', 'about.tsx', 'blog/[slug].tsx', '+not-found.tsx'])
+*/
+function buildRouteManifest(files) {
+	const routes = [];
+	let notFound;
+	const byPath = /* @__PURE__ */ new Map();
+	const byChunk = /* @__PURE__ */ new Map();
+	for (const file of [...files].sort()) {
+		if (!ROUTE_FILE.test(file)) continue;
+		const baseName = stripExt(file).split("/").pop() ?? "";
+		if (baseName === "+not-found") {
+			notFound = file;
+			continue;
+		}
+		if (baseName.startsWith("_") || baseName.startsWith("+")) continue;
+		const { routePath, params, catchAll } = fileToRoute(file);
+		const prior = byPath.get(routePath);
+		if (prior !== void 0) throw new Error(`Duplicate route path "${routePath}": both "${prior}" and "${file}" map to it.`);
+		byPath.set(routePath, file);
+		const chunk = chunkName(file);
+		const priorChunk = byChunk.get(chunk);
+		if (priorChunk !== void 0) throw new Error(`Duplicate chunk name "${chunk}": both "${priorChunk}" and "${file}" produce it; rename one route file so their split bundles do not collide.`);
+		byChunk.set(chunk, file);
+		routes.push({
+			routePath,
+			file,
+			chunk,
+			params,
+			catchAll
+		});
+	}
+	const manifest = { routes };
+	if (notFound !== void 0) manifest.notFound = notFound;
+	return manifest;
+}
+//#endregion
+export { buildRouteManifest, chunkName, fileToRoute };
+
+//# sourceMappingURL=routes.js.map

package/dist/routes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"routes.js","names":[],"sources":["../src/routes.ts"],"sourcesContent":["/**\n * Per-route code-splitting: build a route manifest from a file tree.\n *\n * MDC maps a routes directory (file-based routing, à la the Quantum Router) to a\n * **manifest** of chunks — one lazily-loadable entry per route — so the bundler\n * can split per route and the runtime can load a route's code on demand. This\n * pass is platform-agnostic: it produces the manifest; wiring it to a specific\n * bundler/runtime is the CLI's job (Phase 5) and the router's job (Phase 6).\n *\n * @module\n */\n\n/** A single route in the manifest. */\nexport interface RouteEntry {\n  /** URL path, e.g. `/`, `/about`, `/blog/[slug]`. */\n  routePath: string\n  /** Source file implementing the route, relative to the routes dir. */\n  file: string\n  /** Stable chunk name for the split bundle, e.g. `route_blog_slug`. */\n  chunk: string\n  /** Dynamic param names parsed from the path, e.g. `[\"slug\"]`. */\n  params: string[]\n  /** True for a catch-all segment (`[...rest]`). */\n  catchAll: boolean\n}\n\n/** The route manifest: every route plus a not-found fallback if present. */\nexport interface RouteManifest {\n  routes: RouteEntry[]\n  /** The `+not-found` route file, if any. */\n  notFound?: string\n}\n\nconst ROUTE_FILE = /\\.(tsx|ts|jsx|js)$/\n\n/** Strip the file extension. */\nfunction stripExt(file: string): string {\n  return file.replace(ROUTE_FILE, '')\n}\n\n/**\n * Convert a file path (relative, POSIX separators) to a route path + params.\n *\n * Conventions (subset of the Quantum Router, see ROADMAP Phase 6):\n * - `index` → the directory's path (`index.tsx` → `/`).\n * - `[param]` → a dynamic segment (`:param`); collected into `params`.\n * - `[...rest]` → a catch-all segment; sets `catchAll`.\n * - `(group)` → a layout group that does NOT affect the URL (removed).\n */\nexport function fileToRoute(file: string): {\n  routePath: string\n  params: string[]\n  catchAll: boolean\n} {\n  const params: string[] = []\n  let catchAll = false\n\n  const segments = stripExt(file)\n    .split('/')\n    .filter((s) => s.length > 0)\n    // Drop layout groups like `(marketing)`.\n    .filter((s) => !(s.startsWith('(') && s.endsWith(')')))\n    .map((s) => {\n      // index → empty (resolves to parent path)\n      if (s === 'index') return ''\n      // [...rest] → catch-all\n      const restMatch = s.match(/^\\[\\.\\.\\.(.+)\\]$/)\n      if (restMatch?.[1]) {\n        catchAll = true\n        params.push(restMatch[1])\n        return `:${restMatch[1]}*`\n      }\n      // [param] → dynamic\n      const paramMatch = s.match(/^\\[(.+)\\]$/)\n      if (paramMatch?.[1]) {\n        params.push(paramMatch[1])\n        return `:${paramMatch[1]}`\n      }\n      return s\n    })\n    .filter((s) => s.length > 0)\n\n  // A catch-all must terminate the path; `docs/[...rest]/edit` is structurally\n  // invalid and would otherwise emit a nonsensical `/docs/:rest*/edit`.\n  const catchAllIndex = segments.findIndex((s) => s.endsWith('*'))\n  if (catchAllIndex !== -1 && catchAllIndex !== segments.length - 1) {\n    throw new Error(\n      `Invalid route file \"${file}\": a catch-all segment ([...x]) must be the last segment.`,\n    )\n  }\n\n  const routePath = segments.length === 0 ? '/' : `/${segments.join('/')}`\n  return { routePath, params, catchAll }\n}\n\n/** Build a stable chunk name from a route file (filesystem-safe identifier). */\nexport function chunkName(file: string): string {\n  const base = stripExt(file)\n    .replace(/[/\\\\]/g, '_')\n    .replace(/\\[\\.\\.\\.(.+?)\\]/g, 'rest_$1')\n    .replace(/\\[(.+?)\\]/g, '$1')\n    .replace(/[()]/g, '')\n    .replace(/[^a-zA-Z0-9_]/g, '_')\n    .replace(/_+/g, '_')\n    .replace(/^_|_$/g, '')\n  return `route_${base || 'index'}`\n}\n\n/**\n * Build a {@link RouteManifest} from a list of route files (relative paths,\n * POSIX `/` separators). Routes are sorted for deterministic output.\n *\n * @example\n * buildRouteManifest(['index.tsx', 'about.tsx', 'blog/[slug].tsx', '+not-found.tsx'])\n */\nexport function buildRouteManifest(files: readonly string[]): RouteManifest {\n  const routes: RouteEntry[] = []\n  let notFound: string | undefined\n  // Detect collisions (e.g. `index.tsx` and `(app)/index.tsx` both map to `/`).\n  const byPath = new Map<string, string>()\n  // Distinct routes must also get distinct chunk names — `chunkName` is lossy\n  // (e.g. `blog/[slug]` and `blog/slug` both strip to `route_blog_slug`), so a\n  // collision here would silently make two routes share one split bundle.\n  const byChunk = new Map<string, string>()\n\n  for (const file of [...files].sort()) {\n    if (!ROUTE_FILE.test(file)) continue\n    const baseName = stripExt(file).split('/').pop() ?? ''\n    if (baseName === '+not-found') {\n      notFound = file\n      continue\n    }\n    // Skip layout files (`_layout`) and other reserved `_`/`+` prefixed files\n    // from the navigable route table (they're handled separately by the router).\n    if (baseName.startsWith('_') || baseName.startsWith('+')) continue\n\n    const { routePath, params, catchAll } = fileToRoute(file)\n    const prior = byPath.get(routePath)\n    if (prior !== undefined) {\n      throw new Error(\n        `Duplicate route path \"${routePath}\": both \"${prior}\" and \"${file}\" map to it.`,\n      )\n    }\n    byPath.set(routePath, file)\n    const chunk = chunkName(file)\n    const priorChunk = byChunk.get(chunk)\n    if (priorChunk !== undefined) {\n      throw new Error(\n        `Duplicate chunk name \"${chunk}\": both \"${priorChunk}\" and \"${file}\" produce it; ` +\n          'rename one route file so their split bundles do not collide.',\n      )\n    }\n    byChunk.set(chunk, file)\n    routes.push({ routePath, file, chunk, params, catchAll })\n  }\n\n  const manifest: RouteManifest = { routes }\n  if (notFound !== undefined) manifest.notFound = notFound\n  return manifest\n}\n"],"mappings":";AAiCA,MAAM,aAAa;;AAGnB,SAAS,SAAS,MAAsB;CACtC,OAAO,KAAK,QAAQ,YAAY,EAAE;AACpC;;;;;;;;;;AAWA,SAAgB,YAAY,MAI1B;CACA,MAAM,SAAmB,CAAC;CAC1B,IAAI,WAAW;CAEf,MAAM,WAAW,SAAS,IAAI,EAC3B,MAAM,GAAG,EACT,QAAQ,MAAM,EAAE,SAAS,CAAC,EAE1B,QAAQ,MAAM,EAAE,EAAE,WAAW,GAAG,KAAK,EAAE,SAAS,GAAG,EAAE,EACrD,KAAK,MAAM;EAEV,IAAI,MAAM,SAAS,OAAO;EAE1B,MAAM,YAAY,EAAE,MAAM,kBAAkB;EAC5C,IAAI,YAAY,IAAI;GAClB,WAAW;GACX,OAAO,KAAK,UAAU,EAAE;GACxB,OAAO,IAAI,UAAU,GAAG;EAC1B;EAEA,MAAM,aAAa,EAAE,MAAM,YAAY;EACvC,IAAI,aAAa,IAAI;GACnB,OAAO,KAAK,WAAW,EAAE;GACzB,OAAO,IAAI,WAAW;EACxB;EACA,OAAO;CACT,CAAC,EACA,QAAQ,MAAM,EAAE,SAAS,CAAC;CAI7B,MAAM,gBAAgB,SAAS,WAAW,MAAM,EAAE,SAAS,GAAG,CAAC;CAC/D,IAAI,kBAAkB,MAAM,kBAAkB,SAAS,SAAS,GAC9D,MAAM,IAAI,MACR,uBAAuB,KAAK,0DAC9B;CAIF,OAAO;EAAE,WADS,SAAS,WAAW,IAAI,MAAM,IAAI,SAAS,KAAK,GAAG;EACjD;EAAQ;CAAS;AACvC;;AAGA,SAAgB,UAAU,MAAsB;CAS9C,OAAO,SARM,SAAS,IAAI,EACvB,QAAQ,UAAU,GAAG,EACrB,QAAQ,oBAAoB,SAAS,EACrC,QAAQ,cAAc,IAAI,EAC1B,QAAQ,SAAS,EAAE,EACnB,QAAQ,kBAAkB,GAAG,EAC7B,QAAQ,OAAO,GAAG,EAClB,QAAQ,UAAU,EACF,KAAK;AAC1B;;;;;;;;AASA,SAAgB,mBAAmB,OAAyC;CAC1E,MAAM,SAAuB,CAAC;CAC9B,IAAI;CAEJ,MAAM,yBAAS,IAAI,IAAoB;CAIvC,MAAM,0BAAU,IAAI,IAAoB;CAExC,KAAK,MAAM,QAAQ,CAAC,GAAG,KAAK,EAAE,KAAK,GAAG;EACpC,IAAI,CAAC,WAAW,KAAK,IAAI,GAAG;EAC5B,MAAM,WAAW,SAAS,IAAI,EAAE,MAAM,GAAG,EAAE,IAAI,KAAK;EACpD,IAAI,aAAa,cAAc;GAC7B,WAAW;GACX;EACF;EAGA,IAAI,SAAS,WAAW,GAAG,KAAK,SAAS,WAAW,GAAG,GAAG;EAE1D,MAAM,EAAE,WAAW,QAAQ,aAAa,YAAY,IAAI;EACxD,MAAM,QAAQ,OAAO,IAAI,SAAS;EAClC,IAAI,UAAU,KAAA,GACZ,MAAM,IAAI,MACR,yBAAyB,UAAU,WAAW,MAAM,SAAS,KAAK,aACpE;EAEF,OAAO,IAAI,WAAW,IAAI;EAC1B,MAAM,QAAQ,UAAU,IAAI;EAC5B,MAAM,aAAa,QAAQ,IAAI,KAAK;EACpC,IAAI,eAAe,KAAA,GACjB,MAAM,IAAI,MACR,yBAAyB,MAAM,WAAW,WAAW,SAAS,KAAK,2EAErE;EAEF,QAAQ,IAAI,OAAO,IAAI;EACvB,OAAO,KAAK;GAAE;GAAW;GAAM;GAAO;GAAQ;EAAS,CAAC;CAC1D;CAEA,MAAM,WAA0B,EAAE,OAAO;CACzC,IAAI,aAAa,KAAA,GAAW,SAAS,WAAW;CAChD,OAAO;AACT"}

package/dist/transform.d.ts

@@ -0,0 +1,20 @@
+import { CompileOptions, CompileResult } from "./types.js";
+
+//#region src/transform.d.ts
+/**
+ * Compile a single TSX/TS module to JavaScript.
+ *
+ * Pipeline: JSX desugar → tree-flatten (optional) → user plugins → emit.
+ * Returns emitted code, an optional source map, any (transpile-level)
+ * diagnostics, and optimizer stats. Use {@link compileChecked} to gate on the
+ * full type checker.
+ */
+declare function compile(source: string, options?: CompileOptions): CompileResult;
+/**
+ * Type-check then compile. If the gate finds any `error` diagnostic, returns it
+ * WITHOUT emitting code (`code: ''`) — the build must not ship type errors.
+ */
+declare function compileChecked(source: string, options?: CompileOptions): CompileResult;
+//#endregion
+export { compile, compileChecked };
+//# sourceMappingURL=transform.d.ts.map

package/dist/transform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transform.d.ts","names":[],"sources":["../src/transform.ts"],"mappings":";;;AAqCoF;AAoDpF;;;;;;;AApDoF,iBAApE,OAAA,CAAQ,MAAA,UAAgB,OAAA,GAAS,cAAA,GAAsB,aAAa;;AAoDO;;;iBAA3E,cAAA,CAAe,MAAA,UAAgB,OAAA,GAAS,cAAA,GAAsB,aAAa"}

package/dist/transform.js

@@ -0,0 +1,93 @@
+import { createFlattenTransformer } from "./flatten.js";
+import { hasErrors, typecheck } from "./typecheck.js";
+import ts from "typescript";
+//#region src/transform.ts
+/**
+* The MDC transform/compile pipeline.
+*
+* `compile()` lowers TSX → `createElement(...)` (matching `@mindees/core`'s
+* factory), runs the built-in optimizer passes (tree-flattening) plus any user
+* plugins, and emits JavaScript + a source map. It does **not** type-check
+* (that's {@link typecheck}); `compileChecked()` runs the gate first and refuses
+* to emit on `error` diagnostics.
+*
+* @module
+*/
+/** Compiler options for emit (JSX classic → createElement/Fragment). */
+function emitOptions(sourceMap) {
+	return {
+		jsx: ts.JsxEmit.React,
+		jsxFactory: "createElement",
+		jsxFragmentFactory: "Fragment",
+		target: ts.ScriptTarget.ES2023,
+		module: ts.ModuleKind.ESNext,
+		sourceMap
+	};
+}
+/**
+* Compile a single TSX/TS module to JavaScript.
+*
+* Pipeline: JSX desugar → tree-flatten (optional) → user plugins → emit.
+* Returns emitted code, an optional source map, any (transpile-level)
+* diagnostics, and optimizer stats. Use {@link compileChecked} to gate on the
+* full type checker.
+*/
+function compile(source, options = {}) {
+	const { fileName = "module.tsx", sourceMap = true, flatten = true, plugins = [] } = options;
+	const after = [];
+	let stats = {
+		flattenedNodes: 0,
+		totalElements: 0
+	};
+	if (flatten) {
+		const flattener = createFlattenTransformer(ts);
+		after.push(flattener.factory);
+		stats = flattener.stats;
+	}
+	for (const plugin of plugins) after.push(plugin.transformer(ts));
+	const output = ts.transpileModule(source, {
+		compilerOptions: emitOptions(sourceMap),
+		fileName,
+		reportDiagnostics: true,
+		transformers: { after }
+	});
+	const diagnostics = (output.diagnostics ?? []).map((d) => {
+		const message = ts.flattenDiagnosticMessageText(d.messageText, "\n");
+		return {
+			severity: d.category === ts.DiagnosticCategory.Error ? "error" : "warning",
+			code: `TS${d.code}`,
+			message
+		};
+	});
+	const result = {
+		code: output.outputText,
+		diagnostics,
+		stats
+	};
+	if (sourceMap && output.sourceMapText) result.map = output.sourceMapText;
+	return result;
+}
+/**
+* Type-check then compile. If the gate finds any `error` diagnostic, returns it
+* WITHOUT emitting code (`code: ''`) — the build must not ship type errors.
+*/
+function compileChecked(source, options = {}) {
+	const diagnostics = typecheck(source, options.fileName ?? "module.tsx");
+	if (hasErrors(diagnostics)) return {
+		code: "",
+		diagnostics,
+		stats: {
+			flattenedNodes: 0,
+			totalElements: 0
+		}
+	};
+	const compiled = compile(source, options);
+	return {
+		...compiled,
+		diagnostics: [...diagnostics, ...compiled.diagnostics]
+	};
+}
+//#endregion
+export { compile, compileChecked };
+
+//# sourceMappingURL=transform.js.map

package/dist/transform.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transform.js","names":[],"sources":["../src/transform.ts"],"sourcesContent":["/**\n * The MDC transform/compile pipeline.\n *\n * `compile()` lowers TSX → `createElement(...)` (matching `@mindees/core`'s\n * factory), runs the built-in optimizer passes (tree-flattening) plus any user\n * plugins, and emits JavaScript + a source map. It does **not** type-check\n * (that's {@link typecheck}); `compileChecked()` runs the gate first and refuses\n * to emit on `error` diagnostics.\n *\n * @module\n */\n\nimport ts from 'typescript'\nimport { createFlattenTransformer } from './flatten'\nimport { hasErrors, typecheck } from './typecheck'\nimport type { CompileOptions, CompileResult, CompileStats } from './types'\n\n/** Compiler options for emit (JSX classic → createElement/Fragment). */\nfunction emitOptions(sourceMap: boolean): ts.CompilerOptions {\n  return {\n    jsx: ts.JsxEmit.React,\n    jsxFactory: 'createElement',\n    jsxFragmentFactory: 'Fragment',\n    target: ts.ScriptTarget.ES2023,\n    module: ts.ModuleKind.ESNext,\n    sourceMap,\n  }\n}\n\n/**\n * Compile a single TSX/TS module to JavaScript.\n *\n * Pipeline: JSX desugar → tree-flatten (optional) → user plugins → emit.\n * Returns emitted code, an optional source map, any (transpile-level)\n * diagnostics, and optimizer stats. Use {@link compileChecked} to gate on the\n * full type checker.\n */\nexport function compile(source: string, options: CompileOptions = {}): CompileResult {\n  const { fileName = 'module.tsx', sourceMap = true, flatten = true, plugins = [] } = options\n\n  // IMPORTANT: our optimizer + plugins operate on the desugared\n  // `createElement(...)` call form, but `transpileModule` runs `before`\n  // transformers on the *pre-desugar* JSX AST. JSX is lowered during the\n  // `after` phase, so flatten/plugins must run there to see the calls.\n  const after: ts.TransformerFactory<ts.SourceFile>[] = []\n  let stats: CompileStats = { flattenedNodes: 0, totalElements: 0 }\n\n  if (flatten) {\n    const flattener = createFlattenTransformer(ts)\n    after.push(flattener.factory)\n    stats = flattener.stats // live object, updated during emit\n  }\n\n  for (const plugin of plugins) {\n    after.push(plugin.transformer(ts) as ts.TransformerFactory<ts.SourceFile>)\n  }\n\n  const output = ts.transpileModule(source, {\n    compilerOptions: emitOptions(sourceMap),\n    fileName,\n    reportDiagnostics: true,\n    transformers: { after },\n  })\n\n  // transpileModule only surfaces a few syntactic diagnostics; semantic ones\n  // come from the type-check gate. Map each to our structured form.\n  const diagnostics = (output.diagnostics ?? []).map((d) => {\n    const message = ts.flattenDiagnosticMessageText(d.messageText, '\\n')\n    return {\n      severity:\n        d.category === ts.DiagnosticCategory.Error ? ('error' as const) : ('warning' as const),\n      code: `TS${d.code}`,\n      message,\n    }\n  })\n\n  const result: CompileResult = {\n    code: output.outputText,\n    diagnostics,\n    stats,\n  }\n  if (sourceMap && output.sourceMapText) result.map = output.sourceMapText\n  return result\n}\n\n/**\n * Type-check then compile. If the gate finds any `error` diagnostic, returns it\n * WITHOUT emitting code (`code: ''`) — the build must not ship type errors.\n */\nexport function compileChecked(source: string, options: CompileOptions = {}): CompileResult {\n  const fileName = options.fileName ?? 'module.tsx'\n  const diagnostics = typecheck(source, fileName)\n  if (hasErrors(diagnostics)) {\n    return { code: '', diagnostics, stats: { flattenedNodes: 0, totalElements: 0 } }\n  }\n  const compiled = compile(source, options)\n  // Surface any type-check warnings alongside the compile result.\n  return { ...compiled, diagnostics: [...diagnostics, ...compiled.diagnostics] }\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAkBA,SAAS,YAAY,WAAwC;CAC3D,OAAO;EACL,KAAK,GAAG,QAAQ;EAChB,YAAY;EACZ,oBAAoB;EACpB,QAAQ,GAAG,aAAa;EACxB,QAAQ,GAAG,WAAW;EACtB;CACF;AACF;;;;;;;;;AAUA,SAAgB,QAAQ,QAAgB,UAA0B,CAAC,GAAkB;CACnF,MAAM,EAAE,WAAW,cAAc,YAAY,MAAM,UAAU,MAAM,UAAU,CAAC,MAAM;CAMpF,MAAM,QAAgD,CAAC;CACvD,IAAI,QAAsB;EAAE,gBAAgB;EAAG,eAAe;CAAE;CAEhE,IAAI,SAAS;EACX,MAAM,YAAY,yBAAyB,EAAE;EAC7C,MAAM,KAAK,UAAU,OAAO;EAC5B,QAAQ,UAAU;CACpB;CAEA,KAAK,MAAM,UAAU,SACnB,MAAM,KAAK,OAAO,YAAY,EAAE,CAAyC;CAG3E,MAAM,SAAS,GAAG,gBAAgB,QAAQ;EACxC,iBAAiB,YAAY,SAAS;EACtC;EACA,mBAAmB;EACnB,cAAc,EAAE,MAAM;CACxB,CAAC;CAID,MAAM,eAAe,OAAO,eAAe,CAAC,GAAG,KAAK,MAAM;EACxD,MAAM,UAAU,GAAG,6BAA6B,EAAE,aAAa,IAAI;EACnE,OAAO;GACL,UACE,EAAE,aAAa,GAAG,mBAAmB,QAAS,UAAqB;GACrE,MAAM,KAAK,EAAE;GACb;EACF;CACF,CAAC;CAED,MAAM,SAAwB;EAC5B,MAAM,OAAO;EACb;EACA;CACF;CACA,IAAI,aAAa,OAAO,eAAe,OAAO,MAAM,OAAO;CAC3D,OAAO;AACT;;;;;AAMA,SAAgB,eAAe,QAAgB,UAA0B,CAAC,GAAkB;CAE1F,MAAM,cAAc,UAAU,QADb,QAAQ,YAAY,YACS;CAC9C,IAAI,UAAU,WAAW,GACvB,OAAO;EAAE,MAAM;EAAI;EAAa,OAAO;GAAE,gBAAgB;GAAG,eAAe;EAAE;CAAE;CAEjF,MAAM,WAAW,QAAQ,QAAQ,OAAO;CAExC,OAAO;EAAE,GAAG;EAAU,aAAa,CAAC,GAAG,aAAa,GAAG,SAAS,WAAW;CAAE;AAC/E"}

package/dist/typecheck.d.ts

@@ -0,0 +1,16 @@
+import { Diagnostic } from "./types.js";
+
+//#region src/typecheck.d.ts
+/**
+ * Type-check a single module's source and return its diagnostics.
+ *
+ * @param source - The module source (`.tsx` is assumed unless `fileName` says otherwise).
+ * @param fileName - Logical file name. Default `"module.tsx"`.
+ * @returns All `error`/`warning` diagnostics (semantic + syntactic). Empty = clean.
+ */
+declare function typecheck(source: string, fileName?: string): Diagnostic[];
+/** True if any diagnostic is an `error` (i.e. the build must fail). */
+declare function hasErrors(diagnostics: readonly Diagnostic[]): boolean;
+//#endregion
+export { hasErrors, typecheck };
+//# sourceMappingURL=typecheck.d.ts.map

package/dist/typecheck.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typecheck.d.ts","names":[],"sources":["../src/typecheck.ts"],"mappings":";;;;;;AAiK4D;;;;iBAvD5C,SAAA,CAAU,MAAA,UAAgB,QAAA,YAA0B,UAAU;;iBAuD9D,SAAA,CAAU,WAAkC,WAAZ,UAAU"}

package/dist/typecheck.js

@@ -0,0 +1,129 @@
+import ts from "typescript";
+//#region src/typecheck.ts
+/**
+* The MDC type-check gate.
+*
+* Runs the TypeScript checker over a single in-memory module and reports
+* structured {@link Diagnostic}s. This is the compiler's correctness gate: a
+* build with any `error`-severity diagnostic must not ship.
+*
+* It uses an in-memory `CompilerHost` so no files touch disk; lib `.d.ts` files
+* are read from the real `typescript` install so global types resolve.
+*
+* @module
+*/
+/** Synthetic ambient module that gives the single-module gate a JSX environment. */
+const JSX_LIB_FILE = "__mindees_jsx__.d.ts";
+const JSX_LIB_SOURCE = `declare namespace JSX {
+  interface IntrinsicElements { [name: string]: Record<string, unknown> }
+  type Element = unknown
+}
+`;
+/**
+* Module-resolution diagnostic codes the single-module gate cannot meaningfully
+* judge (it type-checks ONE module with `noResolve`, so every import is
+* "unresolved"). Cross-module resolution is the project-graph type-check's job.
+* - TS2307: Cannot find module '…'.
+* - TS2792: Cannot find module … (did you mean to set 'moduleResolution'?).
+*/
+const UNRESOLVED_IMPORT_CODES = new Set([2307, 2792]);
+/** Default compiler options for the gate: strict, modern, JSX-aware. */
+function defaultOptions() {
+	return {
+		strict: true,
+		noUncheckedIndexedAccess: true,
+		exactOptionalPropertyTypes: true,
+		target: ts.ScriptTarget.ES2023,
+		module: ts.ModuleKind.ESNext,
+		moduleResolution: ts.ModuleResolutionKind.Bundler,
+		jsx: ts.JsxEmit.React,
+		jsxFactory: "createElement",
+		jsxFragmentFactory: "Fragment",
+		noEmit: true,
+		skipLibCheck: true,
+		noResolve: true,
+		types: []
+	};
+}
+function toSeverity(category) {
+	if (category === ts.DiagnosticCategory.Error) return "error";
+	if (category === ts.DiagnosticCategory.Warning) return "warning";
+	return null;
+}
+/**
+* Map a file extension to its `ScriptKind`. `ts.createSourceFile` does NOT infer
+* this — omitting it would mis-parse files — so we map it explicitly (not via
+* any TypeScript-internal helper). A `.ts` file thus rejects JSX, while `.tsx`
+* accepts it.
+*/
+function scriptKindForFile(fileName) {
+	const lower = fileName.toLowerCase();
+	if (lower.endsWith(".tsx")) return ts.ScriptKind.TSX;
+	if (lower.endsWith(".jsx")) return ts.ScriptKind.JSX;
+	if (lower.endsWith(".js") || lower.endsWith(".mjs") || lower.endsWith(".cjs")) return ts.ScriptKind.JS;
+	if (lower.endsWith(".json")) return ts.ScriptKind.JSON;
+	return ts.ScriptKind.TS;
+}
+/** Convert a TypeScript diagnostic to our structured form. */
+function convert(diag) {
+	if (UNRESOLVED_IMPORT_CODES.has(diag.code)) return null;
+	const severity = toSeverity(diag.category);
+	if (!severity) return null;
+	const message = ts.flattenDiagnosticMessageText(diag.messageText, "\n");
+	const out = {
+		severity,
+		code: `TS${diag.code}`,
+		message
+	};
+	if (diag.file) {
+		out.file = diag.file.fileName;
+		if (diag.start !== void 0) {
+			const { line, character } = diag.file.getLineAndCharacterOfPosition(diag.start);
+			out.position = {
+				line: line + 1,
+				column: character + 1
+			};
+		}
+	}
+	return out;
+}
+/**
+* Type-check a single module's source and return its diagnostics.
+*
+* @param source - The module source (`.tsx` is assumed unless `fileName` says otherwise).
+* @param fileName - Logical file name. Default `"module.tsx"`.
+* @returns All `error`/`warning` diagnostics (semantic + syntactic). Empty = clean.
+*/
+function typecheck(source, fileName = "module.tsx") {
+	const options = defaultOptions();
+	const sourceFile = ts.createSourceFile(fileName, source, ts.ScriptTarget.ES2023, true, scriptKindForFile(fileName));
+	const jsxLib = ts.createSourceFile(JSX_LIB_FILE, JSX_LIB_SOURCE, ts.ScriptTarget.ES2023, true, ts.ScriptKind.TS);
+	const defaultHost = ts.createCompilerHost(options);
+	const host = {
+		...defaultHost,
+		getSourceFile: (name, languageVersion, onError, shouldCreate) => {
+			if (name === fileName) return sourceFile;
+			if (name === JSX_LIB_FILE) return jsxLib;
+			return defaultHost.getSourceFile(name, languageVersion, onError, shouldCreate);
+		},
+		writeFile: () => {},
+		fileExists: (name) => name === fileName || name === JSX_LIB_FILE || defaultHost.fileExists(name),
+		readFile: (name) => name === fileName ? source : name === JSX_LIB_FILE ? JSX_LIB_SOURCE : defaultHost.readFile(name)
+	};
+	const program = ts.createProgram([JSX_LIB_FILE, fileName], options, host);
+	const diagnostics = [...program.getSyntacticDiagnostics(sourceFile), ...program.getSemanticDiagnostics(sourceFile)];
+	const out = [];
+	for (const d of diagnostics) {
+		const converted = convert(d);
+		if (converted) out.push(converted);
+	}
+	return out;
+}
+/** True if any diagnostic is an `error` (i.e. the build must fail). */
+function hasErrors(diagnostics) {
+	return diagnostics.some((d) => d.severity === "error");
+}
+//#endregion
+export { hasErrors, typecheck };
+
+//# sourceMappingURL=typecheck.js.map

package/dist/typecheck.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"typecheck.js","names":[],"sources":["../src/typecheck.ts"],"sourcesContent":["/**\n * The MDC type-check gate.\n *\n * Runs the TypeScript checker over a single in-memory module and reports\n * structured {@link Diagnostic}s. This is the compiler's correctness gate: a\n * build with any `error`-severity diagnostic must not ship.\n *\n * It uses an in-memory `CompilerHost` so no files touch disk; lib `.d.ts` files\n * are read from the real `typescript` install so global types resolve.\n *\n * @module\n */\n\nimport ts from 'typescript'\nimport type { Diagnostic } from './types'\n\n/** Synthetic ambient module that gives the single-module gate a JSX environment. */\nconst JSX_LIB_FILE = '__mindees_jsx__.d.ts'\nconst JSX_LIB_SOURCE = `declare namespace JSX {\n  interface IntrinsicElements { [name: string]: Record<string, unknown> }\n  type Element = unknown\n}\n`\n\n/**\n * Module-resolution diagnostic codes the single-module gate cannot meaningfully\n * judge (it type-checks ONE module with `noResolve`, so every import is\n * \"unresolved\"). Cross-module resolution is the project-graph type-check's job.\n * - TS2307: Cannot find module '…'.\n * - TS2792: Cannot find module … (did you mean to set 'moduleResolution'?).\n */\nconst UNRESOLVED_IMPORT_CODES = new Set([2307, 2792])\n\n/** Default compiler options for the gate: strict, modern, JSX-aware. */\nfunction defaultOptions(): ts.CompilerOptions {\n  return {\n    strict: true,\n    noUncheckedIndexedAccess: true,\n    exactOptionalPropertyTypes: true,\n    target: ts.ScriptTarget.ES2023,\n    module: ts.ModuleKind.ESNext,\n    moduleResolution: ts.ModuleResolutionKind.Bundler,\n    jsx: ts.JsxEmit.React,\n    jsxFactory: 'createElement',\n    jsxFragmentFactory: 'Fragment',\n    noEmit: true,\n    skipLibCheck: true,\n    // Type-check a single module in isolation; imports are not resolved here\n    // (unresolved-import diagnostics are filtered — see UNRESOLVED_IMPORT_CODES).\n    noResolve: true,\n    types: [],\n  }\n}\n\nfunction toSeverity(category: ts.DiagnosticCategory): 'error' | 'warning' | null {\n  if (category === ts.DiagnosticCategory.Error) return 'error'\n  if (category === ts.DiagnosticCategory.Warning) return 'warning'\n  return null\n}\n\n/**\n * Map a file extension to its `ScriptKind`. `ts.createSourceFile` does NOT infer\n * this — omitting it would mis-parse files — so we map it explicitly (not via\n * any TypeScript-internal helper). A `.ts` file thus rejects JSX, while `.tsx`\n * accepts it.\n */\nfunction scriptKindForFile(fileName: string): ts.ScriptKind {\n  const lower = fileName.toLowerCase()\n  if (lower.endsWith('.tsx')) return ts.ScriptKind.TSX\n  if (lower.endsWith('.jsx')) return ts.ScriptKind.JSX\n  if (lower.endsWith('.js') || lower.endsWith('.mjs') || lower.endsWith('.cjs')) {\n    return ts.ScriptKind.JS\n  }\n  if (lower.endsWith('.json')) return ts.ScriptKind.JSON\n  return ts.ScriptKind.TS\n}\n\n/** Convert a TypeScript diagnostic to our structured form. */\nfunction convert(diag: ts.Diagnostic): Diagnostic | null {\n  // The single-module gate doesn't resolve imports; drop unresolved-import noise.\n  if (UNRESOLVED_IMPORT_CODES.has(diag.code)) return null\n  const severity = toSeverity(diag.category)\n  if (!severity) return null\n  const message = ts.flattenDiagnosticMessageText(diag.messageText, '\\n')\n  const out: Diagnostic = {\n    severity,\n    code: `TS${diag.code}`,\n    message,\n  }\n  if (diag.file) {\n    out.file = diag.file.fileName\n    if (diag.start !== undefined) {\n      const { line, character } = diag.file.getLineAndCharacterOfPosition(diag.start)\n      out.position = { line: line + 1, column: character + 1 }\n    }\n  }\n  return out\n}\n\n/**\n * Type-check a single module's source and return its diagnostics.\n *\n * @param source - The module source (`.tsx` is assumed unless `fileName` says otherwise).\n * @param fileName - Logical file name. Default `\"module.tsx\"`.\n * @returns All `error`/`warning` diagnostics (semantic + syntactic). Empty = clean.\n */\nexport function typecheck(source: string, fileName = 'module.tsx'): Diagnostic[] {\n  const options = defaultOptions()\n  const sourceFile = ts.createSourceFile(\n    fileName,\n    source,\n    ts.ScriptTarget.ES2023,\n    true,\n    scriptKindForFile(fileName),\n  )\n  // A synthetic ambient JSX lib so intrinsic elements (`<view>`, `<text>`, …)\n  // type-check without each module declaring JSX.IntrinsicElements.\n  const jsxLib = ts.createSourceFile(\n    JSX_LIB_FILE,\n    JSX_LIB_SOURCE,\n    ts.ScriptTarget.ES2023,\n    true,\n    ts.ScriptKind.TS,\n  )\n\n  const defaultHost = ts.createCompilerHost(options)\n  const host: ts.CompilerHost = {\n    ...defaultHost,\n    getSourceFile: (name, languageVersion, onError, shouldCreate) => {\n      if (name === fileName) return sourceFile\n      if (name === JSX_LIB_FILE) return jsxLib\n      return defaultHost.getSourceFile(name, languageVersion, onError, shouldCreate)\n    },\n    writeFile: () => {\n      /* noEmit */\n    },\n    fileExists: (name) =>\n      name === fileName || name === JSX_LIB_FILE || defaultHost.fileExists(name),\n    readFile: (name) =>\n      name === fileName\n        ? source\n        : name === JSX_LIB_FILE\n          ? JSX_LIB_SOURCE\n          : defaultHost.readFile(name),\n  }\n\n  const program = ts.createProgram([JSX_LIB_FILE, fileName], options, host)\n  const diagnostics = [\n    ...program.getSyntacticDiagnostics(sourceFile),\n    ...program.getSemanticDiagnostics(sourceFile),\n  ]\n\n  const out: Diagnostic[] = []\n  for (const d of diagnostics) {\n    const converted = convert(d)\n    if (converted) out.push(converted)\n  }\n  return out\n}\n\n/** True if any diagnostic is an `error` (i.e. the build must fail). */\nexport function hasErrors(diagnostics: readonly Diagnostic[]): boolean {\n  return diagnostics.some((d) => d.severity === 'error')\n}\n"],"mappings":"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"}

package/dist/types.d.ts

@@ -0,0 +1,78 @@
+//#region src/types.d.ts
+/**
+ * Shared types for the Mindees Compiler (MDC).
+ *
+ * @module
+ */
+/** Severity of a {@link Diagnostic}. */
+type DiagnosticSeverity = 'error' | 'warning';
+/** A 1-based source position. */
+interface SourcePosition {
+  /** 1-based line. */
+  line: number;
+  /** 1-based column. */
+  column: number;
+}
+/** A compiler diagnostic (a type error, lint-ish issue, or transform note). */
+interface Diagnostic {
+  severity: DiagnosticSeverity;
+  /** Stable code, e.g. `"TS2345"` for a TypeScript diagnostic. */
+  code: string;
+  /** Human-readable message. */
+  message: string;
+  /** Source file the diagnostic refers to, if known. */
+  file?: string;
+  /** Start position in the file, if known. */
+  position?: SourcePosition;
+}
+/** The result of compiling a single module. */
+interface CompileResult {
+  /** Emitted JavaScript. */
+  code: string;
+  /** Source map (JSON string), when source maps are enabled. */
+  map?: string;
+  /** Diagnostics produced (type errors etc.). Empty on a clean compile. */
+  diagnostics: Diagnostic[];
+  /** Optimizer statistics for this module. */
+  stats: CompileStats;
+}
+/** Per-compile optimizer statistics, used by tests and the perf budget. */
+interface CompileStats {
+  /** `createElement` calls collapsed by tree-flattening. */
+  flattenedNodes: number;
+  /** Total `createElement` calls seen before flattening. */
+  totalElements: number;
+}
+/** Options controlling a compile. */
+interface CompileOptions {
+  /** Logical file name (drives JSX/TS parsing + diagnostics + maps). Default `"module.tsx"`. */
+  fileName?: string;
+  /** Emit a source map. Default `true`. */
+  sourceMap?: boolean;
+  /** Run the tree-flattening optimizer pass. Default `true`. */
+  flatten?: boolean;
+  /** Additional transform plugins to run (after the built-in passes). */
+  plugins?: MdcPlugin[];
+}
+/**
+ * A transform plugin. Plugins operate on the desugared `createElement(...)` call
+ * form, so they see a stable, framework-level shape. Because `transpileModule`
+ * lowers JSX during the **`after`** phase, the returned factory is run as an
+ * **`after`** transformer (a `before` transformer would see raw JSX, not calls).
+ *
+ * Typed structurally against `unknown` here to avoid leaking the `typescript`
+ * types across the package boundary; see `transform.ts` for the concrete usage.
+ */
+interface MdcPlugin {
+  /** Unique plugin name (for diagnostics + ordering). */
+  name: string;
+  /**
+   * Build a TypeScript transformer factory:
+   * `(ts, program?) => TransformerFactory<SourceFile>`.
+   * Receives the `typescript` module so plugins don't import it themselves.
+   */
+  transformer: (ts: typeof import('typescript')) => unknown;
+}
+//#endregion
+export { CompileOptions, CompileResult, CompileStats, Diagnostic, DiagnosticSeverity, MdcPlugin, SourcePosition };
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","names":[],"sources":["../src/types.ts"],"mappings":";;AAOA;;;;AAA8B;AAAA,KAAlB,kBAAA;;UAGK,cAAA;EAEf;EAAA,IAAA;EAMe;EAJf,MAAM;AAAA;;UAIS,UAAA;EACf,QAAA,EAAU,kBAAA;EAEV;EAAA,IAAA;EAIA;EAFA,OAAA;EAIW;EAFX,IAAA;EAEyB;EAAzB,QAAA,GAAW,cAAc;AAAA;;UAIV,aAAA;EAEf;EAAA,IAAA;EAIA;EAFA,GAAA;EAIA;EAFA,WAAA,EAAa,UAAA;EAEM;EAAnB,KAAA,EAAO,YAAY;AAAA;;UAIJ,YAAA;EAEf;EAAA,cAAA;EAMe;EAJf,aAAa;AAAA;;UAIE,cAAA;EAIf;EAFA,QAAA;EAMA;EAJA,SAAA;EAImB;EAFnB,OAAA;EAce;EAZf,OAAA,GAAU,SAAS;AAAA;;;;;;AAoB0B;;;;UAR9B,SAAA;;EAEf,IAAA;;;;;;EAMA,WAAA,GAAc,EAAA;AAAA"}

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@mindees/compiler",
+  "version": "0.1.0",
+  "description": "MindeesNative Compiler (MDC) — build-time optimizer: type-check gate, TSX→createElement transform, tree-flattening, per-route code-splitting, and a plugin API. TS→native AOT is a research track.",
+  "license": "MIT OR Apache-2.0",
+  "type": "module",
+  "sideEffects": false,
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mindees/mindees.git",
+    "directory": "packages/compiler"
+  },
+  "dependencies": {
+    "typescript": "6.0.3",
+    "@mindees/core": "0.1.0"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "typecheck": "tsc --noEmit"
+  }
+}