@supacloud/compiler 0.5.0 → 0.6.0

package/dist/program.d.ts

@@ -0,0 +1,30 @@
+import * as ts from "@typescript/typescript6";
+import { type TraitRecord } from "./traits";
+export interface IncrementalProgramSession {
+    /** The current TypeScript program used as the semantic compilation boundary. */
+    getProgram(): ts.Program;
+    /** The current TypeScript type checker. */
+    getTypeChecker(): ts.TypeChecker;
+    /** Update the program while preserving TypeScript's incremental state. */
+    update(rootNames: string[], changedPaths?: string[]): ProgramUpdate;
+    /** Local Angular-style metadata records compiled from the current Program. */
+    getTraits(): readonly TraitRecord[];
+    /** TypeScript syntactic diagnostics for the current Program. */
+    getDiagnostics(): readonly ts.Diagnostic[];
+    /** Emit the current TypeScript program using the builder's incremental state. */
+    emit(): ts.EmitResult;
+    /** Drop the retained builder and source versions. */
+    reset(): void;
+}
+export interface ProgramUpdate {
+    changedFiles: string[];
+    reusedFiles: string[];
+    program: ts.Program;
+}
+/**
+ * Angular-style semantic boundary around TypeScript's incremental program.
+ *
+ * This deliberately owns only TypeScript program state. SupaCloud metadata
+ * handlers and ApplicationGraph linking remain separate layers.
+ */
+export declare function createIncrementalProgramSession(projectRoot: string): IncrementalProgramSession;

package/dist/traits.d.ts

@@ -0,0 +1,32 @@
+import * as ts from "@typescript/typescript6";
+export type TraitKind = "module" | "injectable" | "controller" | "command" | "query" | "defineModule" | "injectionToken";
+export interface TraitRecord {
+    kind: TraitKind;
+    name: string;
+    file: string;
+    start: number;
+    end: number;
+    fingerprint: string;
+}
+export interface TraitCompilation {
+    byFile: Map<string, TraitRecord[]>;
+    all: TraitRecord[];
+}
+export interface TraitHandler {
+    readonly kind: TraitKind;
+    detect(node: ts.Node): string | undefined;
+}
+export declare class TraitCompiler {
+    private readonly handlers;
+    constructor(handlers?: readonly TraitHandler[]);
+    /**
+     * Angular-style local metadata compiler.
+     *
+     * This pass is intentionally syntax-only. It discovers candidate declarations
+     * cheaply; handlers that need symbols or types run later against the Program's
+     * TypeChecker.
+     */
+    compile(program: ts.Program, previous: TraitCompilation | undefined, changedFiles: Set<string>): TraitCompilation;
+    private compileSourceFile;
+}
+export declare function compileTraits(program: ts.Program, previous: TraitCompilation | undefined, changedFiles: Set<string>): TraitCompilation;

package/dist/type-safety.d.ts

@@ -0,0 +1,9 @@
+import type { Diagnostic, TypeSafetyOptions } from "./types";
+export interface TypeSafetyScanOptions extends TypeSafetyOptions {
+    rootDir: string;
+    include?: string[];
+    outDir?: string;
+    strict?: boolean;
+}
+export declare function scanGeneratedArtifacts(artifacts: Record<string, string | undefined>, strict?: boolean): Diagnostic[];
+export declare function scanProductionSource(options: TypeSafetyScanOptions): Diagnostic[];

package/dist/types.d.ts

@@ -2,9 +2,34 @@
  * ApplicationGraph: Static application graph built by the compiler from source AST.
  * No runtime reflection or container; all metadata is explicitly represented here and in generated code.
  */
+import type { IncrementalProgramSession } from "./program";
 export type Scope = "application" | "request" | "job";
 export type ProviderKind = "class" | "value" | "factory" | "existing";
 export type TokenKind = "injection-token" | "class";
+export interface FunctionalInjectNode {
+    /** Logical token name used by the application graph. */
+    token: string;
+    /** Source expression used to identify the runtime token. */
+    expression: string;
+    /** Relative source module path for the token expression. */
+    importPath?: string;
+    /** Package module specifier for a library token. */
+    importModule?: string;
+    optional?: boolean;
+    self?: boolean;
+    skipSelf?: boolean;
+    host?: boolean;
+}
+export interface AspectRefNode {
+    /** Exported symbol name used in the generated static import. */
+    name: string;
+    /** Source expression retained for diagnostics and manifest inspection. */
+    expression: string;
+    /** Relative source module path for a project-local aspect. */
+    importPath?: string;
+    /** Package module specifier for a library aspect. */
+    importModule?: string;
+}
 export interface Diagnostic {
     severity: "error" | "warn";
     code: string;
@@ -38,6 +63,8 @@ export interface ProviderNode {
     skipSelfDeps?: string[];
     /** Parameter tokens marked @Host(). */
     hostDeps?: string[];
+    /** Property-level Angular functional inject() calls compiled into a static context. */
+    functionalInjects?: FunctionalInjectNode[];
     /** When true, multiple providers can contribute to this token as an array of instances (Angular multi-providers). */
     multi?: boolean;
     /** Automatically provided in the root injector context without manual module declaration (Angular-style). */
@@ -49,6 +76,8 @@ export interface ProviderNode {
     line: number;
     /** Relative module path of useClass/useFactory/useValue symbol (for import generation). */
     importPath?: string;
+    /** Package module specifier for providers supplied by a library. */
+    importModule?: string;
 }
 export interface HandlerParamNode {
     name: string;
@@ -101,16 +130,24 @@ export interface RouteNode {
     data?: Record<string, unknown>;
     /** Detailed method parameter metadata for compile-time typed invoker generation. */
     handlerParams?: HandlerParamNode[];
+    /** Explicit aspects applied around this route. */
+    aspects?: AspectRefNode[];
 }
 export interface ControllerNode {
     className: string;
     path: string;
     scope: Scope;
     deps: string[];
+    /** Class implements OnDestroy interface or onDestroy method. */
+    hasOnDestroy?: boolean;
     /** Parameter tokens marked @Optional(). */
     optionalDeps?: string[];
     selfDeps?: string[];
     skipSelfDeps?: string[];
+    /** Parameter tokens marked @Host(). */
+    hostDeps?: string[];
+    /** Property-level Angular functional inject() calls compiled into a static context. */
+    functionalInjects?: FunctionalInjectNode[];
     /** Automatically registered without manual module declaration (Angular standalone controller style). */
     standalone?: boolean;
     routes: RouteNode[];
@@ -128,6 +165,14 @@ export interface CommandNode {
     idempotency: "required" | "none";
     /** Automatically registered without manual module declaration. */
     standalone?: boolean;
+    /** Explicit aspects applied around this command. */
+    aspects?: AspectRefNode[];
+}
+export interface JobNode {
+    className: string;
+    name: string;
+    scope: Scope;
+    aspects?: AspectRefNode[];
 }
 export interface QueryNode {
     className: string;
@@ -146,7 +191,10 @@ export interface ModuleNode {
     providers: ProviderNode[];
     controllers: ControllerNode[];
     commands: CommandNode[];
+    jobs?: JobNode[];
     queries: QueryNode[];
+    /** Explicit aspects applied to all routes and commands in this module. */
+    aspects?: AspectRefNode[];
     /** Exported token names. */
     exports: string[];
 }
@@ -202,6 +250,21 @@ export interface CompileOptions {
     treeShakeUnusedProviders?: boolean;
     /** Incremental dependency graph cache. */
     cache?: DependencyGraphCache;
+    /**
+     * Changed source paths supplied by the watch/incremental driver.
+     * This is an implementation hint and does not change the public graph shape.
+     */
+    changedPaths?: string[];
+    /** Type-safety gates for generated artifacts and production source. */
+    typeSafety?: TypeSafetyOptions;
+}
+export interface TypeSafetyOptions {
+    /** Reject the `any` keyword in generated TypeScript artifacts. */
+    noAnyInGenerated?: boolean;
+    /** Scan non-test production source for unsafe type escapes and widening. */
+    scanProductionSource?: boolean;
+    /** Additional relative glob patterns excluded from the production-source scan. */
+    exclude?: string[];
 }
 export interface ModuleBoundaryRule {
     /** Source module tag pattern or tag (for example, 'type:ui', 'scope:case', or '*'). */
@@ -300,12 +363,17 @@ export interface DependencyGraphCache {
     modules: Map<string, CachedModuleEntry>;
     /** Global file hashes by relative file path. */
     fileHashes: Map<string, string>;
-    /** Retained AST project for true incremental graph re-analysis. */
-    project?: any;
+    /** Retained native TypeScript BuilderProgram session. */
+    programSession?: IncrementalProgramSession;
     /** Retained module dependency graph tracking imports and reverse dependents. */
-    dependencyGraph?: any;
+    dependencyGraph?: DependencyGraphIndex;
+    /** Content hashes for generated artifacts, used by the incremental emitter. */
+    generatedHashes?: Map<string, string>;
     lastStats?: {
         reusedModules: string[];
         reanalyzedModules: string[];
     };
 }
+export interface DependencyGraphIndex {
+    getAffectedModules(changedFiles: string[]): string[];
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@supacloud/compiler",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "Static compiler for @supacloud/app metadata: builds the application graph from AST, validates it, and generates reflection-free factory code",
   "type": "module",
   "main": "./dist/index.js",
@@ -22,7 +22,7 @@
   ],
   "scripts": {
     "build": "bun run clean && bun run build:js && bun run build:types",
-    "build:js": "bun build src/index.ts src/cli.ts --outdir dist --target node --external ts-morph",
+    "build:js": "bun build src/index.ts src/cli.ts --outdir dist --target node --external @typescript/typescript6",
     "build:types": "tsc -p tsconfig.json --emitDeclarationOnly",
     "clean": "rm -rf dist",
     "prepublishOnly": "bun run build",
@@ -44,7 +44,7 @@
     "directory": "packages/compiler"
   },
   "dependencies": {
-    "ts-morph": "^28.0.0"
+    "@typescript/typescript6": "^6.0.2"
   },
   "devDependencies": {
     "@types/bun": "^1.4.0",