@supacloud/compiler 0.55.1 → 0.57.0

package/dist/command-boundary.d.ts

@@ -0,0 +1,9 @@
+import * as ts from "@supacloud/db/typescript";
+import type { Diagnostic } from "./types";
+interface GovernedClass {
+    declaration: ts.ClassDeclaration;
+    name: string;
+}
+/** A conservative source check for typed command references, not a JavaScript sandbox. */
+export declare function scanCommandBoundaries(source: ts.SourceFile, file: string, checker: ts.TypeChecker, commands: readonly GovernedClass[], boundRoutes: ReadonlyMap<ts.MethodDeclaration, string>): Promise<Diagnostic[]>;
+export {};

package/dist/database-contracts.d.ts

@@ -5,8 +5,8 @@ export interface DatabaseContractsOptions {
     outDir: string;
     /** Official PostgREST snapshot. Omit when the project does not use PostgREST. */
     postgrestTypes?: string;
-    /** Drizzle query-builder module. Omit when the project does not use Drizzle. */
-    drizzleSchema?: string;
+    /** ZenStack query-builder module. Omit when the project does not use ZenStack. */
+    modelSchema?: string;
     /** Explicit identity/role label for reviewing snapshot provenance. Not an authorization proof. */
     role: string;
     /** Role-scoped pg_graphql snapshot exported by graphql-schema. Omit when GraphQL is unused. */

package/dist/delivery-bundle-worker.js

@@ -23,6 +23,43 @@ var __esm = (fn, res, err) => () => {
     throw err[0];
   return res;
 };
+var __dispose = Symbol.dispose || /* @__PURE__ */ Symbol.for("Symbol.dispose");
+var __asyncDispose = Symbol.asyncDispose || /* @__PURE__ */ Symbol.for("Symbol.asyncDispose");
+var __using = (stack, value, async) => {
+  if (value != null) {
+    if (typeof value !== "object" && typeof value !== "function")
+      throw TypeError('Object expected to be assigned to "using" declaration');
+    var dispose;
+    if (async)
+      dispose = value[__asyncDispose];
+    if (dispose === undefined)
+      dispose = value[__dispose];
+    if (typeof dispose !== "function")
+      throw TypeError("Object not disposable");
+    stack.push([async, dispose, value]);
+  } else if (async) {
+    stack.push([async]);
+  }
+  return value;
+};
+var __callDispose = (stack, error, hasError) => {
+  var E = typeof SuppressedError === "function" ? SuppressedError : function(e, s, m, _) {
+    return _ = Error(m), _.name = "SuppressedError", _.error = e, _.suppressed = s, _;
+  }, fail = (e) => error = hasError ? new E(e, error, "An error was suppressed during disposal") : (hasError = true, e), next = (it) => {
+    while (it = stack.pop()) {
+      try {
+        var result = it[1] && it[1].call(it[2]);
+        if (it[0])
+          return Promise.resolve(result).then(next, (e) => (fail(e), next()));
+      } catch (e) {
+        fail(e);
+      }
+    }
+    if (hasError)
+      throw error;
+  };
+  return next();
+};
 
 // node_modules/typebox/build/system/arguments/arguments.mjs
 function Match(args, match) {
@@ -10513,88 +10550,91 @@ init_delivery_files2();
 import { isBuiltin } from "node:module";
 import { readFile as readFile2 } from "node:fs/promises";
 import { join as join2, resolve as resolve3 } from "node:path";
-import * as ts2 from "@typescript/typescript6";
+import * as ts2 from "@supacloud/db/typescript";
 
 // src/delivery-imports.ts
-import * as ts from "@typescript/typescript6";
-function staticDeliveryImports(path, contents) {
-  if (!/\.[cm]?[jt]sx?$/.test(path))
-    return contents;
-  const source = ts.createSourceFile(path, new TextDecoder().decode(contents), ts.ScriptTarget.Latest, true);
-  const computed = [];
-  function scan(node) {
-    if (ts.isCallExpression(node) && (node.expression.kind === ts.SyntaxKind.ImportKeyword || ts.isIdentifier(node.expression) && node.expression.text === "require")) {
-      const argument = node.arguments[0];
-      if (!argument || !ts.isStringLiteral(argument) && !ts.isNoSubstitutionTemplateLiteral(argument))
-        computed.push(node);
-    }
-    ts.forEachChild(node, scan);
-  }
-  scan(source);
-  if (computed.length === 0)
-    return contents;
-  const reject = () => {
-    throw new Error("Computed module loading is not supported in independent delivery bundles.");
-  };
-  if (!ts.isExternalModule(source))
-    return reject();
-  const host = ts.createCompilerHost({ noLib: true, noResolve: true, allowJs: true });
-  host.getSourceFile = (name) => name === path ? source : undefined;
-  const checker = ts.createProgram([path], { noLib: true, noResolve: true, allowJs: true }, host).getTypeChecker();
-  const replacements = new Map;
-  const removed = new Set;
-  for (const call of computed) {
-    let visit = function(node) {
-      const referenced = ts.isIdentifier(node) ? ts.isShorthandPropertyAssignment(node.parent) ? checker.getShorthandAssignmentValueSymbol(node.parent) : ts.isExportSpecifier(node.parent) ? checker.getExportSpecifierLocalTargetSymbol(node.parent) : checker.getSymbolAtLocation(node) : undefined;
-      if (ts.isIdentifier(node) && node !== declarationName && referenced === symbol) {
-        const use = node.parent;
-        if (!ts.isCallExpression(use) || use.expression !== node || use.arguments.length !== 1 || use.questionDotToken || use.typeArguments?.length)
-          return reject();
-        const value = use.arguments[0];
-        if (!value || !ts.isStringLiteral(value) && !ts.isNoSubstitutionTemplateLiteral(value))
-          return reject();
-        references++;
-        replacements.set(use, ts.factory.createCallExpression(call.expression, undefined, [value]));
+import * as ts from "@supacloud/db/typescript";
+async function staticDeliveryImports(path, contents) {
+  let __stack = [];
+  try {
+    if (!/\.[cm]?[jt]sx?$/.test(path))
+      return contents;
+    const syntax = await ts.createSourceFile(path, new TextDecoder().decode(contents));
+    let source = syntax;
+    const computed = [];
+    function scan(node) {
+      if (ts.isCallExpression(node) && (node.expression.kind === ts.SyntaxKind.ImportKeyword || ts.isIdentifier(node.expression) && node.expression.text === "require")) {
+        const argument = node.arguments[0];
+        if (!argument || !ts.isStringLiteral(argument) && !ts.isNoSubstitutionTemplateLiteral(argument))
+          computed.push(node);
       }
-      ts.forEachChild(node, visit);
+      ts.forEachChild(node, scan);
+    }
+    scan(source);
+    if (computed.length === 0)
+      return contents;
+    const reject = () => {
+      throw new Error("Computed module loading is not supported in independent delivery bundles.");
     };
-    const statement = call.parent;
-    const block = statement.parent;
-    const declaration = block.parent;
-    if (call.expression.kind !== ts.SyntaxKind.ImportKeyword || call.arguments.length !== 1 || !ts.isReturnStatement(statement) || !ts.isBlock(block) || block.statements.length !== 1 || !ts.isFunctionDeclaration(declaration) || declaration.parent !== source || !declaration.name || declaration.modifiers?.length || declaration.asteriskToken || declaration.typeParameters?.length || declaration.parameters.length !== 1)
-      return reject();
-    const parameter = declaration.parameters[0];
-    const argument = call.arguments[0];
-    if (!parameter || !ts.isIdentifier(parameter.name) || parameter.initializer || parameter.dotDotDotToken || !argument || !ts.isIdentifier(argument) || checker.getSymbolAtLocation(argument) !== checker.getSymbolAtLocation(parameter.name))
-      return reject();
-    const symbol = checker.getSymbolAtLocation(declaration.name);
-    if (!symbol || symbol.declarations?.length !== 1)
+    if (!ts.isExternalModule(source))
       return reject();
-    const declarationName = declaration.name;
-    let references = 0;
-    visit(source);
-    if (references === 0)
-      return reject();
-    removed.add(declaration);
-  }
-  const transformed = ts.transform(source, [(context) => {
-    const visit = (node) => {
-      if (ts.isFunctionDeclaration(node) && removed.has(node))
-        return;
-      const replacement = ts.isCallExpression(node) ? replacements.get(node) : undefined;
-      if (replacement)
-        return replacement;
-      return ts.visitEachChild(node, visit, context);
-    };
-    return (node) => ts.visitNode(node, visit, ts.isSourceFile) ?? node;
-  }]);
-  try {
-    const transformedSource = transformed.transformed[0];
-    if (!transformedSource)
+    const program = __using(__stack, await ts.createProgram([path], { noLib: true, noResolve: true, allowJs: true }, { sources: new Map([[path, source.text]]) }), 1);
+    const boundSource = program.getSourceFile(path);
+    if (!boundSource)
       return reject();
-    return new TextEncoder().encode(ts.createPrinter().printFile(transformedSource));
+    computed.length = 0;
+    source = boundSource;
+    scan(source);
+    const checker = program.getTypeChecker();
+    const replacements = new Map;
+    const removed = new Set;
+    for (const call of computed) {
+      const statement = call.parent;
+      const block = statement.parent;
+      const declaration = block.parent;
+      if (call.expression.kind !== ts.SyntaxKind.ImportKeyword || call.arguments.length !== 1 || !ts.isReturnStatement(statement) || !ts.isBlock(block) || block.statements.length !== 1 || !ts.isFunctionDeclaration(declaration) || declaration.parent !== source || !declaration.name || declaration.modifiers?.length || declaration.asteriskToken || declaration.typeParameters?.length || declaration.parameters.length !== 1)
+        return reject();
+      const parameter = declaration.parameters[0];
+      const argument = call.arguments[0];
+      if (!parameter || !ts.isIdentifier(parameter.name) || parameter.initializer || parameter.dotDotDotToken || !argument || !ts.isIdentifier(argument) || await checker.getSymbolAtLocation(argument) !== await checker.getSymbolAtLocation(parameter.name))
+        return reject();
+      const symbol = await checker.getSymbolAtLocation(declaration.name);
+      if (!symbol || symbol.declarations?.length !== 1)
+        return reject();
+      const declarationName = declaration.name;
+      let references = 0;
+      async function visit(node) {
+        const referenced = ts.isIdentifier(node) ? ts.isShorthandPropertyAssignment(node.parent) ? await checker.getShorthandAssignmentValueSymbol(node.parent) : ts.isExportSpecifier(node.parent) ? await checker.getExportSpecifierLocalTargetSymbol(node.parent) : await checker.getSymbolAtLocation(node) : undefined;
+        if (ts.isIdentifier(node) && node !== declarationName && referenced === symbol) {
+          const use = node.parent;
+          if (!ts.isCallExpression(use) || use.expression !== node || use.arguments.length !== 1 || use.questionDotToken || use.typeArguments?.length)
+            return reject();
+          const value = use.arguments[0];
+          if (!value || !ts.isStringLiteral(value) && !ts.isNoSubstitutionTemplateLiteral(value))
+            return reject();
+          references++;
+          replacements.set(use, `import(${value.getText(source)})`);
+        }
+        await ts.forEachChildAsync(node, visit);
+      }
+      await visit(source);
+      if (references === 0)
+        return reject();
+      removed.add(declaration);
+    }
+    const edits = [
+      ...[...removed].map((node) => ({ start: node.getStart(source), end: node.end, text: "" })),
+      ...[...replacements].map(([node, text]) => ({ start: node.getStart(source), end: node.end, text }))
+    ].sort((a, b) => b.start - a.start);
+    let output = source.text;
+    for (const edit of edits)
+      output = output.slice(0, edit.start) + edit.text + output.slice(edit.end);
+    return new TextEncoder().encode(output);
+  } catch (_catch) {
+    var _err = _catch, _hasErr = 1;
   } finally {
-    transformed.dispose();
+    var _promise = __callDispose(__stack, _err, _hasErr);
+    _promise && await _promise;
   }
 }
 
@@ -10718,7 +10758,7 @@ async function bundleDeliveryTargetInProcess(name, code, project, generatedDirec
             return { contents: code, loader: "ts" };
           const bytes = await readFile2(args.path);
           inputs.set(resolve3(args.path), digest(bytes));
-          return { contents: staticDeliveryImports(args.path, bytes), loader: args.loader };
+          return { contents: await staticDeliveryImports(args.path, bytes), loader: args.loader };
         });
       }
     }]
@@ -10746,7 +10786,7 @@ async function bundleDeliveryTargetInProcess(name, code, project, generatedDirec
     if (/\.[cm]?js$/.test(path)) {
       let check = function(node) {
         const specifier = ts2.isImportDeclaration(node) || ts2.isExportDeclaration(node) ? node.moduleSpecifier : ts2.isCallExpression(node) && (node.expression.kind === ts2.SyntaxKind.ImportKeyword || ts2.isIdentifier(node.expression) && /^(?:__)?require$/.test(node.expression.text) || ts2.isPropertyAccessExpression(node.expression) && node.expression.name.text === "require" && ts2.isMetaProperty(node.expression.expression) && node.expression.expression.keywordToken === ts2.SyntaxKind.ImportKeyword) ? node.arguments[0] : undefined;
-        if (specifier && ts2.isStringLiteralLike(specifier)) {
+        if (specifier && ts2.isStringLiteralLikeNode(specifier)) {
           if (!isBuiltin(specifier.text) && specifier.text !== "bun" && !specifier.text.startsWith("bun:")) {
             throw new Error("Independent bundles cannot retain external package imports.");
           }
@@ -10754,7 +10794,7 @@ async function bundleDeliveryTargetInProcess(name, code, project, generatedDirec
         }
         ts2.forEachChild(node, check);
       };
-      const source = ts2.createSourceFile(path, new TextDecoder().decode(bytes), ts2.ScriptTarget.Latest, true);
+      const source = await ts2.createSourceFile(path, new TextDecoder().decode(bytes), ts2.ScriptTarget.Latest, true);
       check(source);
     }
     files.set(`bundle/${path}`, bytes);

package/dist/delivery-imports.d.ts

@@ -1,2 +1,2 @@
 /** Resolve private literal-only import wrappers without permitting an open dependency set. */
-export declare function staticDeliveryImports(path: string, contents: Uint8Array): Uint8Array;
+export declare function staticDeliveryImports(path: string, contents: Uint8Array): Promise<Uint8Array>;

package/dist/delivery-render.d.ts

@@ -5,6 +5,7 @@ import { type GenerateOptions } from "./generate";
 export declare function renderDeliveryTarget(graph: ApplicationGraph, target: DeliveryTarget, options: GenerateOptions): {
     applicationCode: string;
     manifestJson: string;
+    executionPlan: import("./types").CompiledExecutionManifest;
     contractsManifestJson: string;
     clientCode?: string;
     openApiCode?: string;

package/dist/di-resolution.d.ts

@@ -0,0 +1,39 @@
+import type { ApplicationGraph, ControllerNode, Diagnostic, ModuleNode, ProviderNode, Scope } from "./types";
+export interface DependencyFlags {
+    self?: boolean;
+    skipSelf?: boolean;
+}
+export interface StaticProvider {
+    module: ModuleNode;
+    provider: ProviderNode;
+}
+export type DependencyResolution = {
+    kind: "provider";
+    relation: "local" | "imported" | "root";
+    target: StaticProvider;
+} | {
+    kind: "context";
+    scope: "request" | "job";
+} | {
+    kind: "external";
+} | {
+    kind: "missing";
+} | {
+    kind: "ambiguous";
+    candidates: StaticProvider[];
+};
+export declare function dependencyFlags(owner: Pick<ProviderNode | ControllerNode, "dependencyOptions" | "optionalDeps" | "selfDeps" | "skipSelfDeps" | "hostDeps">, token: string, index?: number): {
+    optional: boolean;
+    self: boolean;
+    skipSelf: boolean;
+    host: boolean;
+};
+/** Follow only explicit public exports; a diamond preserves the original instance. */
+export declare function exportedProviders(graph: ApplicationGraph, module: ModuleNode, token: string, seen?: Set<string>): StaticProvider[];
+/** One compile-time resolution rule for validation, generated factories and manifests. */
+export declare function resolveDependency(graph: ApplicationGraph, module: ModuleNode, token: string, scope?: Scope, flags?: DependencyFlags): DependencyResolution;
+/** Includes implicit root dependencies required before a module factory can run. */
+export declare function moduleDependencies(graph: ApplicationGraph, module: ModuleNode): string[];
+export declare function scopeCanDependOn(owner: Scope, dependency: Scope): boolean;
+/** Invalid static wiring never becomes an executable artifact, including writeOnError. */
+export declare function blocksStaticCompilation(diagnostic: Diagnostic): boolean;

package/dist/diagnostics.js

@@ -23,6 +23,43 @@ var __esm = (fn, res, err) => () => {
     throw err[0];
   return res;
 };
+var __dispose = Symbol.dispose || /* @__PURE__ */ Symbol.for("Symbol.dispose");
+var __asyncDispose = Symbol.asyncDispose || /* @__PURE__ */ Symbol.for("Symbol.asyncDispose");
+var __using = (stack, value, async) => {
+  if (value != null) {
+    if (typeof value !== "object" && typeof value !== "function")
+      throw TypeError('Object expected to be assigned to "using" declaration');
+    var dispose;
+    if (async)
+      dispose = value[__asyncDispose];
+    if (dispose === undefined)
+      dispose = value[__dispose];
+    if (typeof dispose !== "function")
+      throw TypeError("Object not disposable");
+    stack.push([async, dispose, value]);
+  } else if (async) {
+    stack.push([async]);
+  }
+  return value;
+};
+var __callDispose = (stack, error, hasError) => {
+  var E = typeof SuppressedError === "function" ? SuppressedError : function(e, s, m, _) {
+    return _ = Error(m), _.name = "SuppressedError", _.error = e, _.suppressed = s, _;
+  }, fail = (e) => error = hasError ? new E(e, error, "An error was suppressed during disposal") : (hasError = true, e), next = (it) => {
+    while (it = stack.pop()) {
+      try {
+        var result = it[1] && it[1].call(it[2]);
+        if (it[0])
+          return Promise.resolve(result).then(next, (e) => (fail(e), next()));
+      } catch (e) {
+        fail(e);
+      }
+    }
+    if (hasError)
+      throw error;
+  };
+  return next();
+};
 
 // src/repair-plan.ts
 function createDiagnosticRepairPlan(diagnostics) {
@@ -71,7 +108,7 @@ function classifyFix(fix) {
 import { createHash, randomUUID } from "node:crypto";
 import { lstat, readFile, realpath, rename, unlink, writeFile } from "node:fs/promises";
 import { dirname, isAbsolute, relative, resolve, sep } from "node:path";
-import * as ts from "@typescript/typescript6";
+import * as ts from "@supacloud/db/typescript";
 async function applyDiagnosticFix(fix, options = {}) {
   if (!fix || typeof fix.targetFile !== "string")
     throw new Error("Invalid DiagnosticFix");
@@ -88,7 +125,8 @@ async function applyDiagnosticFix(fix, options = {}) {
   if (options.expectedSourceHash !== undefined && options.expectedSourceHash !== sourceHash) {
     throw new Error("Fix source changed since preview; analyze the project again");
   }
-  let source = parse(file, original);
+  const originalSource = await parse(file, original);
+  let source = originalSource;
   let content;
   switch (fix.type) {
     case "set_command_mode": {
@@ -100,15 +138,16 @@ async function applyDiagnosticFix(fix, options = {}) {
       if (!current || current.initializer.getText(source) !== fix.expectedExpression) {
         throw new Error("Command mode changed since diagnosis; analyze the project again");
       }
-      content = replaceProperty(source, object, fix.property, ts.factory.createStringLiteral(fix.value));
+      content = await replaceProperty(source, object, fix.property, ts.factory.createStringLiteral(fix.value, ts.TokenFlags.None));
       break;
     }
     case "add_module_import": {
       if (!fix.importPath || !fix.symbol)
         throw new Error("Module fix requires importPath and symbol");
       identifier(fix.symbol);
-      const withImport = importSymbol(source, fix.importPath, fix.symbol);
-      source = parse(file, withImport);
+      const withImport = await importSymbol(source, fix.importPath, fix.symbol);
+      const importedSource = await parse(file, withImport);
+      source = importedSource;
       const object = unique(moduleObjects(source).filter((candidate) => !fix.targetModule || stringProperty(candidate, "name") === fix.targetModule), "target module");
       const imports = property(object, "imports");
       if (imports && !ts.isArrayLiteralExpression(imports.initializer)) {
@@ -117,7 +156,7 @@ async function applyDiagnosticFix(fix, options = {}) {
       const values = imports && ts.isArrayLiteralExpression(imports.initializer) ? imports.initializer.elements : [];
       if (values.some(ts.isSpreadElement))
         throw new Error("Module imports cannot contain spread elements");
-      content = values.some((value) => ts.isIdentifier(value) && value.text === fix.symbol) ? withImport : replaceProperty(source, object, "imports", ts.factory.createArrayLiteralExpression([
+      content = values.some((value) => ts.isIdentifier(value) && value.text === fix.symbol) ? withImport : await replaceProperty(source, object, "imports", ts.factory.createArrayLiteralExpression([
         ...values,
         ts.factory.createIdentifier(fix.symbol)
       ]));
@@ -134,7 +173,7 @@ async function applyDiagnosticFix(fix, options = {}) {
       if (current && (!ts.isStringLiteral(current.initializer) || current.initializer.text !== permission)) {
         throw new Error("Command permission already exists with a different value");
       }
-      content = current ? original : replaceProperty(source, object, "permission", ts.factory.createStringLiteral(permission));
+      content = current ? original : await replaceProperty(source, object, "permission", ts.factory.createStringLiteral(permission, ts.TokenFlags.None));
       break;
     }
     case "add_route_parameter_binding": {
@@ -152,13 +191,14 @@ async function applyDiagnosticFix(fix, options = {}) {
         throw new Error("Framework import must be static");
       }
       const edited = original.slice(0, parameter.getStart(source)) + `@${binding}(${JSON.stringify(fix.parameter)}) ` + original.slice(parameter.getStart(source));
-      content = importSymbol(parse(file, edited), framework.moduleSpecifier.text, binding);
+      const editedSource = await parse(file, edited);
+      content = await importSymbol(editedSource, framework.moduleSpecifier.text, binding);
       break;
     }
     default:
       throw new Error(`Diagnostic fix '${fix.type}' requires a manual semantic decision; no files changed`);
   }
-  parse(file, content);
+  await parse(file, content);
   const result = { file, changed: content !== original, content, sourceHash };
   if (options.dryRun === false && result.changed) {
     const temporary = `${file}.supacloud-fix-${randomUUID()}`;
@@ -173,8 +213,8 @@ async function applyDiagnosticFix(fix, options = {}) {
   }
   return result;
 }
-function parse(file, text) {
-  const result = ts.transpileModule(text, {
+async function parse(file, text) {
+  const result = await ts.transpileModule(text, {
     fileName: file,
     reportDiagnostics: true,
     compilerOptions: { target: ts.ScriptTarget.ESNext, experimentalDecorators: true }
@@ -182,7 +222,7 @@ function parse(file, text) {
   if (result.diagnostics?.some((item) => item.category === ts.DiagnosticCategory.Error)) {
     throw new Error("Cannot fix syntactically invalid TypeScript");
   }
-  return ts.createSourceFile(file, text, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+  return await ts.createSourceFile(file, text, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
 }
 function unique(items, description) {
   const [item] = items;
@@ -213,14 +253,14 @@ function stringProperty(object, key) {
   const value = property(object, key)?.initializer;
   return value && ts.isStringLiteral(value) ? value.text : undefined;
 }
-function replaceProperty(source, object, key, value) {
+async function replaceProperty(source, object, key, value) {
   const previous = property(object, key);
-  const replacement = ts.factory.createPropertyAssignment(key, value);
-  const properties = object.properties.map((item) => item === previous ? replacement : item);
-  if (!previous)
-    properties.push(replacement);
-  const updated = ts.factory.updateObjectLiteralExpression(object, properties);
-  return source.text.slice(0, object.getStart(source)) + ts.createPrinter().printNode(ts.EmitHint.Expression, updated, source) + source.text.slice(object.end);
+  const text = await ts.printNode(value);
+  if (previous)
+    return source.text.slice(0, previous.initializer.getStart(source)) + text + source.text.slice(previous.initializer.end);
+  const position = object.end - 1;
+  const separator = object.properties.length && !object.properties.hasTrailingComma ? "," : "";
+  return source.text.slice(0, position) + `${separator} ${key}: ${text}` + source.text.slice(position);
 }
 function findClass(source, name) {
   return unique(source.statements.filter((statement) => ts.isClassDeclaration(statement) && statement.name?.text === name), `class '${name}'`);
@@ -249,7 +289,7 @@ function moduleObjects(source) {
   }
   return result;
 }
-function importSymbol(source, path, symbol) {
+async function importSymbol(source, path, symbol) {
   identifier(symbol);
   const current = resolve(source.fileName).replace(/\.(tsx?|mts|cts)$/, "");
   const target = resolve(dirname(source.fileName), path).replace(/\.(tsx?|mts|cts)$/, "");
@@ -259,7 +299,7 @@ function importSymbol(source, path, symbol) {
   if (matches.length > 1)
     throw new Error(`Ambiguous imports from '${path}'`);
   const match = matches[0];
-  if (match && ts.isImportDeclaration(match) && match.importClause?.namedBindings && ts.isNamedImports(match.importClause.namedBindings) && !match.importClause.isTypeOnly) {
+  if (match && ts.isImportDeclaration(match) && match.importClause?.namedBindings && ts.isNamedImports(match.importClause.namedBindings) && match.importClause.phaseModifier !== ts.SyntaxKind.TypeKeyword) {
     if (match.importClause.namedBindings.elements.some((item) => item.name.text === symbol))
       return source.text;
     const bindings = match.importClause.namedBindings;
@@ -267,7 +307,7 @@ function importSymbol(source, path, symbol) {
       ...bindings.elements,
       ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier(symbol))
     ]);
-    return source.text.slice(0, bindings.getStart(source)) + ts.createPrinter().printNode(ts.EmitHint.Unspecified, updated, source) + source.text.slice(bindings.end);
+    return source.text.slice(0, bindings.getStart(source)) + await ts.printNode(updated) + source.text.slice(bindings.end);
   }
   if (match)
     throw new Error(`Import from '${path}' is not a named value import`);

package/dist/execution-manifest.d.ts

@@ -0,0 +1,8 @@
+import type { CommandExecutionCapabilities, CompiledExecutionManifest, Diagnostic } from "./types";
+/** Internal delivery error; the public validator returns structured diagnostics. */
+export declare class ExecutionManifestValidationError extends Error {
+    readonly diagnostics: Diagnostic[];
+    constructor(diagnostics: Diagnostic[]);
+}
+/** Validate a compiler-produced plan against deployment declarations, never runtime attestations. */
+export declare function validateExecutionManifest(plan: CompiledExecutionManifest, capabilities?: CommandExecutionCapabilities): Diagnostic[];

package/dist/generate.d.ts

@@ -1,5 +1,5 @@
-import type { ApplicationGraph, OpenApiOptions } from "./types";
-export interface GenerateOptions {
+import type { ApplicationGraph, CompiledExecutionManifest, OpenApiOptions, ValidateOptions } from "./types";
+export interface GenerateOptions extends Pick<ValidateOptions, "moduleBoundaryPreset" | "moduleBoundaries" | "commandCapabilities"> {
     rootDir: string;
     outDir: string;
     generateClient?: boolean;
@@ -14,6 +14,7 @@ export interface GenerateOptions {
 export interface RenderedArtifacts {
     applicationCode: string;
     manifestJson: string;
+    executionPlan: CompiledExecutionManifest;
     contractsManifestJson: string;
     clientCode?: string;
     openApiCode?: string;

package/dist/graphql-runtime.d.ts

@@ -3,4 +3,4 @@
  * selections, fragments and conditional fields. Unsupported wire types fail closed.
  */
 export type GraphqlOperationKind = "query" | "mutation";
-export declare function renderGraphqlValidators(source: string, operationNames: readonly string[], operationKinds?: ReadonlyMap<string, GraphqlOperationKind>): string;
+export declare function renderGraphqlValidators(source: string, operationNames: readonly string[], operationKinds?: ReadonlyMap<string, GraphqlOperationKind>): Promise<string>;

package/dist/http-provider-migration.d.ts

@@ -1,6 +1,6 @@
-import * as ts from "@typescript/typescript6";
+import * as ts from "@supacloud/db/typescript";
 import type { SourceMigrationResult } from "./migrations";
 import type { Diagnostic } from "./types";
 /** Never replaces the root array helper in constructor/custom pipeline usages. */
-export declare function migrateHttpProviderImports(source: string, fileName: string): SourceMigrationResult;
-export declare function scanHttpProviderImports(source: ts.SourceFile, file: string): Diagnostic[];
+export declare function migrateHttpProviderImports(source: string, fileName: string): Promise<SourceMigrationResult>;
+export declare function scanHttpProviderImports(source: ts.SourceFile, file: string): Promise<Diagnostic[]>;

package/dist/incremental.d.ts

@@ -4,7 +4,7 @@ export interface IncrementalCompileResult extends CompileResult {
 }
 export interface IncrementalCompiler {
     compile(options: CompileOptions, changedPaths?: string[]): Promise<IncrementalCompileResult>;
-    reset(): void;
+    reset(): Promise<void>;
     getCache?(): DependencyGraphCache;
 }
 export declare function createDependencyGraphCache(): DependencyGraphCache;

package/dist/index.d.ts

@@ -38,6 +38,7 @@ export { TraitCompiler } from "./traits";
 export type { TraitCompilation, TraitHandler, TraitKind, TraitRecord } from "./traits";
 export { generateApplication, renderApplication, renderClient, renderOpenApi } from "./generate";
 export type { GenerateOptions, RenderedArtifacts } from "./generate";
+export { validateExecutionManifest } from "./execution-manifest";
 export { buildContractManifest } from "./contract-manifest";
 export type { ContractManifest } from "./contract-manifest";
 export { diffOpenApiDocuments, exportGeneratedOpenApiJson, formatOpenApiDiff, loadGeneratedOpenApiDocument, parseOpenApiDocument, readOpenApiJson, serializeOpenApiJson, writeOpenApiJson, OpenApiDocumentError, } from "./openapi-tools";
@@ -47,12 +48,12 @@ export type { MigrateFileResult, MigrateProjectOptions, MigrateProjectResult, So
 export { validateGraph, COMPILER_DIAGNOSTIC_CODES } from "./validate";
 export { scanGeneratedArtifacts, scanProductionSource, TYPE_SAFETY_DIAGNOSTIC_CODES } from "./type-safety";
 export type { TypeSafetyScanOptions } from "./type-safety";
-export { scanDrizzleSql, SQL_SAFETY_DIAGNOSTIC_CODES } from "./sql-safety";
+export { scanQuerySql, SQL_SAFETY_DIAGNOSTIC_CODES } from "./sql-safety";
 export { DEFAULT_SUPACLOUD_CONFIG, compileOptionsFromConfig, defineSupacloudConfig, loadSupacloudConfig, resolveSupacloudConfig, } from "./config";
 export type { SupaCloudConfig } from "./config";
 export { camelName } from "./util";
 export { ANGULAR_ENTERPRISE_RULES, CLEAN_ARCHITECTURE_RULES, MODULAR_MONOLITH_RULES, MODULE_BOUNDARY_PROFILES, getModuleBoundaryPreset, getModuleBoundaryProfile, resolveModuleBoundaries, } from "./profiles";
-export type { ApplicationGraph, AspectRefNode, CachedModuleEntry, CheckProjectResult, CommandExecutionCapabilities, CommandNode, CompileOptions, DatabaseGovernanceOptions, CompileResult, CompileStats, ControllerNode, DependencyGraphCache, DependencyGraphIndex, Diagnostic, DiagnosticFix, EffectCompilerOptions, EffectErrorMappingNode, EffectRetryPolicy, EffectRouteNode, ModuleBoundaryPresetName, ModuleBoundaryProfile, ModuleBoundaryRule, ModuleNode, JobNode, ProviderKind, ProviderNode, QueryNode, RouteNode, Scope, TokenKind, TypeSafetyOptions, ValidateOptions, WatchEvent, WatchHandle, WatchOptions, FeatureSpecNode, FeatureTransitionNode, FeatureDatabaseSourceNode, FeaturePersistenceNode, GraphqlOptions, GraphqlContractSummary, OpenApiOptions, OpenApiSecurityScheme, OpenApiServer, } from "./types";
+export type { ApplicationGraph, AspectRefNode, CachedModuleEntry, CheckProjectResult, CommandExecutionCapabilities, CommandNode, CompileOptions, DatabaseGovernanceOptions, CompileResult, CompileStats, CompiledExecutionManifest, ExecutionPlanCommand, ExecutionPlanJob, ExecutionPlanModule, ExecutionPlanProvider, ExecutionPlanProviderEdge, ExecutionPlanRoute, ControllerNode, DependencyGraphCache, DependencyOptions, DependencyGraphIndex, Diagnostic, DiagnosticFix, EffectCompilerOptions, EffectErrorMappingNode, EffectRetryPolicy, EffectRouteNode, ModuleBoundaryPresetName, ModuleBoundaryProfile, ModuleBoundaryRule, ModuleNode, JobNode, ProviderKind, ProviderNode, QueryNode, RouteNode, Scope, TokenKind, TypeSafetyOptions, ValidateOptions, WatchEvent, WatchHandle, WatchOptions, FeatureSpecNode, FeatureTransitionNode, FeatureDatabaseSourceNode, FeaturePersistenceNode, GraphqlOptions, GraphqlContractSummary, OpenApiOptions, OpenApiSecurityScheme, OpenApiServer, } from "./types";
 export { inspectRouteContracts, validateRouteContracts } from "./route-contracts";
 export { validateEffectPolicies, validateJobPolicies } from "./effect-governance";
 export { pullGraphqlSchema } from "./graphql-schema";