@supacloud/compiler 0.28.0 → 0.30.0

package/dist/cli.js

@@ -1663,6 +1663,12 @@ class ModuleGenerator {
   }
   renderFactories() {
     const sections = [this.renderServicesFactory()];
+    if (this.hasApplicationLifecycle("init")) {
+      sections.push(this.renderApplicationLifecycle("init"));
+    }
+    if (this.hasApplicationLifecycle("destroy")) {
+      sections.push(this.renderApplicationLifecycle("destroy"));
+    }
     if (this.hasFactoryContent("request")) {
       sections.push(this.renderScopeFactory("request"));
       sections.push(this.renderScopeDestroyer("request"));
@@ -1679,6 +1685,12 @@ class ModuleGenerator {
       `  name: ${JSON.stringify(this.module.name)} as const,`,
       `  createServices: create${this.pascal}Services,`
     ];
+    if (this.hasApplicationLifecycle("init")) {
+      lines.push(`  initializeServices: initialize${this.pascal}Services,`);
+    }
+    if (this.hasApplicationLifecycle("destroy")) {
+      lines.push(`  destroyServices: destroy${this.pascal}Services,`);
+    }
     if (this.hasFactoryContent("request")) {
       lines.push(`  createRequestScope: create${this.pascal}RequestScope,`);
       lines.push(`  destroyRequestScope: destroy${this.pascal}RequestScope,`);
@@ -1701,6 +1713,40 @@ class ModuleGenerator {
   hasFactoryContent(kind) {
     return this.module.providers.some((p) => factoryOfScope(p.scope) === kind) || this.module.controllers.some((c) => factoryOfScope(c.scope) === kind);
   }
+  hasApplicationLifecycle(kind) {
+    return this.applicationLifecyclePlan(kind).length > 0;
+  }
+  applicationLifecyclePlan(kind) {
+    const result = [];
+    const multiIndices = new Map;
+    for (const provider of orderProviders(this.module.providers.filter((p) => factoryOfScope(p.scope) === "services"))) {
+      const index = provider.multi ? multiIndices.get(provider.token) ?? 0 : undefined;
+      if (index !== undefined)
+        multiIndices.set(provider.token, index + 1);
+      const owned = provider.kind !== "existing";
+      const selected = kind === "init" ? provider.hasOnInit : provider.hasOnDestroy;
+      if (owned && selected)
+        result.push({ key: camelName(provider.token), ...index === undefined ? {} : { index } });
+    }
+    for (const controller of this.module.controllers) {
+      if (factoryOfScope(controller.scope) !== "services")
+        continue;
+      const selected = kind === "init" ? controller.hasOnInit : controller.hasOnDestroy;
+      if (selected)
+        result.push({ key: camelName(controller.className) });
+    }
+    return result;
+  }
+  renderApplicationLifecycle(kind) {
+    const suffix = kind === "init" ? "initialize" : "destroy";
+    const helper = kind === "init" ? "initializeServiceInstances" : "destroyServiceInstances";
+    return [
+      `async function ${suffix}${this.pascal}Services(services: Record<string, unknown>): Promise<void> {`,
+      `  await ${helper}(services, ${JSON.stringify(this.applicationLifecyclePlan(kind))});`,
+      `}`
+    ].join(`
+`);
+  }
   renderControllers() {
     if (this.module.controllers.length === 0)
       return "[]";
@@ -3419,6 +3465,10 @@ export interface CompiledModule {
     deps: Record<string, unknown>,
     imported: Record<string, Record<string, unknown>>,
   ): Record<string, unknown>;
+  /** Initializes application-scoped instances owned by this module. */
+  initializeServices?(services: Record<string, unknown>): Promise<void>;
+  /** Destroys application-scoped instances owned by this module. */
+  destroyServices?(services: Record<string, unknown>): Promise<void>;
   createRequestScope?(
     services: Record<string, unknown>,
     ctx: unknown,
@@ -3502,7 +3552,54 @@ function destroyScopeInstances(
   });
   scopeDestructions.set(scope, destruction);
   return destruction;
-}`;
+}
+
+type CompiledServiceLifecycleEntry = { key: string; index?: number };
+
+async function initializeServiceInstances(
+  services: Record<string, unknown>,
+  plan: readonly CompiledServiceLifecycleEntry[],
+): Promise<void> {
+  const seen = new Set<unknown>();
+  for (const entry of plan) {
+    const value = services[entry.key];
+    const instance = entry.index === undefined
+      ? value
+      : Array.isArray(value) ? value[entry.index] : undefined;
+    if (seen.has(instance)) continue;
+    seen.add(instance);
+    if (!isRecord(instance) || !isFunction(instance.onInit)) continue;
+    await instance.onInit();
+  }
+}
+
+async function destroyServiceInstances(
+  services: Record<string, unknown>,
+  plan: readonly CompiledServiceLifecycleEntry[],
+): Promise<void> {
+  const errors: unknown[] = [];
+  const seen = new Set<unknown>();
+  for (const entry of [...plan].reverse()) {
+    const value = services[entry.key];
+    const instance = entry.index === undefined
+      ? value
+      : Array.isArray(value) ? value[entry.index] : undefined;
+    if (seen.has(instance)) continue;
+    seen.add(instance);
+    if (!isRecord(instance)) continue;
+    const hook = isFunction(instance.onDestroy)
+      ? instance.onDestroy
+      : isFunction(instance.ngOnDestroy) ? instance.ngOnDestroy : undefined;
+    if (!hook) continue;
+    try {
+      await hook.call(instance);
+    } catch (error) {
+      errors.push(error);
+    }
+  }
+  if (errors.length > 0) throw new AggregateError(errors, "Application service destruction failed");
+}
+`;
 var init_generate = __esm(() => {
   init_contract_manifest();
 });
@@ -3724,8 +3821,8 @@ var init_graphql_options = __esm(() => {
 });
 
 // src/graphql-inputs.ts
-import { resolve as resolve3 } from "node:path";
-import * as ts7 from "@typescript/typescript6";
+import { resolve as resolve4 } from "node:path";
+import * as ts10 from "@typescript/typescript6";
 function graphqlInputPaths(options) {
   if (!options.graphql)
     return [];
@@ -3734,9 +3831,9 @@ function graphqlInputPaths(options) {
   } catch {
     return [];
   }
-  const root = resolve3(options.rootDir);
-  const schema = resolve3(root, options.graphql.schema);
-  const documents = ts7.sys.readDirectory(root, [".graphql", ".gql"], ["**/node_modules/**", "**/.git/**", resolve3(options.outDir)], options.graphql.documents ?? ["**/*.graphql", "**/*.gql"]).map((path) => resolve3(path)).filter((path) => path !== schema);
+  const root = resolve4(options.rootDir);
+  const schema = resolve4(root, options.graphql.schema);
+  const documents = ts10.sys.readDirectory(root, [".graphql", ".gql"], ["**/node_modules/**", "**/.git/**", resolve4(options.outDir)], options.graphql.documents ?? ["**/*.graphql", "**/*.gql"]).map((path) => resolve4(path)).filter((path) => path !== schema);
   return [schema, ...[...new Set(documents)].sort()];
 }
 var init_graphql_inputs = __esm(() => {
@@ -3744,10 +3841,10 @@ var init_graphql_inputs = __esm(() => {
 });
 
 // src/graphql-runtime.ts
-import * as ts8 from "@typescript/typescript6";
-import { resolve as resolve4 } from "node:path";
+import * as ts11 from "@typescript/typescript6";
+import { resolve as resolve5 } from "node:path";
 function renderGraphqlValidators(source, operationNames) {
-  const fileName = resolve4("/__supacloud_graphql__/contracts.ts");
+  const fileName = resolve5("/__supacloud_graphql__/contracts.ts");
   const options = {
     strict: true,
     noUncheckedIndexedAccess: true,
@@ -3756,18 +3853,18 @@ function renderGraphqlValidators(source, operationNames) {
     noPropertyAccessFromIndexSignature: true,
     noFallthroughCasesInSwitch: true,
     skipLibCheck: false,
-    target: ts8.ScriptTarget.ES2022,
+    target: ts11.ScriptTarget.ES2022,
     lib: ["lib.es2022.d.ts"],
     types: [],
     noEmit: true
   };
-  const host = ts8.createCompilerHost(options);
+  const host = ts11.createCompilerHost(options);
   const getSourceFile = host.getSourceFile.bind(host);
-  host.getSourceFile = (path, languageVersion, onError, shouldCreateNewSourceFile) => resolve4(path) === fileName ? ts8.createSourceFile(path, source, languageVersion, true) : getSourceFile(path, languageVersion, onError, shouldCreateNewSourceFile);
-  const program = ts8.createProgram([fileName], options, host);
-  const diagnostics = ts8.getPreEmitDiagnostics(program);
+  host.getSourceFile = (path, languageVersion, onError, shouldCreateNewSourceFile) => resolve5(path) === fileName ? ts11.createSourceFile(path, source, languageVersion, true) : getSourceFile(path, languageVersion, onError, shouldCreateNewSourceFile);
+  const program = ts11.createProgram([fileName], options, host);
+  const diagnostics = ts11.getPreEmitDiagnostics(program);
   if (diagnostics.length) {
-    throw new Error(`Generated GraphQL types cannot be validated: ${diagnostics.map((item) => ts8.flattenDiagnosticMessageText(item.messageText, `
+    throw new Error(`Generated GraphQL types cannot be validated: ${diagnostics.map((item) => ts11.flattenDiagnosticMessageText(item.messageText, `
 `)).join("; ")}`);
   }
   const checker = program.getTypeChecker();
@@ -3797,25 +3894,25 @@ function renderGraphqlValidators(source, operationNames) {
     return name;
   }
   function expression(type) {
-    if (type.flags & ts8.TypeFlags.Any)
+    if (type.flags & ts11.TypeFlags.Any)
       return unsupported(type);
-    if (type.flags & ts8.TypeFlags.Unknown)
+    if (type.flags & ts11.TypeFlags.Unknown)
       return "true";
-    if (type.flags & ts8.TypeFlags.Never)
+    if (type.flags & ts11.TypeFlags.Never)
       return "false";
-    if (type.flags & ts8.TypeFlags.Null)
+    if (type.flags & ts11.TypeFlags.Null)
       return "value === null";
-    if (type.flags & ts8.TypeFlags.Undefined)
+    if (type.flags & ts11.TypeFlags.Undefined)
       return "value === undefined";
     if (type.isStringLiteral() || type.isNumberLiteral())
       return `value === ${JSON.stringify(type.value)}`;
-    if (type.flags & ts8.TypeFlags.BooleanLiteral)
+    if (type.flags & ts11.TypeFlags.BooleanLiteral)
       return `value === ${checker.typeToString(type)}`;
-    if (type.flags & ts8.TypeFlags.String)
+    if (type.flags & ts11.TypeFlags.String)
       return 'typeof value === "string"';
-    if (type.flags & ts8.TypeFlags.Number)
+    if (type.flags & ts11.TypeFlags.Number)
       return 'typeof value === "number" && Number.isFinite(value)';
-    if (type.flags & ts8.TypeFlags.Boolean)
+    if (type.flags & ts11.TypeFlags.Boolean)
       return 'typeof value === "boolean"';
     if (type.isUnion())
       return type.types.map((part) => `${reference(part)}(value)`).join(" || ");
@@ -3824,16 +3921,16 @@ function renderGraphqlValidators(source, operationNames) {
     if (checker.isTupleType(type))
       return unsupported(type);
     if (checker.isArrayType(type)) {
-      const item = checker.getIndexTypeOfType(type, ts8.IndexKind.Number);
+      const item = checker.getIndexTypeOfType(type, ts11.IndexKind.Number);
       if (!item)
         return unsupported(type);
       return `isGraphqlArray(value) && Array.from(value).every(${reference(item)})`;
     }
-    if (type.flags & ts8.TypeFlags.Object) {
+    if (type.flags & ts11.TypeFlags.Object) {
       if (type.getCallSignatures().length || type.getConstructSignatures().length)
         return unsupported(type);
       const indexes = checker.getIndexInfosOfType(type);
-      if (indexes.some((index) => !(index.keyType.flags & ts8.TypeFlags.String)))
+      if (indexes.some((index) => !(index.keyType.flags & ts11.TypeFlags.String)))
         return unsupported(type);
       const properties = checker.getPropertiesOfType(type).map((property) => {
         const declaration = property.valueDeclaration ?? property.declarations?.[0];
@@ -3842,7 +3939,7 @@ function renderGraphqlValidators(source, operationNames) {
         const check = reference(checker.getTypeOfSymbolAtLocation(property, declaration));
         const key = JSON.stringify(property.name);
         const present = `Object.prototype.hasOwnProperty.call(value, ${key})`;
-        return property.flags & ts8.SymbolFlags.Optional ? `(!${present} || ${check}(value[${key}]))` : `(${present} && ${check}(value[${key}]))`;
+        return property.flags & ts11.SymbolFlags.Optional ? `(!${present} || ${check}(value[${key}]))` : `(${present} && ${check}(value[${key}]))`;
       });
       const indexedValues = indexes.map((index) => `Object.values(value).every(${reference(index.type)})`);
       return ["isGraphqlRecord(value)", ...properties, ...indexedValues].join(" && ");
@@ -4212,6 +4309,12 @@ function createContextPack(graph, subject) {
     routeContracts: inspectRouteContracts({ ...graph, modules }),
     ...graphql ? { graphql } : {},
     diagnostics: (graph.diagnostics ?? []).filter((diagnostic) => diagnostic.file === undefined || files.includes(diagnostic.file)),
+    conventions: {
+      singleResult: "async-await",
+      eventComposition: "rxjs",
+      angularHost: "@supacloud/app/angular",
+      cancellation: "explicit-owner-signal"
+    },
     relatedModules: {
       imports: subjectModule.imports.filter((name) => selected.has(name)),
       importedBy: graph.modules.filter((module) => module.imports.includes(subjectModule.name)).map((module) => module.name).sort()
@@ -15323,7 +15426,7 @@ var init_delivery_schema = __esm(() => {
 import { createHash as createHash6 } from "node:crypto";
 import { constants as constants2 } from "node:fs";
 import { lstat, mkdir as mkdir2, open as open3, readFile as readFile3, readdir, realpath, rename as rename2, rm, writeFile as writeFile2 } from "node:fs/promises";
-import { dirname as dirname5, isAbsolute as isAbsolute2, join as join6, relative as relative6, resolve as resolve6, sep as sep6 } from "node:path";
+import { dirname as dirname5, isAbsolute as isAbsolute2, join as join6, relative as relative6, resolve as resolve7, sep as sep6 } from "node:path";
 function canonical2(value) {
   return JSON.stringify(value, (_key, item) => item !== null && typeof item === "object" && !Array.isArray(item) ? Object.fromEntries(Object.entries(item).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0)) : item);
 }
@@ -15386,7 +15489,7 @@ async function reserveOutput(project, requested) {
   if (!inside(project, requested))
     throw new Error("Delivery output must be inside the application project.");
   const base = await realpath(project);
-  const path = resolve6(base, relative6(project, requested));
+  const path = resolve7(base, relative6(project, requested));
   if (relative6(base, path).split(sep6).some((part) => part === ".git" || part === "node_modules")) {
     throw new Error("Delivery output cannot use repository or dependency internals.");
   }
@@ -15579,9 +15682,9 @@ var init_delivery_build_schema = __esm(() => {
 
 // node_modules/@supacloud/delivery/src/delivery-artifact.ts
 import { readdir as readdir2, realpath as realpath2 } from "node:fs/promises";
-import { basename, dirname as dirname6, join as join7, resolve as resolve7 } from "node:path";
+import { basename, dirname as dirname6, join as join7, resolve as resolve8 } from "node:path";
 async function readDeliveryManifest(manifestPath) {
-  const selected = resolve7(manifestPath);
+  const selected = resolve8(manifestPath);
   const root = await realpath2(dirname6(selected));
   const manifest = parseDeliveryBuildManifest(JSON.parse((await readBoundedOwned(root, join7(root, basename(selected)), JSON_LIMIT)).toString("utf8")));
   return { root, manifest };
@@ -15730,6 +15833,213 @@ var init_delivery_context = __esm(() => {
   };
 });
 
+// src/fixes.ts
+import { createHash as createHash8, randomUUID } from "node:crypto";
+import { lstat as lstat2, readFile as readFile5, realpath as realpath3, rename as rename3, unlink as unlink2, writeFile as writeFile3 } from "node:fs/promises";
+import { dirname as dirname8, isAbsolute as isAbsolute4, relative as relative9, resolve as resolve12, sep as sep9 } from "node:path";
+import * as ts12 from "@typescript/typescript6";
+async function applyDiagnosticFix(fix, options = {}) {
+  if (!fix || typeof fix.targetFile !== "string")
+    throw new Error("Invalid DiagnosticFix");
+  const root = await realpath3(options.rootDir ?? process.cwd());
+  const file = resolve12(root, fix.targetFile);
+  const stat = await lstat2(file);
+  const resolved = await realpath3(file);
+  const relativePath = relative9(root, resolved);
+  if (stat.isSymbolicLink() || !stat.isFile() || isAbsolute4(relativePath) || relativePath === ".." || relativePath.startsWith(`..${sep9}`)) {
+    throw new Error("Fix target must be a regular file inside rootDir");
+  }
+  const original = await readFile5(file, "utf8");
+  const sourceHash = createHash8("sha256").update(original).digest("hex");
+  if (options.expectedSourceHash !== undefined && options.expectedSourceHash !== sourceHash) {
+    throw new Error("Fix source changed since preview; analyze the project again");
+  }
+  let source = parse5(file, original);
+  let content;
+  switch (fix.type) {
+    case "set_command_mode": {
+      if (fix.property !== "transaction" && fix.property !== "idempotency" || fix.value !== "required" && fix.value !== "none") {
+        throw new Error("Command mode fix requires an explicit property and policy value");
+      }
+      const object = decoratorObject(findClass(source, fix.command), "Command");
+      const current = property(object, fix.property);
+      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, ts12.factory.createStringLiteral(fix.value));
+      break;
+    }
+    case "add_module_import": {
+      if (!fix.importPath || !fix.symbol)
+        throw new Error("Module fix requires importPath and symbol");
+      identifier2(fix.symbol);
+      const withImport = importSymbol(source, fix.importPath, fix.symbol);
+      source = parse5(file, withImport);
+      const object = unique(moduleObjects(source).filter((candidate) => !fix.targetModule || stringProperty(candidate, "name") === fix.targetModule), "target module");
+      const imports = property(object, "imports");
+      if (imports && !ts12.isArrayLiteralExpression(imports.initializer)) {
+        throw new Error("Module imports must be a static array");
+      }
+      const values = imports && ts12.isArrayLiteralExpression(imports.initializer) ? imports.initializer.elements : [];
+      if (values.some(ts12.isSpreadElement))
+        throw new Error("Module imports cannot contain spread elements");
+      content = values.some((value) => ts12.isIdentifier(value) && value.text === fix.symbol) ? withImport : replaceProperty(source, object, "imports", ts12.factory.createArrayLiteralExpression([
+        ...values,
+        ts12.factory.createIdentifier(fix.symbol)
+      ]));
+      break;
+    }
+    case "add_command_permission": {
+      const permission = options.permission ?? fix.permission;
+      if (!permission?.trim()) {
+        throw new Error("Permission fix requires an explicit permission; privileges are never inferred");
+      }
+      const command = findClass(source, fix.command);
+      const object = decoratorObject(command, "Command");
+      const current = property(object, "permission");
+      if (current && (!ts12.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", ts12.factory.createStringLiteral(permission));
+      break;
+    }
+    case "add_route_parameter_binding": {
+      const controller = findClass(source, fix.controller);
+      const method = unique(controller.members.filter((member) => ts12.isMethodDeclaration(member) && nameOf(member.name) === fix.route), "route handler");
+      const parameter = unique(method.parameters.filter((candidate) => ts12.isIdentifier(candidate.name) && candidate.name.text === fix.parameter), "same-named route parameter");
+      const binding = fix.binding === "param" ? "Param" : fix.binding === "query" ? "Query" : undefined;
+      if (!binding)
+        throw new Error("Invalid route binding");
+      const decorators = ts12.getDecorators(parameter) ?? [];
+      if (decorators.length > 0)
+        throw new Error("Parameter already has a decorator");
+      const framework = unique(source.statements.filter((statement) => ts12.isImportDeclaration(statement) && statement.importClause?.namedBindings && ts12.isNamedImports(statement.importClause.namedBindings) && statement.importClause.namedBindings.elements.some((element) => ["Controller", "Get", "Post", "Put", "Patch", "Delete", "Head", "Options"].includes(element.name.text))), "framework import");
+      if (!ts12.isImportDeclaration(framework) || !ts12.isStringLiteral(framework.moduleSpecifier)) {
+        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(parse5(file, edited), framework.moduleSpecifier.text, binding);
+      break;
+    }
+    default:
+      throw new Error(`Diagnostic fix '${fix.type}' requires a manual semantic decision; no files changed`);
+  }
+  parse5(file, content);
+  const result = { file, changed: content !== original, content, sourceHash };
+  if (options.dryRun === false && result.changed) {
+    const temporary = `${file}.supacloud-fix-${randomUUID()}`;
+    try {
+      await writeFile3(temporary, content, { encoding: "utf8", flag: "wx", mode: stat.mode });
+      if (await readFile5(file, "utf8") !== original)
+        throw new Error("Target changed while preparing the fix");
+      await rename3(temporary, file);
+    } finally {
+      await unlink2(temporary).catch(() => {});
+    }
+  }
+  return result;
+}
+function parse5(file, text) {
+  const result = ts12.transpileModule(text, {
+    fileName: file,
+    reportDiagnostics: true,
+    compilerOptions: { target: ts12.ScriptTarget.ESNext, experimentalDecorators: true }
+  });
+  if (result.diagnostics?.some((item) => item.category === ts12.DiagnosticCategory.Error)) {
+    throw new Error("Cannot fix syntactically invalid TypeScript");
+  }
+  return ts12.createSourceFile(file, text, ts12.ScriptTarget.Latest, true, ts12.ScriptKind.TS);
+}
+function unique(items, description) {
+  if (items.length !== 1)
+    throw new Error(`Expected exactly one ${description}; found ${items.length}`);
+  return items[0];
+}
+function identifier2(value) {
+  if (!/^[A-Za-z_$][\w$]*$/.test(value))
+    throw new Error(`Invalid identifier '${value}'`);
+}
+function nameOf(name) {
+  if (!name)
+    return "";
+  return ts12.isIdentifier(name) || ts12.isStringLiteral(name) || ts12.isNumericLiteral(name) ? name.text : "";
+}
+function property(object, key) {
+  if (object.properties.some((item) => !ts12.isPropertyAssignment(item) || ts12.isComputedPropertyName(item.name))) {
+    throw new Error("Fix requires explicit static object properties");
+  }
+  const values = object.properties.filter((item) => ts12.isPropertyAssignment(item) && nameOf(item.name) === key);
+  if (values.length > 1)
+    throw new Error(`Duplicate '${key}' property`);
+  return values[0];
+}
+function stringProperty(object, key) {
+  const value = property(object, key)?.initializer;
+  return value && ts12.isStringLiteral(value) ? value.text : undefined;
+}
+function replaceProperty(source, object, key, value) {
+  const previous = property(object, key);
+  const replacement = ts12.factory.createPropertyAssignment(key, value);
+  const properties = object.properties.map((item) => item === previous ? replacement : item);
+  if (!previous)
+    properties.push(replacement);
+  const updated = ts12.factory.updateObjectLiteralExpression(object, properties);
+  return source.text.slice(0, object.getStart(source)) + ts12.createPrinter().printNode(ts12.EmitHint.Expression, updated, source) + source.text.slice(object.end);
+}
+function findClass(source, name) {
+  return unique(source.statements.filter((statement) => ts12.isClassDeclaration(statement) && statement.name?.text === name), `class '${name}'`);
+}
+function decoratorObject(node, name) {
+  const decorator = unique((ts12.getDecorators(node) ?? []).filter((item) => ts12.isCallExpression(item.expression) && item.expression.expression.getText() === name), `@${name} decorator`);
+  const argument = ts12.isCallExpression(decorator.expression) ? decorator.expression.arguments[0] : undefined;
+  if (!argument || !ts12.isObjectLiteralExpression(argument))
+    throw new Error(`@${name} requires a static object`);
+  return argument;
+}
+function moduleObjects(source) {
+  const result = [];
+  for (const statement of source.statements) {
+    if (ts12.isClassDeclaration(statement) && (ts12.getDecorators(statement) ?? []).some((item) => ts12.isCallExpression(item.expression) && item.expression.expression.getText() === "Module")) {
+      result.push(decoratorObject(statement, "Module"));
+    }
+    if (ts12.isVariableStatement(statement)) {
+      for (const declaration of statement.declarationList.declarations) {
+        const call = declaration.initializer;
+        if (call && ts12.isCallExpression(call) && ["defineModule", "defineFeatureSlice"].includes(call.expression.getText()) && call.arguments[0] && ts12.isObjectLiteralExpression(call.arguments[0])) {
+          result.push(call.arguments[0]);
+        }
+      }
+    }
+  }
+  return result;
+}
+function importSymbol(source, path, symbol) {
+  identifier2(symbol);
+  const current = resolve12(source.fileName).replace(/\.(tsx?|mts|cts)$/, "");
+  const target = resolve12(dirname8(source.fileName), path).replace(/\.(tsx?|mts|cts)$/, "");
+  if (current === target)
+    return source.text;
+  const matches = source.statements.filter((item) => ts12.isImportDeclaration(item) && ts12.isStringLiteral(item.moduleSpecifier) && item.moduleSpecifier.text === path);
+  if (matches.length > 1)
+    throw new Error(`Ambiguous imports from '${path}'`);
+  const match = matches[0];
+  if (match && ts12.isImportDeclaration(match) && match.importClause?.namedBindings && ts12.isNamedImports(match.importClause.namedBindings) && !match.importClause.isTypeOnly) {
+    if (match.importClause.namedBindings.elements.some((item) => item.name.text === symbol))
+      return source.text;
+    const bindings = match.importClause.namedBindings;
+    const updated = ts12.factory.updateNamedImports(bindings, [
+      ...bindings.elements,
+      ts12.factory.createImportSpecifier(false, undefined, ts12.factory.createIdentifier(symbol))
+    ]);
+    return source.text.slice(0, bindings.getStart(source)) + ts12.createPrinter().printNode(ts12.EmitHint.Unspecified, updated, source) + source.text.slice(bindings.end);
+  }
+  if (match)
+    throw new Error(`Import from '${path}' is not a named value import`);
+  return `import { ${symbol} } from ${JSON.stringify(path)};
+${source.text}`;
+}
+var init_fixes = () => {};
+
 // src/delivery-files.ts
 var init_delivery_files2 = __esm(() => {
   init_delivery_files();
@@ -16095,7 +16405,7 @@ var init_release_evidence = __esm(() => {
 });
 
 // src/release-evidence-cli.ts
-import { resolve as resolve19 } from "node:path";
+import { resolve as resolve20 } from "node:path";
 async function runReleaseEvidenceCommand(args) {
   try {
     const values = new Map;
@@ -16119,7 +16429,7 @@ async function runReleaseEvidenceCommand(args) {
     if (!manifest || !target || manifest.length > 4096 || !/^[a-z][a-z0-9-]{0,62}$/.test(target)) {
       throw new ReleaseEvidenceError("RELEASE_EVIDENCE_INVALID");
     }
-    const evidence = await createReleaseEvidence(resolve19(manifest), target);
+    const evidence = await createReleaseEvidence(resolve20(manifest), target);
     console.log(json ? JSON.stringify(evidence, null, 2) : formatReleaseEvidence(evidence));
   } catch (error) {
     console.error(`Error: ${error instanceof ReleaseEvidenceError ? error.code : "RELEASE_EVIDENCE_INVALID"}`);
@@ -16131,12 +16441,12 @@ var init_release_evidence_cli = __esm(() => {
 });
 
 // src/database-contracts.ts
-import { createHash as createHash10 } from "node:crypto";
+import { createHash as createHash11 } from "node:crypto";
 import { mkdir as mkdir5, readFile as readFile12 } from "node:fs/promises";
-import { dirname as dirname11, relative as relative12, resolve as resolve20 } from "node:path";
-import * as ts14 from "@typescript/typescript6";
+import { dirname as dirname11, relative as relative12, resolve as resolve21 } from "node:path";
+import * as ts17 from "@typescript/typescript6";
 function hash3(value) {
-  return createHash10("sha256").update(value).digest("hex");
+  return createHash11("sha256").update(value).digest("hex");
 }
 function importPath(out, path) {
   const value = relative12(out, path).replaceAll("\\", "/").replace(/\.(?:d\.)?[cm]?ts$/, "");
@@ -16161,33 +16471,33 @@ function parseDatabaseContractsOptions(value, directory) {
     throw new TypeError("migrations must be an ordered list of SQL files");
   }
   return {
-    rootDir: resolve20(directory, field("rootDir")),
-    outDir: resolve20(directory, field("outDir")),
-    postgrestTypes: resolve20(directory, field("postgrestTypes")),
-    drizzleSchema: resolve20(directory, field("drizzleSchema")),
+    rootDir: resolve21(directory, field("rootDir")),
+    outDir: resolve21(directory, field("outDir")),
+    postgrestTypes: resolve21(directory, field("postgrestTypes")),
+    drizzleSchema: resolve21(directory, field("drizzleSchema")),
     role: field("role"),
-    graphql: { ...graphql, schema: resolve20(directory, graphql.schema) },
-    migrations: migrations.map((file) => resolve20(directory, file))
+    graphql: { ...graphql, schema: resolve21(directory, graphql.schema) },
+    migrations: migrations.map((file) => resolve21(directory, file))
   };
 }
 async function generateDatabaseContracts(options, check = false) {
-  const rootDir = resolve20(options.rootDir), outDir = resolve20(options.outDir);
-  const postgrestTypes = resolve20(rootDir, options.postgrestTypes), drizzleSchema = resolve20(rootDir, options.drizzleSchema);
+  const rootDir = resolve21(options.rootDir), outDir = resolve21(options.outDir);
+  const postgrestTypes = resolve21(rootDir, options.postgrestTypes), drizzleSchema = resolve21(rootDir, options.drizzleSchema);
   const snapshot = await readFile12(postgrestTypes, "utf8");
-  const syntax = ts14.createSourceFile(postgrestTypes, snapshot, ts14.ScriptTarget.Latest, true);
-  const database = syntax.statements.find((node) => (ts14.isTypeAliasDeclaration(node) || ts14.isInterfaceDeclaration(node)) && node.name.text === "Database" && node.modifiers?.some((modifier) => modifier.kind === ts14.SyntaxKind.ExportKeyword));
+  const syntax = ts17.createSourceFile(postgrestTypes, snapshot, ts17.ScriptTarget.Latest, true);
+  const database = syntax.statements.find((node) => (ts17.isTypeAliasDeclaration(node) || ts17.isInterfaceDeclaration(node)) && node.name.text === "Database" && node.modifiers?.some((modifier) => modifier.kind === ts17.SyntaxKind.ExportKeyword));
   if (!database)
     throw new Error("PostgREST snapshot must export Database from the official type generator");
-  const program = ts14.createProgram([postgrestTypes], {
+  const program = ts17.createProgram([postgrestTypes], {
     strict: true,
     noEmit: true,
     skipLibCheck: true,
     types: [],
-    target: ts14.ScriptTarget.ES2022,
-    module: ts14.ModuleKind.ESNext,
-    moduleResolution: ts14.ModuleResolutionKind.Bundler
+    target: ts17.ScriptTarget.ES2022,
+    module: ts17.ModuleKind.ESNext,
+    moduleResolution: ts17.ModuleResolutionKind.Bundler
   });
-  if (ts14.getPreEmitDiagnostics(program).length)
+  if (ts17.getPreEmitDiagnostics(program).length)
     throw new Error("PostgREST snapshot has TypeScript errors");
   const artifacts = await renderGraphql({
     rootDir,
@@ -16200,16 +16510,16 @@ async function generateDatabaseContracts(options, check = false) {
   }
   const inputs = {};
   const addInput = async (path) => {
-    const absolute = resolve20(rootDir, path);
+    const absolute = resolve21(rootDir, path);
     inputs[relative12(rootDir, absolute).replaceAll("\\", "/")] = hash3(await readFile12(absolute, "utf8"));
   };
   await addInput(postgrestTypes);
   await addInput(drizzleSchema);
-  const drizzleProgram = ts14.createProgram([drizzleSchema], {
+  const drizzleProgram = ts17.createProgram([drizzleSchema], {
     noEmit: true,
-    moduleResolution: ts14.ModuleResolutionKind.Bundler,
-    module: ts14.ModuleKind.ESNext,
-    target: ts14.ScriptTarget.ES2022,
+    moduleResolution: ts17.ModuleResolutionKind.Bundler,
+    module: ts17.ModuleKind.ESNext,
+    target: ts17.ScriptTarget.ES2022,
     types: [],
     skipLibCheck: true
   });
@@ -16217,8 +16527,8 @@ async function generateDatabaseContracts(options, check = false) {
     if (!source.isDeclarationFile && !source.fileName.includes("/node_modules/"))
       await addInput(source.fileName);
   }
-  await addInput(resolve20(rootDir, options.graphql.schema));
-  if (new Set(options.migrations.map((path) => resolve20(rootDir, path))).size !== options.migrations.length) {
+  await addInput(resolve21(rootDir, options.graphql.schema));
+  if (new Set(options.migrations.map((path) => resolve21(rootDir, path))).size !== options.migrations.length) {
     throw new Error("Duplicate migration in database contracts configuration");
   }
   for (const path of options.migrations)
@@ -16239,14 +16549,14 @@ async function generateDatabaseContracts(options, check = false) {
     version: 1,
     role: options.role,
     inputs: Object.fromEntries(Object.entries(inputs).sort(([a], [b]) => a.localeCompare(b))),
-    migrationOrder: options.migrations.map((path) => relative12(rootDir, resolve20(rootDir, path)).replaceAll("\\", "/")),
+    migrationOrder: options.migrations.map((path) => relative12(rootDir, resolve21(rootDir, path)).replaceAll("\\", "/")),
     outputs: Object.fromEntries(Object.entries(files).sort(([a], [b]) => a.localeCompare(b)).map(([file, text]) => [file, hash3(text)]))
   };
   files["database.manifest.json"] = JSON.stringify(manifest, null, 2) + `
 `;
   const mismatches = [];
   for (const [file, content] of Object.entries(files)) {
-    const path = resolve20(outDir, file);
+    const path = resolve21(outDir, file);
     let current;
     try {
       current = await readFile12(path, "utf8");
@@ -16260,12 +16570,12 @@ async function generateDatabaseContracts(options, check = false) {
   if (!check) {
     await mkdir5(outDir, { recursive: true });
     for (const [file, content] of Object.entries(files))
-      await writeFileIfChanged(resolve20(outDir, file), content);
+      await writeFileIfChanged(resolve21(outDir, file), content);
   }
   return { upToDate: mismatches.length === 0, mismatches, written: check ? [] : mismatches, manifest };
 }
 async function runDatabaseContractsFile(path, check = false) {
-  const absolute = resolve20(path);
+  const absolute = resolve21(path);
   const value = JSON.parse(await readFile12(absolute, "utf8"));
   return generateDatabaseContracts(parseDatabaseContractsOptions(value, dirname11(absolute)), check);
 }
@@ -16277,8 +16587,8 @@ var init_database_contracts = __esm(() => {
 
 // src/graphql-schema.ts
 import { mkdir as mkdir6, readFile as readFile13 } from "node:fs/promises";
-import { createHash as createHash11 } from "node:crypto";
-import { dirname as dirname12, resolve as resolve21 } from "node:path";
+import { createHash as createHash12 } from "node:crypto";
+import { dirname as dirname12, resolve as resolve22 } from "node:path";
 async function pullGraphqlSchema(options) {
   assertGraphqlOptions({ schema: options.output });
   const endpoint = new URL(options.url);
@@ -16318,7 +16628,7 @@ async function pullGraphqlSchema(options) {
     throw new Error("GraphQL schema export failed. Verify caller grants and enable introspection only in the intended development environment.");
   }
   const schema = lexicographicSortSchema(buildClientSchema(data));
-  const path = resolve21(options.output);
+  const path = resolve22(options.output);
   const content = path.endsWith(".json") ? JSON.stringify(introspectionFromSchema(schema), null, 2) + `
 ` : `# GENERATED BY supacloud-compiler graphql-schema. DO NOT EDIT.
 # Database First: change database declarations, apply migrations, then re-export for the intended role.
@@ -16332,7 +16642,7 @@ async function pullGraphqlSchema(options) {
       throw error;
   }
   const upToDate = previous === content;
-  const schemaHash = createHash11("sha256").update(content).digest("hex");
+  const schemaHash = createHash12("sha256").update(content).digest("hex");
   if (options.check)
     return { path, schemaHash, upToDate, written: false };
   await mkdir6(dirname12(path), { recursive: true });
@@ -16345,13 +16655,13 @@ var init_graphql_schema = __esm(() => {
 });
 
 // src/cli.ts
-import { resolve as resolve22 } from "node:path";
+import { resolve as resolve23 } from "node:path";
 import { readFile as readFile14 } from "node:fs/promises";
 
 // src/analyze.ts
 import { createHash as createHash3 } from "node:crypto";
 import { relative as relative2, resolve as resolvePath, sep as sep2 } from "node:path";
-import * as ts4 from "@typescript/typescript6";
+import * as ts7 from "@typescript/typescript6";
 
 // src/program.ts
 import { createHash as createHash2 } from "node:crypto";
@@ -16687,12 +16997,258 @@ function readProjectConfig(rootDir) {
 init_validate();
 
 // src/static-di.ts
+import * as ts6 from "@typescript/typescript6";
+
+// src/reactive-analysis.ts
+import * as ts4 from "@typescript/typescript6";
+
+// src/api-source.ts
 import * as ts3 from "@typescript/typescript6";
+import { resolve as resolve2 } from "node:path";
+function bindApiSource(source) {
+  const file = resolve2(source.fileName);
+  const bound = ts3.createSourceFile(file, source.text, ts3.ScriptTarget.Latest, true);
+  const options = { noLib: true, noResolve: true, target: ts3.ScriptTarget.ES2022 };
+  const host = {
+    getSourceFile: (name) => resolve2(name) === file ? bound : undefined,
+    getDefaultLibFileName: () => "",
+    writeFile: () => {},
+    getCurrentDirectory: () => process.cwd(),
+    getDirectories: () => [],
+    fileExists: (name) => resolve2(name) === file,
+    readFile: (name) => resolve2(name) === file ? source.text : undefined,
+    getCanonicalFileName: (name) => name,
+    useCaseSensitiveFileNames: () => true,
+    getNewLine: () => `
+`
+  };
+  const program = ts3.createProgram([file], options, host);
+  return { source: bound, checker: program.getTypeChecker() };
+}
+function importedFrom(node) {
+  let current = node;
+  while (current && !ts3.isImportDeclaration(current))
+    current = current.parent;
+  return current && ts3.isImportDeclaration(current) && ts3.isStringLiteral(current.moduleSpecifier) ? current.moduleSpecifier.text : undefined;
+}
+function apiOrigin(expression, checker, seen = new Set) {
+  if (seen.has(expression))
+    return;
+  seen.add(expression);
+  if (ts3.isParenthesizedExpression(expression) || ts3.isAsExpression(expression) || ts3.isSatisfiesExpression(expression) || ts3.isTypeAssertionExpression(expression)) {
+    return apiOrigin(expression.expression, checker, seen);
+  }
+  if (ts3.isPropertyAccessExpression(expression) || ts3.isElementAccessExpression(expression)) {
+    const name = ts3.isPropertyAccessExpression(expression) ? expression.name.text : ts3.isStringLiteral(expression.argumentExpression) ? expression.argumentExpression.text : undefined;
+    const namespace = apiOrigin(expression.expression, checker, seen);
+    return namespace?.name === "*" && name ? { module: namespace.module, name } : undefined;
+  }
+  if (!ts3.isIdentifier(expression))
+    return;
+  const symbol = checker.getSymbolAtLocation(expression);
+  for (const declaration of symbol?.declarations ?? []) {
+    if (ts3.isImportSpecifier(declaration) && !declaration.isTypeOnly && !declaration.parent.parent.isTypeOnly) {
+      const module = importedFrom(declaration);
+      if (module)
+        return { module, name: (declaration.propertyName ?? declaration.name).text };
+    }
+    if (ts3.isNamespaceImport(declaration) && !declaration.parent.isTypeOnly) {
+      const module = importedFrom(declaration);
+      if (module)
+        return { module, name: "*" };
+    }
+    if (ts3.isVariableDeclaration(declaration) && declaration.initializer && ts3.isVariableDeclarationList(declaration.parent) && declaration.parent.flags & ts3.NodeFlags.Const) {
+      return apiOrigin(declaration.initializer, checker, seen);
+    }
+  }
+  return;
+}
+
+// src/reactive-analysis.ts
+var angularState = new Set(["@angular/core", "@supacloud/app/angular"]);
+var signalBridges = new Set(["@angular/core/rxjs-interop", "@supacloud/app/angular", "@supacloud/app/rxjs"]);
+function scanReactiveSource(input, file) {
+  if (!input.statements.some((node) => ts4.isImportDeclaration(node) && ts4.isStringLiteral(node.moduleSpecifier) && (angularState.has(node.moduleSpecifier.text) || signalBridges.has(node.moduleSpecifier.text))))
+    return [];
+  const { source, checker } = bindApiSource(input);
+  const diagnostics = [];
+  const reported = new Set;
+  const visit = (node, reactive) => {
+    if (ts4.isCallExpression(node)) {
+      const origin = apiOrigin(node.expression, checker);
+      if (reactive && origin && signalBridges.has(origin.module) && ["toSignal", "toScopedSignal", "rxResource"].includes(origin.name) && !reported.has(node.pos)) {
+        reported.add(node.pos);
+        const start = source.getLineAndCharacterOfPosition(node.getStart(source));
+        const end = source.getLineAndCharacterOfPosition(node.end);
+        diagnostics.push({
+          severity: "error",
+          code: "reactive-subscription-in-computation",
+          file,
+          line: start.line + 1,
+          column: start.character,
+          endLine: end.line + 1,
+          endColumn: end.character,
+          message: `${origin.name} creates a subscription inside a reactive computation.`,
+          suggestion: "Create the subscription once in its explicit owner scope, then derive state with computed. Hoisting requires ownership review; no automatic edit is safe.",
+          docsUrl: "https://supacloud.dev/errors/reactive-subscription-in-computation"
+        });
+      }
+      if (origin && angularState.has(origin.module) && ["computed", "effect", "untracked"].includes(origin.name)) {
+        const callback = node.arguments[0];
+        if (callback && (ts4.isArrowFunction(callback) || ts4.isFunctionExpression(callback))) {
+          visit(callback.body, origin.name === "untracked" ? false : true);
+          for (const argument of node.arguments.slice(1))
+            visit(argument, reactive);
+          return;
+        }
+      }
+      let expression = node.expression;
+      while (ts4.isParenthesizedExpression(expression))
+        expression = expression.expression;
+      if (ts4.isArrowFunction(expression) || ts4.isFunctionExpression(expression))
+        visit(expression.body, reactive);
+    }
+    if (ts4.isFunctionLike(node)) {
+      if (!reactive)
+        ts4.forEachChild(node, (child) => visit(child, false));
+      return;
+    }
+    ts4.forEachChild(node, (child) => visit(child, reactive));
+  };
+  visit(source, false);
+  return diagnostics;
+}
+
+// src/http-provider-migration.ts
+import * as ts5 from "@typescript/typescript6";
+function providerArgument(node, checker) {
+  let current = node;
+  while (ts5.isParenthesizedExpression(current.parent))
+    current = current.parent;
+  if (!ts5.isCallExpression(current.parent) || current.parent.expression !== current)
+    return false;
+  current = current.parent;
+  while (ts5.isParenthesizedExpression(current.parent))
+    current = current.parent;
+  const parent = current.parent;
+  if (!ts5.isCallExpression(parent) || !parent.arguments.some((argument) => argument === current))
+    return false;
+  const owner = apiOrigin(parent.expression, checker);
+  return owner?.name === "provideHttpClient" && ["@supacloud/app", "@supacloud/app/http"].includes(owner.module);
+}
+function migrateHttpProviderImports(source, fileName) {
+  const bound = bindApiSource(ts5.createSourceFile(fileName, source, ts5.ScriptTarget.Latest, true));
+  const { source: sf, checker } = bound;
+  const edits = [];
+  const issues = [];
+  const printer = ts5.createPrinter({ newLine: source.includes(`\r
+`) ? ts5.NewLineKind.CarriageReturnLineFeed : ts5.NewLineKind.LineFeed });
+  const newline = source.includes(`\r
+`) ? `\r
+` : `
+`;
+  for (const statement of sf.statements) {
+    if (!ts5.isImportDeclaration(statement) || !ts5.isStringLiteral(statement.moduleSpecifier) || statement.moduleSpecifier.text !== "@supacloud/app" || !statement.importClause || statement.importClause.isTypeOnly)
+      continue;
+    const named = statement.importClause.namedBindings;
+    if (!named || !ts5.isNamedImports(named))
+      continue;
+    const specifier = named.elements.find((item) => !item.isTypeOnly && (item.propertyName ?? item.name).text === "withInterceptors");
+    if (!specifier)
+      continue;
+    const symbol = checker.getSymbolAtLocation(specifier.name);
+    if (!symbol)
+      continue;
+    const uses = [];
+    const visit = (node) => {
+      if (ts5.isImportDeclaration(node))
+        return;
+      if (ts5.isIdentifier(node) && checker.getSymbolAtLocation(node) === symbol)
+        uses.push(node);
+      ts5.forEachChild(node, visit);
+    };
+    visit(sf);
+    if (!uses.some((node) => providerArgument(node, checker)))
+      continue;
+    if (!uses.every((node) => providerArgument(node, checker)) || statement.attributes) {
+      issues.push({
+        code: "http-provider-migration-ambiguous",
+        file: fileName,
+        line: sf.getLineAndCharacterOfPosition(specifier.getStart(sf)).line + 1,
+        message: "withInterceptors also has non-provider uses; split the bindings manually before migration."
+      });
+      continue;
+    }
+    const remaining = named.elements.filter((item) => item !== specifier);
+    if (remaining.length === 0 && !statement.importClause.name) {
+      edits.push({ start: statement.moduleSpecifier.getStart(sf), end: statement.moduleSpecifier.end, text: '"@supacloud/app/http"' });
+    } else {
+      const clause = ts5.factory.updateImportClause(statement.importClause, false, statement.importClause.name, remaining.length ? ts5.factory.updateNamedImports(named, remaining) : undefined);
+      const updated = ts5.factory.updateImportDeclaration(statement, statement.modifiers, clause, statement.moduleSpecifier, statement.attributes);
+      const text = printer.printNode(ts5.EmitHint.Unspecified, updated, sf).trimStart() + newline + `import { ${specifier.getText(sf)} } from "@supacloud/app/http";`;
+      const withoutLeading = text.replace(/^(?:\/\/[^\n]*\n|\/\*[\s\S]*?\*\/\s*)+/, "");
+      edits.push({ start: statement.getStart(sf), end: statement.end, text: withoutLeading });
+    }
+  }
+  const checkNamespace = (node) => {
+    if ((ts5.isPropertyAccessExpression(node) || ts5.isElementAccessExpression(node)) && providerArgument(node, checker)) {
+      const origin = apiOrigin(node, checker);
+      if (origin?.module === "@supacloud/app" && origin.name === "withInterceptors")
+        issues.push({
+          code: "http-provider-migration-namespace",
+          file: fileName,
+          line: sf.getLineAndCharacterOfPosition(node.getStart(sf)).line + 1,
+          message: "Use a dedicated named import from @supacloud/app/http; namespace rewrites require manual review."
+        });
+    }
+    ts5.forEachChild(node, checkNamespace);
+  };
+  checkNamespace(sf);
+  if (issues.length)
+    return { changed: false, content: source, replacements: 0, issues };
+  let content = source;
+  for (const edit of edits.sort((a, b) => b.start - a.start))
+    content = content.slice(0, edit.start) + edit.text + content.slice(edit.end);
+  return { changed: edits.length > 0, content, replacements: edits.length, issues: [] };
+}
+function scanHttpProviderImports(source, file) {
+  if (!source.text.includes("@supacloud/app"))
+    return [];
+  const { source: sf, checker } = bindApiSource(source);
+  const diagnostics = [];
+  const visit = (node) => {
+    if (ts5.isCallExpression(node)) {
+      const origin = apiOrigin(node.expression, checker);
+      if (origin?.module === "@supacloud/app" && origin.name === "withInterceptors" && providerArgument(node.expression, checker)) {
+        const start = sf.getLineAndCharacterOfPosition(node.getStart(sf));
+        const end = sf.getLineAndCharacterOfPosition(node.end);
+        diagnostics.push({
+          severity: "error",
+          code: "http-provider-import-mismatch",
+          file,
+          line: start.line + 1,
+          column: start.character,
+          endLine: end.line + 1,
+          endColumn: end.character,
+          message: "The root withInterceptors returns an interceptor array, not a provideHttpClient feature.",
+          suggestion: "Import withInterceptors from @supacloud/app/http. Preview the http-provider-entrypoint source migration; mixed/namespace uses require manual review.",
+          docsUrl: "https://supacloud.dev/errors/http-provider-import-mismatch"
+        });
+      }
+    }
+    ts5.forEachChild(node, visit);
+  };
+  visit(sf);
+  return diagnostics;
+}
+
+// src/static-di.ts
 var runtimeApis = new Set([
   "inject",
   "createEnvironmentInjector",
   "runInInjectionContext",
   "EnvironmentInjector",
+  "Injector",
   "bootstrapBun",
   "runInScope",
   "runInRequestContext",
@@ -16702,25 +17258,33 @@ var runtimeApis = new Set([
 function scanRuntimeDi(source, file) {
   const diagnostics = [];
   const namespaces = new Set;
-  const report = (node) => diagnostics.push({
-    severity: "error",
-    code: "runtime-injection-disallowed",
-    errorCode: "SC2012",
-    docsUrl: "https://supacloud.dev/errors/SC2012",
-    file,
-    line: source.getLineAndCharacterOfPosition(node.getStart()).line + 1,
-    message: "Compiled applications cannot import runtime DI. Use explicit constructors and generated scope factories."
-  });
+  const report = (node) => {
+    const start = source.getLineAndCharacterOfPosition(node.getStart());
+    const end = source.getLineAndCharacterOfPosition(node.end);
+    diagnostics.push({
+      severity: "error",
+      code: "runtime-injection-disallowed",
+      errorCode: "SC2012",
+      docsUrl: "https://supacloud.dev/errors/SC2012",
+      file,
+      line: start.line + 1,
+      column: start.character,
+      endLine: end.line + 1,
+      endColumn: end.character,
+      message: "Compiled applications cannot import runtime DI. Use explicit constructors and generated scope factories.",
+      suggestion: "Use constructor dependencies and generated request/job factories. Keep Angular runtime services outside the compiled application source root."
+    });
+  };
   for (const statement of source.statements) {
-    if (!(ts3.isImportDeclaration(statement) || ts3.isExportDeclaration(statement)) || !statement.moduleSpecifier || !ts3.isStringLiteral(statement.moduleSpecifier) || !/^@supacloud\/app(?:\/|$)/.test(statement.moduleSpecifier.text))
+    if (!(ts6.isImportDeclaration(statement) || ts6.isExportDeclaration(statement)) || !statement.moduleSpecifier || !ts6.isStringLiteral(statement.moduleSpecifier) || !(/^@supacloud\/app(?:\/|$)/.test(statement.moduleSpecifier.text) || statement.moduleSpecifier.text === "@angular/core"))
       continue;
-    if (ts3.isImportDeclaration(statement)) {
+    if (ts6.isImportDeclaration(statement)) {
       if (statement.importClause?.isTypeOnly)
         continue;
       const binding = statement.importClause?.namedBindings;
-      if (binding && ts3.isNamespaceImport(binding))
+      if (binding && ts6.isNamespaceImport(binding))
         namespaces.add(binding.name.text);
-      if (binding && ts3.isNamedImports(binding))
+      if (binding && ts6.isNamedImports(binding))
         for (const item of binding.elements) {
           if (!item.isTypeOnly && runtimeApis.has((item.propertyName ?? item.name).text))
             report(item);
@@ -16728,24 +17292,29 @@ function scanRuntimeDi(source, file) {
     } else if (!statement.isTypeOnly) {
       if (!statement.exportClause)
         report(statement);
-      else if (ts3.isNamedExports(statement.exportClause))
+      else if (ts6.isNamedExports(statement.exportClause))
         for (const item of statement.exportClause.elements) {
           if (!item.isTypeOnly && runtimeApis.has((item.propertyName ?? item.name).text))
             report(item);
         }
     }
   }
-  const visit = (node) => {
-    if (ts3.isPropertyAccessExpression(node) && ts3.isIdentifier(node.expression) && namespaces.has(node.expression.text) && runtimeApis.has(node.name.text))
-      report(node);
-    if (ts3.isElementAccessExpression(node) && ts3.isIdentifier(node.expression) && namespaces.has(node.expression.text) && (!ts3.isStringLiteral(node.argumentExpression) || runtimeApis.has(node.argumentExpression.text)))
-      report(node);
-    if (ts3.isVariableDeclaration(node) && node.initializer && ts3.isIdentifier(node.initializer) && namespaces.has(node.initializer.text))
-      report(node);
-    ts3.forEachChild(node, visit);
-  };
-  visit(source);
-  return diagnostics;
+  if (namespaces.size > 0) {
+    const bound = bindApiSource(source);
+    const protectedNamespace = (expression) => {
+      const origin = apiOrigin(expression, bound.checker);
+      return origin?.name === "*" && (origin.module === "@angular/core" || /^@supacloud\/app(?:\/|$)/.test(origin.module));
+    };
+    const visit = (node) => {
+      if (ts6.isPropertyAccessExpression(node) && protectedNamespace(node.expression) && runtimeApis.has(node.name.text))
+        report(node);
+      if (ts6.isElementAccessExpression(node) && protectedNamespace(node.expression) && (!ts6.isStringLiteral(node.argumentExpression) || runtimeApis.has(node.argumentExpression.text)))
+        report(node);
+      ts6.forEachChild(node, visit);
+    };
+    visit(bound.source);
+  }
+  return [...diagnostics, ...scanReactiveSource(source, file), ...scanHttpProviderImports(source, file)];
 }
 
 // src/analyze.ts
@@ -16796,36 +17365,39 @@ function lineOf(node) {
   return sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile)).line + 1;
 }
 function variableName(decl) {
-  return ts4.isIdentifier(decl.name) ? decl.name.text : nodeText(decl.name);
+  return ts7.isIdentifier(decl.name) ? decl.name.text : nodeText(decl.name);
 }
 function propertyName(name) {
-  if (ts4.isIdentifier(name) || ts4.isPrivateIdentifier(name))
+  if (ts7.isIdentifier(name) || ts7.isPrivateIdentifier(name))
     return name.text;
-  if (ts4.isStringLiteral(name) || ts4.isNumericLiteral(name))
+  if (ts7.isStringLiteral(name) || ts7.isNumericLiteral(name))
     return name.text;
   return nodeText(name);
 }
 function parameterName(param) {
-  return ts4.isIdentifier(param.name) ? param.name.text : nodeText(param.name);
+  return ts7.isIdentifier(param.name) ? param.name.text : nodeText(param.name);
 }
 function decoratorsOf(node) {
-  return ts4.canHaveDecorators(node) ? ts4.getDecorators(node) ?? [] : [];
+  return ts7.canHaveDecorators(node) ? ts7.getDecorators(node) ?? [] : [];
 }
 function decoratorArguments(dec) {
-  return ts4.isCallExpression(dec.expression) ? dec.expression.arguments : [];
+  return ts7.isCallExpression(dec.expression) ? dec.expression.arguments : [];
 }
 function hasMethod(cls, name) {
-  return cls.members.some((member) => (ts4.isMethodDeclaration(member) || ts4.isGetAccessorDeclaration(member) || ts4.isSetAccessorDeclaration(member)) && member.name !== undefined && propertyName(member.name) === name);
+  return cls.members.some((member) => (ts7.isMethodDeclaration(member) || ts7.isGetAccessorDeclaration(member) || ts7.isSetAccessorDeclaration(member)) && member.name !== undefined && propertyName(member.name) === name);
 }
 function hasDestroyHook(cls) {
   return hasMethod(cls, "onDestroy") || hasMethod(cls, "ngOnDestroy");
 }
+function hasInitHook(cls) {
+  return hasMethod(cls, "onInit");
+}
 function descendantsOfKind(root, predicate) {
   const result = [];
   const visit = (node) => {
     if (predicate(node))
       result.push(node);
-    ts4.forEachChild(node, visit);
+    ts7.forEachChild(node, visit);
   };
   visit(root);
   return result;
@@ -16834,7 +17406,7 @@ async function analyzeProject(rootDir, include, cache, changedPaths) {
   const session = cache?.programSession ?? createIncrementalProgramSession(rootDir);
   if (cache)
     cache.programSession = session;
-  const rootNames = ts4.sys.readDirectory(rootDir, [".ts", ".tsx"], ["node_modules", "dist"], include ?? DEFAULT_INCLUDE);
+  const rootNames = ts7.sys.readDirectory(rootDir, [".ts", ".tsx"], ["node_modules", "dist"], include ?? DEFAULT_INCLUDE);
   const update = session.update(rootNames, changedPaths);
   const program = update.program;
   const checker = program.getTypeChecker();
@@ -16870,7 +17442,7 @@ async function analyzeProject(rootDir, include, cache, changedPaths) {
   for (const sf of sourceFiles) {
     const traits = nativeTraitFiles.get(sf.fileName);
     if (!cache || traits?.has("module")) {
-      for (const cls of sf.statements.filter(ts4.isClassDeclaration)) {
+      for (const cls of sf.statements.filter(ts7.isClassDeclaration)) {
         const moduleDec = findDecorator(cls, "Module");
         if (!moduleDec)
           continue;
@@ -16887,14 +17459,14 @@ async function analyzeProject(rootDir, include, cache, changedPaths) {
       }
     }
     if (!cache || traits?.has("defineModule") || traits?.has("defineFeatureSlice")) {
-      for (const call of descendantsOfKind(sf, ts4.isCallExpression)) {
+      for (const call of descendantsOfKind(sf, ts7.isCallExpression)) {
         if (!["defineModule", "defineFeatureSlice"].includes(nodeText(call.expression)))
           continue;
         const parent = call.parent;
-        if (!parent || !ts4.isVariableDeclaration(parent))
+        if (!parent || !ts7.isVariableDeclaration(parent))
           continue;
         const arg = call.arguments[0];
-        if (!arg || !ts4.isObjectLiteralExpression(arg))
+        if (!arg || !ts7.isObjectLiteralExpression(arg))
           continue;
         candidates.push({
           node: parent,
@@ -17030,6 +17602,7 @@ async function analyzeProject(rootDir, include, cache, changedPaths) {
           ...functionalInjects.length > 0 ? { functionalInjects } : {},
           providedIn: "root",
           ...hasDestroyHook(classInfo.decl) ? { hasOnDestroy: true } : {},
+          ...hasInitHook(classInfo.decl) ? { hasOnInit: true } : {},
           exported: true,
           file,
           line,
@@ -17041,7 +17614,7 @@ async function analyzeProject(rootDir, include, cache, changedPaths) {
       const controllerDec = findDecorator(classInfo.decl, "Controller");
       if (controllerDec) {
         const arg = decoratorArguments(controllerDec)[0];
-        const isStandalone = arg && ts4.isObjectLiteralExpression(arg) && booleanProp(arg, "standalone");
+        const isStandalone = arg && ts7.isObjectLiteralExpression(arg) && booleanProp(arg, "standalone");
         if (isStandalone) {
           const ctrl = parseController(classInfo.decl, ctx);
           if (ctrl)
@@ -17201,16 +17774,16 @@ function collectModuleSourceClosure(module, ctx) {
     ownedFiles.add(relativeFile);
     for (const statement of sourceFile.statements) {
       let moduleName;
-      if (ts4.isImportDeclaration(statement) && ts4.isStringLiteral(statement.moduleSpecifier)) {
+      if (ts7.isImportDeclaration(statement) && ts7.isStringLiteral(statement.moduleSpecifier)) {
         moduleName = statement.moduleSpecifier.text;
-      } else if (ts4.isExportDeclaration(statement) && statement.moduleSpecifier && ts4.isStringLiteral(statement.moduleSpecifier)) {
+      } else if (ts7.isExportDeclaration(statement) && statement.moduleSpecifier && ts7.isStringLiteral(statement.moduleSpecifier)) {
         moduleName = statement.moduleSpecifier.text;
-      } else if (ts4.isImportEqualsDeclaration(statement) && ts4.isExternalModuleReference(statement.moduleReference) && ts4.isStringLiteral(statement.moduleReference.expression)) {
+      } else if (ts7.isImportEqualsDeclaration(statement) && ts7.isExternalModuleReference(statement.moduleReference) && ts7.isStringLiteral(statement.moduleReference.expression)) {
         moduleName = statement.moduleReference.expression.text;
       }
       if (!moduleName || moduleName.startsWith("node:"))
         continue;
-      const resolved = ts4.resolveModuleName(moduleName, sourceFile.fileName, ctx.program.getCompilerOptions(), ts4.sys).resolvedModule?.resolvedFileName;
+      const resolved = ts7.resolveModuleName(moduleName, sourceFile.fileName, ctx.program.getCompilerOptions(), ts7.sys).resolvedModule?.resolvedFileName;
       if (resolved && isProjectSourcePath(resolved, ctx.rootDir) && !enqueued.has(resolved)) {
         enqueued.add(resolved);
         queue.push(resolved);
@@ -17232,7 +17805,7 @@ function isProjectSourceFile(sourceFile, rootDir) {
   return isProjectSourcePath(sourceFile.fileName, rootDir) && /\.(tsx?|mts|cts)$/.test(sourceFile.fileName);
 }
 function indexFile(sf, ctx) {
-  for (const cls of sf.statements.filter(ts4.isClassDeclaration)) {
+  for (const cls of sf.statements.filter(ts7.isClassDeclaration)) {
     const name = cls.name?.text;
     if (name && !ctx.classesByName.has(name)) {
       ctx.classesByName.set(name, { name, decl: cls, file: sf.fileName });
@@ -17240,9 +17813,9 @@ function indexFile(sf, ctx) {
     if (name)
       indexInfraResource(cls, name, sf, ctx);
   }
-  for (const statement of sf.statements.filter(ts4.isVariableStatement)) {
+  for (const statement of sf.statements.filter(ts7.isVariableStatement)) {
     for (const decl of statement.declarationList.declarations) {
-      if (ts4.isIdentifier(decl.name) && !ctx.variablesByName.has(decl.name.text)) {
+      if (ts7.isIdentifier(decl.name) && !ctx.variablesByName.has(decl.name.text)) {
         ctx.variablesByName.set(decl.name.text, decl);
       }
       const info = parseTokenVariable(decl, sf.fileName);
@@ -17254,16 +17827,16 @@ function indexFile(sf, ctx) {
 }
 function parseTokenVariable(decl, file) {
   const init = decl.initializer;
-  if (!init || !ts4.isNewExpression(init))
+  if (!init || !ts7.isNewExpression(init))
     return;
   if (nodeText(init.expression) !== "InjectionToken")
     return;
   const [nameArg, optionsArg] = init.arguments ?? [];
   const info = { name: variableName(decl), file, line: lineOf(decl) };
-  if (nameArg && ts4.isStringLiteral(nameArg)) {
+  if (nameArg && ts7.isStringLiteral(nameArg)) {
     info.stringName = nameArg.text;
   }
-  if (optionsArg && ts4.isObjectLiteralExpression(optionsArg)) {
+  if (optionsArg && ts7.isObjectLiteralExpression(optionsArg)) {
     const scope = stringLiteralProp(optionsArg, "scope");
     if (scope && isScope(scope)) {
       info.scope = scope;
@@ -17283,23 +17856,23 @@ function parseModule(candidate, nameByNode, ctx) {
   const { options, className, file, line } = candidate;
   const name = nameByNode.get(candidate.node) ?? className;
   const featureSpec = parseFeatureSpec(getProp(options, "spec"), ctx);
-  const tags = arrayProp(options, "tags").map((el) => ts4.isStringLiteral(el) ? el.text : nodeText(el).replace(/['"]/g, "")).filter(Boolean);
+  const tags = arrayProp(options, "tags").map((el) => ts7.isStringLiteral(el) ? el.text : nodeText(el).replace(/['"]/g, "")).filter(Boolean);
   const aspects = parseAspectRefs(getProp(options, "aspects"), ctx, `module ${name}`);
   const moduleResourceNames = parseModuleInfraResources(infraResourceProp(options, "resources", ctx), ctx, `module ${name}`, sourcePath(ctx.rootDir, file), line);
   const imports = arrayProp(options, "imports").map((el) => {
     const unwrapped = unwrapForwardRef(el);
-    const decl = ts4.isIdentifier(unwrapped) ? resolveDeclaration(unwrapped, ctx)[0] : undefined;
+    const decl = ts7.isIdentifier(unwrapped) ? resolveDeclaration(unwrapped, ctx)[0] : undefined;
     if (decl) {
       const known = nameByNode.get(decl);
       if (known)
         return known;
-      if (ts4.isClassDeclaration(decl)) {
+      if (ts7.isClassDeclaration(decl)) {
         const dec = findDecorator(decl, "Module");
         const decOptions = dec && decoratorObjectArg(dec);
         const decName = decOptions && stringLiteralProp(decOptions, "name");
         return decName ?? decl.name?.text ?? nodeText(el);
       }
-      if (ts4.isVariableDeclaration(decl))
+      if (ts7.isVariableDeclaration(decl))
         return variableName(decl);
     }
     return nodeText(el);
@@ -17313,7 +17886,7 @@ function parseModule(candidate, nameByNode, ctx) {
       providers.push(...parsedProviders);
       continue;
     }
-    if (ts4.isCallExpression(el)) {
+    if (ts7.isCallExpression(el)) {
       const helper = nodeText(el.expression).split(".").pop() ?? nodeText(el.expression);
       warn(ctx, "unsupported-provider-helper", `无法静态展开 provider helper '${helper}'；请改用显式 Provider 或实现编译器支持的 helper`, sourcePath(ctx.rootDir, el.getSourceFile().fileName), lineOf(el));
       continue;
@@ -17323,10 +17896,10 @@ function parseModule(candidate, nameByNode, ctx) {
       providers.push(provider);
   }
   for (const el of arrayProp(options, "jobs")) {
-    if (!ts4.isIdentifier(el))
+    if (!ts7.isIdentifier(el))
       continue;
     const decl = resolveDeclaration(el, ctx)[0];
-    if (!decl || !ts4.isClassDeclaration(decl))
+    if (!decl || !ts7.isClassDeclaration(decl))
       continue;
     const className = decl.name?.text ?? el.text;
     const registeredProvider = providers.find((provider) => provider.token === className || provider.useClass === className);
@@ -17348,6 +17921,7 @@ function parseModule(candidate, nameByNode, ctx) {
       ...deps.hostDeps.length > 0 ? { hostDeps: deps.hostDeps } : {},
       ...deps.functionalInjects.length > 0 ? { functionalInjects: deps.functionalInjects } : {},
       ...hasDestroyHook(decl) ? { hasOnDestroy: true } : {},
+      ...hasInitHook(decl) ? { hasOnInit: true } : {},
       exported: exportsSet.has(className),
       file: sourcePath(ctx.rootDir, decl.getSourceFile().fileName),
       line: lineOf(decl),
@@ -17363,18 +17937,18 @@ function parseModule(candidate, nameByNode, ctx) {
   const handlerClasses = [];
   const seenHandlers = new Set;
   const collectHandler = (expr) => {
-    if (!ts4.isIdentifier(expr))
+    if (!ts7.isIdentifier(expr))
       return;
     const decl = resolveDeclaration(expr, ctx)[0];
-    if (decl && ts4.isClassDeclaration(decl) && !seenHandlers.has(decl.name?.text ?? "")) {
+    if (decl && ts7.isClassDeclaration(decl) && !seenHandlers.has(decl.name?.text ?? "")) {
       seenHandlers.add(decl.name?.text ?? "");
       handlerClasses.push(decl);
     }
   };
   for (const el of arrayProp(options, "providers")) {
-    if (ts4.isIdentifier(el))
+    if (ts7.isIdentifier(el))
       collectHandler(el);
-    if (ts4.isObjectLiteralExpression(el)) {
+    if (ts7.isObjectLiteralExpression(el)) {
       const useClass = getProp(el, "useClass");
       if (useClass)
         collectHandler(useClass);
@@ -17483,17 +18057,17 @@ function parseFeatureSpec(input, ctx, seen = new Set) {
   if (seen.has(input))
     return;
   seen.add(input);
-  if (ts4.isIdentifier(input)) {
-    const local = input.getSourceFile().statements.flatMap((statement) => ts4.isVariableStatement(statement) ? [...statement.declarationList.declarations] : []);
+  if (ts7.isIdentifier(input)) {
+    const local = input.getSourceFile().statements.flatMap((statement) => ts7.isVariableStatement(statement) ? [...statement.declarationList.declarations] : []);
     const resolved = resolveDeclaration(input, ctx)[0];
-    const decl = (resolved && ts4.isVariableDeclaration(resolved) ? resolved : undefined) ?? ctx.variablesByName.get(input.text) ?? local.find((candidate) => ts4.isIdentifier(candidate.name) && candidate.name.text === input.text) ?? descendantsOfKind(input.getSourceFile(), ts4.isVariableDeclaration).find((candidate) => ts4.isIdentifier(candidate.name) && candidate.name.text === input.text);
-    if (decl && ts4.isVariableDeclaration(decl))
+    const decl = (resolved && ts7.isVariableDeclaration(resolved) ? resolved : undefined) ?? ctx.variablesByName.get(input.text) ?? local.find((candidate) => ts7.isIdentifier(candidate.name) && candidate.name.text === input.text) ?? descendantsOfKind(input.getSourceFile(), ts7.isVariableDeclaration).find((candidate) => ts7.isIdentifier(candidate.name) && candidate.name.text === input.text);
+    if (decl && ts7.isVariableDeclaration(decl))
       return parseFeatureSpec(decl.initializer, ctx, seen);
   }
-  if (ts4.isCallExpression(input) && nodeText(input.expression) === "defineFeatureSpec") {
+  if (ts7.isCallExpression(input) && nodeText(input.expression) === "defineFeatureSpec") {
     return parseFeatureSpec(input.arguments[0], ctx, seen);
   }
-  if (ts4.isAsExpression(input) || ts4.isSatisfiesExpression(input) || ts4.isParenthesizedExpression(input)) {
+  if (ts7.isAsExpression(input) || ts7.isSatisfiesExpression(input) || ts7.isParenthesizedExpression(input)) {
     return parseFeatureSpec(input.expression, ctx, seen);
   }
   const invalid = () => {
@@ -17506,28 +18080,28 @@ function parseFeatureSpec(input, ctx, seen = new Set) {
     });
     return;
   };
-  if (!ts4.isObjectLiteralExpression(input))
+  if (!ts7.isObjectLiteralExpression(input))
     return invalid();
   const name = stringLiteralProp(input, "name");
   const statesExpr = getProp(input, "states");
   const transitionObject = getProp(input, "transitions");
-  if (!name || !statesExpr || !ts4.isArrayLiteralExpression(statesExpr) || statesExpr.elements.some((state) => !ts4.isStringLiteral(state)) || !transitionObject || !ts4.isObjectLiteralExpression(transitionObject) || input.properties.some((property) => !ts4.isPropertyAssignment(property))) {
+  if (!name || !statesExpr || !ts7.isArrayLiteralExpression(statesExpr) || statesExpr.elements.some((state) => !ts7.isStringLiteral(state)) || !transitionObject || !ts7.isObjectLiteralExpression(transitionObject) || input.properties.some((property) => !ts7.isPropertyAssignment(property))) {
     return invalid();
   }
   const states = [];
   for (const state of statesExpr.elements) {
-    if (!ts4.isStringLiteral(state))
+    if (!ts7.isStringLiteral(state))
       return invalid();
     states.push(state.text);
   }
   const transitions = [];
   for (const property of transitionObject.properties) {
-    if (!ts4.isPropertyAssignment(property) || ts4.isComputedPropertyName(property.name) || !ts4.isObjectLiteralExpression(property.initializer))
+    if (!ts7.isPropertyAssignment(property) || ts7.isComputedPropertyName(property.name) || !ts7.isObjectLiteralExpression(property.initializer))
       return invalid();
     const options = property.initializer;
     const from = stringLiteralProp(options, "from");
     const to = stringLiteralProp(options, "to");
-    if (!from || !to || options.properties.some((prop) => !ts4.isPropertyAssignment(prop)) || ["permission", "command", "route", "audit"].some((key) => getProp(options, key) && !stringLiteralProp(options, key)) || ["transaction", "idempotency"].some((key) => getProp(options, key) && !commandModeProp(options, key))) {
+    if (!from || !to || options.properties.some((prop) => !ts7.isPropertyAssignment(prop)) || ["permission", "command", "route", "audit"].some((key) => getProp(options, key) && !stringLiteralProp(options, key)) || ["transaction", "idempotency"].some((key) => getProp(options, key) && !commandModeProp(options, key))) {
       return invalid();
     }
     const permission = stringLiteralProp(options, "permission");
@@ -17554,21 +18128,21 @@ function resolveStaticObjectLiteral(input, ctx, seen = new Set) {
   if (!input || seen.has(input))
     return;
   seen.add(input);
-  if (ts4.isAsExpression(input) || ts4.isSatisfiesExpression(input) || ts4.isParenthesizedExpression(input)) {
+  if (ts7.isAsExpression(input) || ts7.isSatisfiesExpression(input) || ts7.isParenthesizedExpression(input)) {
     return resolveStaticObjectLiteral(input.expression, ctx, seen);
   }
-  if (ts4.isIdentifier(input)) {
-    const declaration = resolveDeclaration(input, ctx).find(ts4.isVariableDeclaration);
+  if (ts7.isIdentifier(input)) {
+    const declaration = resolveDeclaration(input, ctx).find(ts7.isVariableDeclaration);
     return declaration?.initializer ? resolveStaticObjectLiteral(declaration.initializer, ctx, seen) : undefined;
   }
-  if (ts4.isCallExpression(input)) {
+  if (ts7.isCallExpression(input)) {
     const expressionName = nodeText(input.expression);
     if (expressionName === "defineRouteContract" || expressionName.endsWith(".defineRouteContract")) {
       return resolveStaticObjectLiteral(input.arguments[0], ctx, seen);
     }
     return;
   }
-  return ts4.isObjectLiteralExpression(input) ? input : undefined;
+  return ts7.isObjectLiteralExpression(input) ? input : undefined;
 }
 function routePolicyProperty(object, name, ctx, seen = new Set) {
   if (seen.has(object))
@@ -17576,15 +18150,15 @@ function routePolicyProperty(object, name, ctx, seen = new Set) {
   const ancestry = new Set(seen).add(object);
   let result = { unresolved: false };
   for (const property of object.properties) {
-    if (ts4.isSpreadAssignment(property)) {
+    if (ts7.isSpreadAssignment(property)) {
       const spread = resolveStaticObjectLiteral(property.expression, ctx);
       const nested = spread ? routePolicyProperty(spread, name, ctx, ancestry) : { unresolved: true };
       if (nested.unresolved || nested.value !== undefined)
         result = nested;
-    } else if (ts4.isComputedPropertyName(property.name)) {
+    } else if (ts7.isComputedPropertyName(property.name)) {
       result = { unresolved: true };
     } else if (propertyName(property.name) === name) {
-      result = ts4.isPropertyAssignment(property) ? { value: property.initializer, unresolved: false } : { unresolved: true };
+      result = ts7.isPropertyAssignment(property) ? { value: property.initializer, unresolved: false } : { unresolved: true };
     }
   }
   return result;
@@ -17622,9 +18196,9 @@ function parseProvider(el, exportsSet, ctx) {
   const file = sourcePath(ctx.rootDir, el.getSourceFile().fileName);
   const line = lineOf(el);
   const unwrappedEl = unwrapForwardRef(el);
-  if (ts4.isIdentifier(unwrappedEl)) {
+  if (ts7.isIdentifier(unwrappedEl)) {
     const decl = resolveDeclaration(unwrappedEl, ctx)[0];
-    const cls = decl && ts4.isClassDeclaration(decl) ? decl : undefined;
+    const cls = decl && ts7.isClassDeclaration(decl) ? decl : undefined;
     const className = cls?.name?.text ?? unwrappedEl.text;
     const { deps, optionalDeps, selfDeps, skipSelfDeps, hostDeps, functionalInjects, missing } = cls ? classDeps(cls, ctx) : { deps: [], optionalDeps: [], selfDeps: [], skipSelfDeps: [], hostDeps: [], functionalInjects: [], missing: false };
     const injectable = cls ? parseInjectableOptions(cls, ctx) : undefined;
@@ -17645,13 +18219,14 @@ function parseProvider(el, exportsSet, ctx) {
       ...functionalInjects.length > 0 ? { functionalInjects } : {},
       ...injectable?.providedIn ? { providedIn: injectable.providedIn } : {},
       ...cls && hasDestroyHook(cls) ? { hasOnDestroy: true } : {},
+      ...cls && hasInitHook(cls) ? { hasOnInit: true } : {},
       exported: exportsSet.has(className),
       file,
       line,
       ...cls ? { importPath: modulePath(ctx.rootDir, cls.getSourceFile().fileName) } : {}
     };
   }
-  if (!ts4.isObjectLiteralExpression(el))
+  if (!ts7.isObjectLiteralExpression(el))
     return;
   const provideExpr = getProp(el, "provide");
   if (!provideExpr)
@@ -17666,8 +18241,8 @@ function parseProvider(el, exportsSet, ctx) {
   const useExistingExpr = getProp(el, "useExisting");
   if (useClassExpr) {
     const unwrappedClass = unwrapForwardRef(useClassExpr);
-    const decl = ts4.isIdentifier(unwrappedClass) ? resolveDeclaration(unwrappedClass, ctx)[0] : undefined;
-    const cls = decl && ts4.isClassDeclaration(decl) ? decl : undefined;
+    const decl = ts7.isIdentifier(unwrappedClass) ? resolveDeclaration(unwrappedClass, ctx)[0] : undefined;
+    const cls = decl && ts7.isClassDeclaration(decl) ? decl : undefined;
     const useClass = cls?.name?.text ?? nodeText(unwrappedClass);
     let deps = explicitDeps;
     let optionalDeps = [];
@@ -17715,6 +18290,7 @@ function parseProvider(el, exportsSet, ctx) {
       ...multi === undefined ? {} : { multi },
       ...injectable?.providedIn ? { providedIn: injectable.providedIn } : {},
       ...cls && hasMethod(cls, "onDestroy") ? { hasOnDestroy: true } : {},
+      ...cls && hasInitHook(cls) ? { hasOnInit: true } : {},
       exported: exportsSet.has(token),
       file,
       line,
@@ -17723,7 +18299,7 @@ function parseProvider(el, exportsSet, ctx) {
   }
   if (useValueExpr) {
     validateProviderCompatibility(provideExpr, useValueExpr, "value", token, ctx, file, line);
-    const importPath = ts4.isIdentifier(useValueExpr) ? importPathOf(useValueExpr, ctx) : undefined;
+    const importPath = ts7.isIdentifier(useValueExpr) ? importPathOf(useValueExpr, ctx) : undefined;
     return {
       token,
       tokenKind,
@@ -17739,12 +18315,12 @@ function parseProvider(el, exportsSet, ctx) {
     };
   }
   if (useFactoryExpr) {
-    const factoryName = ts4.isIdentifier(useFactoryExpr) ? (() => {
+    const factoryName = ts7.isIdentifier(useFactoryExpr) ? (() => {
       const decl = resolveDeclaration(useFactoryExpr, ctx)[0];
-      return decl && (ts4.isFunctionDeclaration(decl) || ts4.isVariableDeclaration(decl)) ? (ts4.isFunctionDeclaration(decl) ? decl.name?.text : variableName(decl)) ?? useFactoryExpr.text : useFactoryExpr.text;
+      return decl && (ts7.isFunctionDeclaration(decl) || ts7.isVariableDeclaration(decl)) ? (ts7.isFunctionDeclaration(decl) ? decl.name?.text : variableName(decl)) ?? useFactoryExpr.text : useFactoryExpr.text;
     })() : nodeText(useFactoryExpr);
     validateProviderCompatibility(provideExpr, useFactoryExpr, "factory", token, ctx, file, line);
-    const importPath = ts4.isIdentifier(useFactoryExpr) ? importPathOf(useFactoryExpr, ctx) : undefined;
+    const importPath = ts7.isIdentifier(useFactoryExpr) ? importPathOf(useFactoryExpr, ctx) : undefined;
     return {
       token,
       tokenKind,
@@ -17780,20 +18356,20 @@ function parseProvider(el, exportsSet, ctx) {
 function expandProviderExpressions(expressions, ctx, seen = new Set) {
   const result = [];
   for (const expression of expressions) {
-    if (ts4.isSpreadElement(expression)) {
+    if (ts7.isSpreadElement(expression)) {
       result.push(...expandProviderExpressions([expression.expression], ctx, seen));
       continue;
     }
-    if (ts4.isIdentifier(expression)) {
+    if (ts7.isIdentifier(expression)) {
       const declaration = resolveDeclaration(expression, ctx)[0];
-      if (declaration && ts4.isVariableDeclaration(declaration) && declaration.initializer) {
+      if (declaration && ts7.isVariableDeclaration(declaration) && declaration.initializer) {
         const key = `${declaration.getSourceFile().fileName}:${declaration.pos}`;
         if (seen.has(key))
           continue;
         const initializer = declaration.initializer;
-        if (ts4.isCallExpression(initializer) && isProviderHelper(initializer, "makeEnvironmentProviders")) {
+        if (ts7.isCallExpression(initializer) && isProviderHelper(initializer, "makeEnvironmentProviders")) {
           const nested = initializer.arguments[0];
-          if (nested && ts4.isArrayLiteralExpression(nested)) {
+          if (nested && ts7.isArrayLiteralExpression(nested)) {
             seen.add(key);
             result.push(...expandProviderExpressions([...nested.elements], ctx, seen));
             seen.delete(key);
@@ -17802,9 +18378,9 @@ function expandProviderExpressions(expressions, ctx, seen = new Set) {
         }
       }
     }
-    if (ts4.isCallExpression(expression) && isProviderHelper(expression, "makeEnvironmentProviders")) {
+    if (ts7.isCallExpression(expression) && isProviderHelper(expression, "makeEnvironmentProviders")) {
       const nested = expression.arguments[0];
-      if (nested && ts4.isArrayLiteralExpression(nested)) {
+      if (nested && ts7.isArrayLiteralExpression(nested)) {
         result.push(...expandProviderExpressions([...nested.elements], ctx, seen));
         continue;
       }
@@ -17817,7 +18393,7 @@ function isProviderHelper(expression, name) {
   return nodeText(expression.expression).split(".").pop() === name;
 }
 function parseFunctionalProvider(expression, exportsSet, ctx) {
-  if (!ts4.isCallExpression(expression))
+  if (!ts7.isCallExpression(expression))
     return;
   const helper = nodeText(expression.expression).split(".").pop();
   const args = expression.arguments;
@@ -17830,7 +18406,7 @@ function parseFunctionalProvider(expression, exportsSet, ctx) {
       return [];
     const { name: token, kind: tokenKind } = tokenNameOf(tokenExpr, ctx);
     validateProviderCompatibility(tokenExpr, valueExpr, "value", token, ctx, file, line);
-    const importPath = ts4.isIdentifier(valueExpr) ? importPathOf(valueExpr, ctx) : undefined;
+    const importPath = ts7.isIdentifier(valueExpr) ? importPathOf(valueExpr, ctx) : undefined;
     return [{
       token,
       tokenKind,
@@ -17849,7 +18425,7 @@ function parseFunctionalProvider(expression, exportsSet, ctx) {
     if (!initializer)
       return [];
     const token = helper === "provideAppInitializer" ? "APP_INITIALIZER" : "ENVIRONMENT_INITIALIZER";
-    const importPath = ts4.isIdentifier(initializer) ? importPathOf(initializer, ctx) : undefined;
+    const importPath = ts7.isIdentifier(initializer) ? importPathOf(initializer, ctx) : undefined;
     return [{
       token,
       tokenKind: "injection-token",
@@ -17868,7 +18444,7 @@ function parseFunctionalProvider(expression, exportsSet, ctx) {
     const providers = [];
     const routes = args[0];
     if (routes) {
-      const importPath = ts4.isIdentifier(routes) ? importPathOf(routes, ctx) : undefined;
+      const importPath = ts7.isIdentifier(routes) ? importPathOf(routes, ctx) : undefined;
       providers.push({
         token: "ROUTE_CONFIG",
         tokenKind: "injection-token",
@@ -17883,7 +18459,7 @@ function parseFunctionalProvider(expression, exportsSet, ctx) {
       });
     }
     for (const feature of args.slice(1)) {
-      if (!ts4.isCallExpression(feature))
+      if (!ts7.isCallExpression(feature))
         continue;
       const featureName = nodeText(feature.expression).split(".").pop();
       if (featureName === "withRouterConfig" && feature.arguments[0]) {
@@ -17900,8 +18476,8 @@ function parseFunctionalProvider(expression, exportsSet, ctx) {
         });
       } else if (featureName === "withTitleStrategy" && feature.arguments[0]) {
         const strategy = feature.arguments[0];
-        const isClass = ts4.isIdentifier(strategy) && Boolean(resolveDeclaration(strategy, ctx).find((declaration) => ts4.isClassDeclaration(declaration)));
-        const importPath = ts4.isIdentifier(strategy) ? importPathOf(strategy, ctx) : undefined;
+        const isClass = ts7.isIdentifier(strategy) && Boolean(resolveDeclaration(strategy, ctx).find((declaration) => ts7.isClassDeclaration(declaration)));
+        const importPath = ts7.isIdentifier(strategy) ? importPathOf(strategy, ctx) : undefined;
         providers.push({
           token: "TITLE_STRATEGY",
           tokenKind: "injection-token",
@@ -17933,14 +18509,14 @@ function parseFunctionalProvider(expression, exportsSet, ctx) {
       importModule: "@supacloud/app"
     }];
     for (const feature of args) {
-      if (!ts4.isCallExpression(feature))
+      if (!ts7.isCallExpression(feature))
         continue;
       const featureName = nodeText(feature.expression).split(".").pop();
       if (featureName === "withInterceptors") {
         for (const interceptorArg of feature.arguments) {
-          const values = ts4.isArrayLiteralExpression(interceptorArg) ? [...interceptorArg.elements] : [interceptorArg];
+          const values = ts7.isArrayLiteralExpression(interceptorArg) ? [...interceptorArg.elements] : [interceptorArg];
           for (const value of values) {
-            const importPath = ts4.isIdentifier(value) ? importPathOf(value, ctx) : undefined;
+            const importPath = ts7.isIdentifier(value) ? importPathOf(value, ctx) : undefined;
             providers.push({
               token: "HTTP_INTERCEPTORS",
               tokenKind: "injection-token",
@@ -17987,9 +18563,9 @@ function providerTokenValueType(expr, ctx) {
   const typeArguments = typeArgumentsOf(type, ctx);
   if (typeArguments.length > 0)
     return typeArguments[0];
-  if (ts4.isIdentifier(expr)) {
+  if (ts7.isIdentifier(expr)) {
     const declaration = resolveDeclaration(expr, ctx)[0];
-    if (declaration && ts4.isClassDeclaration(declaration)) {
+    if (declaration && ts7.isClassDeclaration(declaration)) {
       return declaredClassType(declaration, ctx);
     }
   }
@@ -17997,9 +18573,9 @@ function providerTokenValueType(expr, ctx) {
 }
 function providerImplementationType(expr, kind, ctx) {
   if (kind === "class" || kind === "existing") {
-    if (ts4.isIdentifier(expr)) {
+    if (ts7.isIdentifier(expr)) {
       const declaration = resolveDeclaration(expr, ctx)[0];
-      if (declaration && ts4.isClassDeclaration(declaration)) {
+      if (declaration && ts7.isClassDeclaration(declaration)) {
         return declaredClassType(declaration, ctx);
       }
     }
@@ -18009,7 +18585,7 @@ function providerImplementationType(expr, kind, ctx) {
   }
   if (kind === "factory") {
     const type = ctx.checker.getTypeAtLocation(expr);
-    const signature = ctx.checker.getSignaturesOfType(type, ts4.SignatureKind.Call)[0];
+    const signature = ctx.checker.getSignaturesOfType(type, ts7.SignatureKind.Call)[0];
     return signature?.getReturnType();
   }
   return ctx.checker.getTypeAtLocation(expr);
@@ -18028,16 +18604,16 @@ function isTypeReference(type) {
   return "target" in type;
 }
 function isUnknownOrAny(type) {
-  return (type.flags & (ts4.TypeFlags.Any | ts4.TypeFlags.Unknown)) !== 0;
+  return (type.flags & (ts7.TypeFlags.Any | ts7.TypeFlags.Unknown)) !== 0;
 }
 function parseController(input, ctx) {
   let decl;
-  if (ts4.isClassDeclaration(input)) {
+  if (ts7.isClassDeclaration(input)) {
     decl = input;
   } else {
     const unwrapped = unwrapForwardRef(input);
-    const resolved = ts4.isIdentifier(unwrapped) ? resolveDeclaration(unwrapped, ctx)[0] : undefined;
-    if (resolved && ts4.isClassDeclaration(resolved)) {
+    const resolved = ts7.isIdentifier(unwrapped) ? resolveDeclaration(unwrapped, ctx)[0] : undefined;
+    if (resolved && ts7.isClassDeclaration(resolved)) {
       decl = resolved;
     }
   }
@@ -18050,9 +18626,9 @@ function parseController(input, ctx) {
   let standalone;
   const pathArg = decoratorArguments(controllerDec)[0];
   if (pathArg) {
-    if (ts4.isStringLiteral(pathArg)) {
+    if (ts7.isStringLiteral(pathArg)) {
       path = pathArg.text;
-    } else if (ts4.isObjectLiteralExpression(pathArg)) {
+    } else if (ts7.isObjectLiteralExpression(pathArg)) {
       const p = stringLiteralProp(pathArg, "path");
       if (p)
         path = p;
@@ -18075,7 +18651,7 @@ function parseController(input, ctx) {
       }
     }
   }
-  for (const method of decl.members.filter(ts4.isMethodDeclaration)) {
+  for (const method of decl.members.filter(ts7.isMethodDeclaration)) {
     for (const dec of decoratorsOf(method)) {
       const name = decoratorName2(dec);
       const httpMethod = name ? ROUTE_DECORATORS[name] : undefined;
@@ -18083,7 +18659,7 @@ function parseController(input, ctx) {
         continue;
       const args = decoratorArguments(dec);
       const pathArg = args[0];
-      const routePath = pathArg && ts4.isStringLiteral(pathArg) ? pathArg.text : "/";
+      const routePath = pathArg && ts7.isStringLiteral(pathArg) ? pathArg.text : "/";
       const route = {
         method: httpMethod,
         path: routePath,
@@ -18157,12 +18733,12 @@ function parseController(input, ctx) {
           } else if (dName === "Headers") {
             hasBindingDecorator = true;
             const argument = dArgs[0];
-            const bindingName = argument !== undefined && ts4.isStringLiteral(argument) ? argument.text : undefined;
+            const bindingName = argument !== undefined && ts7.isStringLiteral(argument) ? argument.text : undefined;
             paramNode = { name: pName, kind: "headers", ...bindingName === undefined ? {} : { bindingName } };
           } else if (dName === "Cookie") {
             hasBindingDecorator = true;
             const argument = dArgs[0];
-            const bindingName = argument !== undefined && ts4.isStringLiteral(argument) ? argument.text : undefined;
+            const bindingName = argument !== undefined && ts7.isStringLiteral(argument) ? argument.text : undefined;
             paramNode = { name: pName, kind: "cookie", ...bindingName === undefined ? {} : { bindingName } };
           }
         }
@@ -18224,20 +18800,20 @@ function parseController(input, ctx) {
           }
         } else if (dName === "Title") {
           const tArg = mArgs[0];
-          if (tArg && ts4.isStringLiteral(tArg)) {
+          if (tArg && ts7.isStringLiteral(tArg)) {
             route.title = tArg.text;
           }
         } else if (dName === "Data") {
           const dArg = mArgs[0];
-          if (dArg && ts4.isObjectLiteralExpression(dArg)) {
+          if (dArg && ts7.isObjectLiteralExpression(dArg)) {
             route.data = { ...route.data, ...parseObjectLiteralValues(dArg) };
           }
         } else if (dName === "Resolve") {
           const rArg = mArgs[0];
-          if (rArg && ts4.isObjectLiteralExpression(rArg)) {
+          if (rArg && ts7.isObjectLiteralExpression(rArg)) {
             const resolvers = route.resolvers ?? {};
             for (const prop of rArg.properties) {
-              if (ts4.isPropertyAssignment(prop)) {
+              if (ts7.isPropertyAssignment(prop)) {
                 const rName = propertyName(prop.name);
                 const init = prop.initializer;
                 if (init)
@@ -18265,7 +18841,7 @@ function parseController(input, ctx) {
         }
         const parse = parsePolicy.value;
         if (parse) {
-          if (ts4.isStringLiteral(parse) && parse.text === "none")
+          if (ts7.isStringLiteral(parse) && parse.text === "none")
             route.parse = "none";
           else
             ctx.diagnostics.push({
@@ -18277,7 +18853,7 @@ function parseController(input, ctx) {
         }
         const allowDeleteBody = deletePolicy.value;
         if (allowDeleteBody) {
-          if (allowDeleteBody.kind === ts4.SyntaxKind.TrueKeyword)
+          if (allowDeleteBody.kind === ts7.SyntaxKind.TrueKeyword)
             route.allowDeleteBody = true;
           else
             ctx.diagnostics.push({
@@ -18302,7 +18878,7 @@ function parseController(input, ctx) {
           });
         }
         const contract = getProp(optionsObject, "contract");
-        if (contract && ts4.isObjectLiteralExpression(contract)) {
+        if (contract && ts7.isObjectLiteralExpression(contract)) {
           route.contract = {};
           for (const field of ["body", "response", "evidence"]) {
             const value = stringLiteralProp(contract, field);
@@ -18320,7 +18896,7 @@ function parseController(input, ctx) {
         }
         for (const field of ["body", "params", "query", "headers", "cookie", "response"]) {
           const schemaExpr = getProp(optionsObject, field);
-          if (schemaExpr && ts4.isIdentifier(schemaExpr)) {
+          if (schemaExpr && ts7.isIdentifier(schemaExpr)) {
             route[field] = nodeText(schemaExpr);
             const importPath = importPathOf(schemaExpr, ctx);
             if (importPath)
@@ -18335,7 +18911,7 @@ function parseController(input, ctx) {
           const responses = {};
           const selectors = new Map;
           for (const property of responsesObject.properties) {
-            if (!ts4.isPropertyAssignment(property) || ts4.isComputedPropertyName(property.name))
+            if (!ts7.isPropertyAssignment(property) || ts7.isComputedPropertyName(property.name))
               continue;
             const status = propertyName(property.name);
             if (!isRouteResponseSelector(status)) {
@@ -18367,7 +18943,7 @@ function parseController(input, ctx) {
             }
             selectors.set(canonical, status);
             const schemaExpr = property.initializer;
-            if (!ts4.isIdentifier(schemaExpr)) {
+            if (!ts7.isIdentifier(schemaExpr)) {
               ctx.diagnostics.push({
                 severity: "error",
                 code: "invalid-route-response-map",
@@ -18389,18 +18965,18 @@ function parseController(input, ctx) {
             route.responses = responses;
         }
         const commandExpr = getProp(optionsObject, "command");
-        if (commandExpr && ts4.isIdentifier(commandExpr)) {
+        if (commandExpr && ts7.isIdentifier(commandExpr)) {
           const commandDecl = resolveDeclaration(commandExpr, ctx)[0];
-          route.command = commandDecl && ts4.isClassDeclaration(commandDecl) ? commandDecl.name?.text ?? commandExpr.text : commandExpr.text;
+          route.command = commandDecl && ts7.isClassDeclaration(commandDecl) ? commandDecl.name?.text ?? commandExpr.text : commandExpr.text;
         }
         const guardsExpr = getProp(optionsObject, "guards");
-        if (guardsExpr && ts4.isArrayLiteralExpression(guardsExpr)) {
+        if (guardsExpr && ts7.isArrayLiteralExpression(guardsExpr)) {
           for (const el of guardsExpr.elements) {
             routeGuards.push(tokenText(el, ctx));
           }
         }
         const canMatchExpr = getProp(optionsObject, "canMatch");
-        if (canMatchExpr && ts4.isArrayLiteralExpression(canMatchExpr)) {
+        if (canMatchExpr && ts7.isArrayLiteralExpression(canMatchExpr)) {
           const canMatchList = [];
           for (const el of canMatchExpr.elements) {
             canMatchList.push(tokenText(el, ctx));
@@ -18410,16 +18986,16 @@ function parseController(input, ctx) {
           }
         }
         const canDeactivateExpr = getProp(optionsObject, "canDeactivate");
-        if (canDeactivateExpr && ts4.isArrayLiteralExpression(canDeactivateExpr)) {
+        if (canDeactivateExpr && ts7.isArrayLiteralExpression(canDeactivateExpr)) {
           for (const el of canDeactivateExpr.elements) {
             routeCanDeactivate.push(tokenText(el, ctx));
           }
         }
         const resolversExpr = getProp(optionsObject, "resolvers");
-        if (resolversExpr && ts4.isObjectLiteralExpression(resolversExpr)) {
+        if (resolversExpr && ts7.isObjectLiteralExpression(resolversExpr)) {
           const resolvers = {};
           for (const prop of resolversExpr.properties) {
-            if (ts4.isPropertyAssignment(prop)) {
+            if (ts7.isPropertyAssignment(prop)) {
               const rName = propertyName(prop.name);
               const init = prop.initializer;
               if (init)
@@ -18431,22 +19007,22 @@ function parseController(input, ctx) {
           }
         }
         const redirectToExpr = getProp(optionsObject, "redirectTo");
-        if (redirectToExpr && ts4.isStringLiteral(redirectToExpr)) {
+        if (redirectToExpr && ts7.isStringLiteral(redirectToExpr)) {
           route.redirectTo = redirectToExpr.text;
         }
         const pathMatchExpr = getProp(optionsObject, "pathMatch");
-        if (pathMatchExpr && ts4.isStringLiteral(pathMatchExpr)) {
+        if (pathMatchExpr && ts7.isStringLiteral(pathMatchExpr)) {
           const val = pathMatchExpr.text;
           if (val === "full" || val === "prefix") {
             route.pathMatch = val;
           }
         }
         const titleExpr = getProp(optionsObject, "title");
-        if (titleExpr && ts4.isStringLiteral(titleExpr)) {
+        if (titleExpr && ts7.isStringLiteral(titleExpr)) {
           route.title = titleExpr.text;
         }
         const dataExpr = getProp(optionsObject, "data");
-        if (dataExpr && ts4.isObjectLiteralExpression(dataExpr)) {
+        if (dataExpr && ts7.isObjectLiteralExpression(dataExpr)) {
           route.data = { ...route.data, ...parseObjectLiteralValues(dataExpr) };
         }
         const aspects = parseAspectRefs(getProp(optionsObject, "aspects"), ctx, `route ${httpMethod} ${routePath}`);
@@ -18468,6 +19044,7 @@ function parseController(input, ctx) {
     scope: injectable?.scope ?? "request",
     deps,
     ...hasDestroyHook(decl) ? { hasOnDestroy: true } : {},
+    ...hasInitHook(decl) ? { hasOnInit: true } : {},
     ...optionalDeps.length > 0 ? { optionalDeps } : {},
     ...selfDeps.length > 0 ? { selfDeps } : {},
     ...skipSelfDeps.length > 0 ? { skipSelfDeps } : {},
@@ -18501,7 +19078,7 @@ function parseJobOptions(meta, owner, ctx) {
     const expression = getProp(meta, field);
     if (!expression)
       continue;
-    if (!ts4.isIdentifier(expression)) {
+    if (!ts7.isIdentifier(expression)) {
       jobOptionError(ctx, "invalid-job-schema", `${owner} 的 ${field} schema 必须是可静态解析的标识符引用，不能使用内联调用或动态表达式`, expression, "SC4019", `将 schema 提取为命名导出，例如 ${field}: ${field === "input" ? "JobInput" : "JobOutput"}。`);
       continue;
     }
@@ -18525,7 +19102,7 @@ function parseJobEnum(meta, field, allowed, owner, ctx, code, errorCode) {
   const expression = getProp(meta, field);
   if (!expression)
     return;
-  if (!ts4.isStringLiteral(expression) || !allowed.includes(expression.text)) {
+  if (!ts7.isStringLiteral(expression) || !allowed.includes(expression.text)) {
     jobOptionError(ctx, code, `${owner} 的 ${field} 必须是 ${allowed.map((value) => JSON.stringify(value)).join(" 或 ")} 字符串字面量`, expression, errorCode);
     return;
   }
@@ -18535,7 +19112,7 @@ function parseJobInteger(meta, field, min, max, owner, ctx, code, errorCode) {
   const expression = getProp(meta, field);
   if (!expression)
     return;
-  const value = ts4.isNumericLiteral(expression) ? Number(expression.text) : Number.NaN;
+  const value = ts7.isNumericLiteral(expression) ? Number(expression.text) : Number.NaN;
   if (!Number.isSafeInteger(value) || value < min || value > max) {
     jobOptionError(ctx, code, `${owner} 的 ${field} 必须是 ${min} 到 ${max} 之间的安全整数`, expression, errorCode);
     return;
@@ -18571,7 +19148,7 @@ function isOpaqueSchema(identifier, declaration, ctx) {
         const property = type.getProperty(kind.value === "Union" ? "anyOf" : "allOf");
         if (!property)
           return true;
-        const members = ctx.checker.getIndexTypeOfType(ctx.checker.getTypeOfSymbolAtLocation(property, identifier), ts4.IndexKind.Number);
+        const members = ctx.checker.getIndexTypeOfType(ctx.checker.getTypeOfSymbolAtLocation(property, identifier), ts7.IndexKind.Number);
         if (!members)
           return true;
         const branches = members.isUnion() ? members.types : [members];
@@ -18583,8 +19160,8 @@ function isOpaqueSchema(identifier, declaration, ctx) {
   }
   if (opaque(ctx.checker.getTypeAtLocation(identifier), new Set))
     return true;
-  const initializer = declaration && ts4.isVariableDeclaration(declaration) ? declaration.initializer : undefined;
-  return Boolean(initializer && ts4.isCallExpression(initializer) && ts4.isPropertyAccessExpression(initializer.expression) && ["Unknown", "Any"].includes(initializer.expression.name.text));
+  const initializer = declaration && ts7.isVariableDeclaration(declaration) ? declaration.initializer : undefined;
+  return Boolean(initializer && ts7.isCallExpression(initializer) && ts7.isPropertyAccessExpression(initializer.expression) && ["Unknown", "Any"].includes(initializer.expression.name.text));
 }
 function checkedRpc(meta, ctx) {
   const expression = getProp(meta, "rpc");
@@ -18605,7 +19182,7 @@ function checkedRpc(meta, ctx) {
 }
 function classDeps(cls, ctx) {
   const injectable = parseInjectableOptions(cls, ctx);
-  const ctor = cls.members.find(ts4.isConstructorDeclaration);
+  const ctor = cls.members.find(ts7.isConstructorDeclaration);
   const deps = injectable?.deps ? [...injectable.deps] : [];
   const optionalDeps = [];
   const selfDeps = [];
@@ -18639,23 +19216,23 @@ function classDeps(cls, ctx) {
       }
     });
   }
-  for (const prop of cls.members.filter(ts4.isPropertyDeclaration)) {
+  for (const prop of cls.members.filter(ts7.isPropertyDeclaration)) {
     const init = prop.initializer;
-    if (init && ts4.isCallExpression(init)) {
+    if (init && ts7.isCallExpression(init)) {
       const callName = nodeText(init.expression).split(".").pop();
       if (callName === "inject") {
         const [tokenArg, optionsArg] = init.arguments;
         if (tokenArg) {
           const tokenName = tokenText(tokenArg, ctx);
           const unwrappedToken = unwrapForwardRef(tokenArg);
-          const known = ts4.isStringLiteral(unwrappedToken) || ts4.isIdentifier(unwrappedToken) && (ctx.tokensByName.has(tokenName) || ctx.classesByName.has(tokenName));
+          const known = ts7.isStringLiteral(unwrappedToken) || ts7.isIdentifier(unwrappedToken) && (ctx.tokensByName.has(tokenName) || ctx.classesByName.has(tokenName));
           if (!known) {
             missing = true;
             continue;
           }
           if (!deps.includes(tokenName))
             deps.push(tokenName);
-          const options = optionsArg && ts4.isObjectLiteralExpression(optionsArg) ? {
+          const options = optionsArg && ts7.isObjectLiteralExpression(optionsArg) ? {
             optional: booleanProp(optionsArg, "optional") ?? false,
             self: booleanProp(optionsArg, "self") ?? false,
             skipSelf: booleanProp(optionsArg, "skipSelf") ?? false,
@@ -18670,9 +19247,9 @@ function classDeps(cls, ctx) {
           if (options.host && !hostDeps.includes(tokenName))
             hostDeps.push(tokenName);
           if (!functionalInjects.some((entry) => entry.token === tokenName)) {
-            const declaration = ts4.isIdentifier(unwrappedToken) ? resolveDeclaration(unwrappedToken, ctx)[0] : undefined;
+            const declaration = ts7.isIdentifier(unwrappedToken) ? resolveDeclaration(unwrappedToken, ctx)[0] : undefined;
             const localFile = declaration && isProjectSourcePath(declaration.getSourceFile().fileName, ctx.rootDir) ? declaration.getSourceFile().fileName : undefined;
-            const importModule = declaration && !localFile && ts4.isIdentifier(unwrappedToken) ? importModuleOf(unwrappedToken, ctx) : undefined;
+            const importModule = declaration && !localFile && ts7.isIdentifier(unwrappedToken) ? importModuleOf(unwrappedToken, ctx) : undefined;
             functionalInjects.push({
               token: tokenName,
               expression: nodeText(unwrappedToken),
@@ -18716,7 +19293,7 @@ function parseInjectableOptions(cls, ctx) {
 }
 function parseInjectParams(cls, ctx) {
   const result = new Map;
-  const ctor = cls.members.find(ts4.isConstructorDeclaration);
+  const ctor = cls.members.find(ts7.isConstructorDeclaration);
   if (!ctor)
     return result;
   ctor.parameters.forEach((param, index) => {
@@ -18732,7 +19309,7 @@ function parseInjectParams(cls, ctx) {
 }
 function parseOptionalParams(cls) {
   const result = new Set;
-  const ctor = cls.members.find(ts4.isConstructorDeclaration);
+  const ctor = cls.members.find(ts7.isConstructorDeclaration);
   if (!ctor)
     return result;
   ctor.parameters.forEach((param, index) => {
@@ -18747,7 +19324,7 @@ function parseOptionalParams(cls) {
 }
 function parseModifierParams(cls, modifierName) {
   const result = new Set;
-  const ctor = cls.members.find(ts4.isConstructorDeclaration);
+  const ctor = cls.members.find(ts7.isConstructorDeclaration);
   if (!ctor)
     return result;
   ctor.parameters.forEach((param, index) => {
@@ -18759,13 +19336,13 @@ function parseModifierParams(cls, modifierName) {
   return result;
 }
 function unwrapForwardRef(expr) {
-  if (ts4.isCallExpression(expr)) {
+  if (ts7.isCallExpression(expr)) {
     const exprText = nodeText(expr.expression);
     if (exprText === "forwardRef" || exprText.endsWith(".forwardRef")) {
       const arg = expr.arguments[0];
-      if (arg && (ts4.isArrowFunction(arg) || ts4.isFunctionExpression(arg))) {
+      if (arg && (ts7.isArrowFunction(arg) || ts7.isFunctionExpression(arg))) {
         const body = arg.body;
-        if (body && ts4.isExpression(body)) {
+        if (body && ts7.isExpression(body)) {
           return unwrapForwardRef(body);
         }
       }
@@ -18775,13 +19352,13 @@ function unwrapForwardRef(expr) {
 }
 function tokenText(expr, ctx) {
   const unwrapped = unwrapForwardRef(expr);
-  if (ts4.isStringLiteral(unwrapped))
+  if (ts7.isStringLiteral(unwrapped))
     return unwrapped.text;
-  if (ts4.isIdentifier(unwrapped)) {
+  if (ts7.isIdentifier(unwrapped)) {
     const decl = resolveDeclaration(unwrapped, ctx)[0];
-    if (decl && ts4.isClassDeclaration(decl))
+    if (decl && ts7.isClassDeclaration(decl))
       return decl.name?.text ?? unwrapped.text;
-    if (decl && ts4.isVariableDeclaration(decl))
+    if (decl && ts7.isVariableDeclaration(decl))
       return variableName(decl);
   }
   return nodeText(unwrapped);
@@ -18801,12 +19378,12 @@ function resolveScope(input, ctx) {
 }
 function tokenNameOf(expr, ctx) {
   const unwrapped = unwrapForwardRef(expr);
-  if (ts4.isIdentifier(unwrapped)) {
+  if (ts7.isIdentifier(unwrapped)) {
     const decl = resolveDeclaration(unwrapped, ctx)[0];
-    if (decl && ts4.isClassDeclaration(decl)) {
+    if (decl && ts7.isClassDeclaration(decl)) {
       return { name: decl.name?.text ?? nodeText(expr), kind: "class" };
     }
-    if (decl && ts4.isVariableDeclaration(decl)) {
+    if (decl && ts7.isVariableDeclaration(decl)) {
       const name = variableName(decl);
       return { name, kind: ctx.tokensByName.has(name) ? "injection-token" : "class" };
     }
@@ -18822,10 +19399,10 @@ function resolveDeclaration(id, ctx) {
     return [];
   let declarations = symbol.declarations ?? [];
   for (let guard = 0;guard < 4; guard += 1) {
-    const isAlias = declarations.some((d) => ts4.isImportSpecifier(d) || ts4.isImportClause(d) || ts4.isNamespaceImport(d));
+    const isAlias = declarations.some((d) => ts7.isImportSpecifier(d) || ts7.isImportClause(d) || ts7.isNamespaceImport(d));
     if (!isAlias)
       break;
-    if (!(symbol.flags & ts4.SymbolFlags.Alias))
+    if (!(symbol.flags & ts7.SymbolFlags.Alias))
       break;
     const aliased = ctx.checker.getAliasedSymbol(symbol);
     symbol = aliased;
@@ -18845,9 +19422,9 @@ function importModuleOf(id, ctx) {
   for (const declaration of declarations) {
     let current = declaration;
     while (current) {
-      if (ts4.isImportDeclaration(current)) {
+      if (ts7.isImportDeclaration(current)) {
         const moduleSpecifier = current.moduleSpecifier;
-        return ts4.isStringLiteral(moduleSpecifier) ? moduleSpecifier.text : undefined;
+        return ts7.isStringLiteral(moduleSpecifier) ? moduleSpecifier.text : undefined;
       }
       current = current.parent;
     }
@@ -18859,27 +19436,27 @@ function findDecorator(cls, name) {
 }
 function decoratorName2(dec) {
   const expr = dec.expression;
-  if (ts4.isCallExpression(expr)) {
+  if (ts7.isCallExpression(expr)) {
     return nodeText(expr.expression).split(".").pop();
   }
-  if (ts4.isIdentifier(expr))
+  if (ts7.isIdentifier(expr))
     return expr.text;
   return;
 }
 function decoratorObjectArg(dec) {
   const expr = dec.expression;
-  if (!ts4.isCallExpression(expr))
+  if (!ts7.isCallExpression(expr))
     return;
   const arg = expr.arguments[0];
-  return arg && ts4.isObjectLiteralExpression(arg) ? arg : undefined;
+  return arg && ts7.isObjectLiteralExpression(arg) ? arg : undefined;
 }
 function getProp(obj, name) {
-  const prop = obj.properties.find((item) => (ts4.isPropertyAssignment(item) || ts4.isShorthandPropertyAssignment(item)) && propertyName(item.name) === name);
+  const prop = obj.properties.find((item) => (ts7.isPropertyAssignment(item) || ts7.isShorthandPropertyAssignment(item)) && propertyName(item.name) === name);
   if (!prop)
     return;
-  if (ts4.isPropertyAssignment(prop))
+  if (ts7.isPropertyAssignment(prop))
     return prop.initializer;
-  if (ts4.isShorthandPropertyAssignment(prop))
+  if (ts7.isShorthandPropertyAssignment(prop))
     return prop.name;
   return;
 }
@@ -18887,10 +19464,10 @@ function toCompilerDiagnostic(diagnostic, rootDir) {
   const file = diagnostic.file;
   const position = file && diagnostic.start !== undefined ? file.getLineAndCharacterOfPosition(diagnostic.start) : undefined;
   return {
-    severity: diagnostic.category === ts4.DiagnosticCategory.Error ? "error" : "warn",
+    severity: diagnostic.category === ts7.DiagnosticCategory.Error ? "error" : "warn",
     code: `typescript-${diagnostic.code}`,
     errorCode: `TS${diagnostic.code}`,
-    message: ts4.flattenDiagnosticMessageText(diagnostic.messageText, `
+    message: ts7.flattenDiagnosticMessageText(diagnostic.messageText, `
 `),
     ...file ? { file: sourcePath(rootDir, file.fileName) } : {},
     ...position ? { line: position.line + 1 } : {}
@@ -18898,16 +19475,16 @@ function toCompilerDiagnostic(diagnostic, rootDir) {
 }
 function stringLiteralProp(obj, name) {
   const expr = getProp(obj, name);
-  return expr && ts4.isStringLiteral(expr) ? expr.text : undefined;
+  return expr && ts7.isStringLiteral(expr) ? expr.text : undefined;
 }
 function arrayProp(obj, name) {
   const expr = getProp(obj, name);
-  return expr && ts4.isArrayLiteralExpression(expr) ? [...expr.elements] : [];
+  return expr && ts7.isArrayLiteralExpression(expr) ? [...expr.elements] : [];
 }
 function parseAspectRefs(expression, ctx, owner) {
   if (!expression)
     return [];
-  if (!ts4.isArrayLiteralExpression(expression)) {
+  if (!ts7.isArrayLiteralExpression(expression)) {
     ctx.diagnostics.push({
       severity: "error",
       code: "dynamic-aspect-reference",
@@ -18922,7 +19499,7 @@ function parseAspectRefs(expression, ctx, owner) {
   }
   const refs = [];
   for (const element of expression.elements) {
-    if (ts4.isSpreadElement(element) || !ts4.isIdentifier(element)) {
+    if (ts7.isSpreadElement(element) || !ts7.isIdentifier(element)) {
       ctx.diagnostics.push({
         severity: "error",
         code: "dynamic-aspect-reference",
@@ -18935,7 +19512,7 @@ function parseAspectRefs(expression, ctx, owner) {
       });
       continue;
     }
-    const declaration = resolveDeclaration(element, ctx).find((candidate) => ts4.isFunctionDeclaration(candidate) || ts4.isVariableDeclaration(candidate) && candidate.initializer !== undefined && (ts4.isArrowFunction(candidate.initializer) || ts4.isFunctionExpression(candidate.initializer)));
+    const declaration = resolveDeclaration(element, ctx).find((candidate) => ts7.isFunctionDeclaration(candidate) || ts7.isVariableDeclaration(candidate) && candidate.initializer !== undefined && (ts7.isArrowFunction(candidate.initializer) || ts7.isFunctionExpression(candidate.initializer)));
     if (!declaration) {
       ctx.diagnostics.push({
         severity: "error",
@@ -18949,7 +19526,7 @@ function parseAspectRefs(expression, ctx, owner) {
       });
       continue;
     }
-    const name = ts4.isFunctionDeclaration(declaration) ? declaration.name?.text : ts4.isVariableDeclaration(declaration) ? variableName(declaration) : undefined;
+    const name = ts7.isFunctionDeclaration(declaration) ? declaration.name?.text : ts7.isVariableDeclaration(declaration) ? variableName(declaration) : undefined;
     if (!name)
       continue;
     const declaredFile = declaration.getSourceFile().fileName;
@@ -18969,9 +19546,9 @@ function booleanProp(obj, name) {
   const expr = getProp(obj, name);
   if (!expr)
     return;
-  if (expr.kind === ts4.SyntaxKind.TrueKeyword)
+  if (expr.kind === ts7.SyntaxKind.TrueKeyword)
     return true;
-  if (expr.kind === ts4.SyntaxKind.FalseKeyword)
+  if (expr.kind === ts7.SyntaxKind.FalseKeyword)
     return false;
   return;
 }
@@ -18985,15 +19562,15 @@ function parseBindingOptions(args, defaultName) {
   let defaultValue;
   const first = args[0];
   const second = args[1];
-  if (first && ts4.isStringLiteral(first)) {
+  if (first && ts7.isStringLiteral(first)) {
     name = first.text;
-  } else if (first && ts4.isObjectLiteralExpression(first)) {
+  } else if (first && ts7.isObjectLiteralExpression(first)) {
     const nameProp = getProp(first, "name");
-    if (nameProp && ts4.isStringLiteral(nameProp)) {
+    if (nameProp && ts7.isStringLiteral(nameProp)) {
       name = nameProp.text;
     }
     const trProp = getProp(first, "transform");
-    if (trProp && ts4.isStringLiteral(trProp)) {
+    if (trProp && ts7.isStringLiteral(trProp)) {
       const val = trProp.text;
       if (val === "number" || val === "boolean" || val === "string") {
         transform = val;
@@ -19004,9 +19581,9 @@ function parseBindingOptions(args, defaultName) {
       defaultValue = parseLiteralValue(defProp);
     }
   }
-  if (second && ts4.isObjectLiteralExpression(second)) {
+  if (second && ts7.isObjectLiteralExpression(second)) {
     const trProp = getProp(second, "transform");
-    if (trProp && ts4.isStringLiteral(trProp)) {
+    if (trProp && ts7.isStringLiteral(trProp)) {
       const val = trProp.text;
       if (val === "number" || val === "boolean" || val === "string") {
         transform = val;
@@ -19020,18 +19597,18 @@ function parseBindingOptions(args, defaultName) {
   return { name, ...transform ? { transform } : {}, default: defaultValue };
 }
 function parseLiteralValue(node) {
-  if (ts4.isStringLiteral(node))
+  if (ts7.isStringLiteral(node))
     return node.text;
-  if (ts4.isNumericLiteral(node))
+  if (ts7.isNumericLiteral(node))
     return Number(node.text);
-  if (node.kind === ts4.SyntaxKind.TrueKeyword)
+  if (node.kind === ts7.SyntaxKind.TrueKeyword)
     return true;
-  if (node.kind === ts4.SyntaxKind.FalseKeyword)
+  if (node.kind === ts7.SyntaxKind.FalseKeyword)
     return false;
-  if (ts4.isArrayLiteralExpression(node)) {
+  if (ts7.isArrayLiteralExpression(node)) {
     return node.elements.map(parseLiteralValue);
   }
-  if (ts4.isObjectLiteralExpression(node)) {
+  if (ts7.isObjectLiteralExpression(node)) {
     return parseObjectLiteralValues(node);
   }
   return;
@@ -19039,7 +19616,7 @@ function parseLiteralValue(node) {
 function parseObjectLiteralValues(obj) {
   const result = {};
   for (const prop of obj.properties) {
-    if (ts4.isPropertyAssignment(prop)) {
+    if (ts7.isPropertyAssignment(prop)) {
       const name = propertyName(prop.name);
       const init = prop.initializer;
       if (init) {
@@ -19056,7 +19633,7 @@ function sourcePath(rootDir, absFile) {
   return relative2(rootDir, absFile).split(sep2).join("/");
 }
 function unwrapInfraResourceExpression(value) {
-  while (ts4.isParenthesizedExpression(value) || ts4.isAsExpression(value) || ts4.isTypeAssertionExpression(value) || ts4.isSatisfiesExpression(value) || ts4.isNonNullExpression(value)) {
+  while (ts7.isParenthesizedExpression(value) || ts7.isAsExpression(value) || ts7.isTypeAssertionExpression(value) || ts7.isSatisfiesExpression(value) || ts7.isNonNullExpression(value)) {
     value = value.expression;
   }
   return value;
@@ -19066,7 +19643,7 @@ function infraResourceProp(obj, name, ctx) {
   if (members.length === 0)
     return;
   const member = members[0];
-  if (members.length !== 1 || !ts4.isPropertyAssignment(member) || ts4.isComputedPropertyName(member.name) || obj.properties.some(ts4.isSpreadAssignment)) {
+  if (members.length !== 1 || !ts7.isPropertyAssignment(member) || ts7.isComputedPropertyName(member.name) || obj.properties.some(ts7.isSpreadAssignment)) {
     pushResourceError(ctx, "unknown-resource", `${name} 必须是唯一、显式的静态属性，且不能被对象展开覆盖`, sourcePath(ctx.rootDir, obj.getSourceFile().fileName), lineOf(member), `使用 ${name}: [...]，不要使用简写属性、计算属性或对象展开。`);
     return;
   }
@@ -19079,7 +19656,7 @@ function indexInfraResource(cls, className, sf, ctx) {
   const file = sourcePath(ctx.rootDir, sf.fileName);
   const line = lineOf(cls);
   const options = decoratorObjectArg(decorator);
-  if (!options || options.properties.some((property) => !ts4.isPropertyAssignment(property) || ts4.isComputedPropertyName(property.name)) || new Set(options.properties.map((property) => property.name && propertyName(property.name))).size !== options.properties.length) {
+  if (!options || options.properties.some((property) => !ts7.isPropertyAssignment(property) || ts7.isComputedPropertyName(property.name)) || new Set(options.properties.map((property) => property.name && propertyName(property.name))).size !== options.properties.length) {
     pushResourceError(ctx, "invalid-resource-kind", "@InfraResource 需要静态的 { name, kind } 对象参数", file, line, '使用 @InfraResource({ name: "orders-db", kind: "database" })，不要使用对象展开或重复属性。');
     return;
   }
@@ -19110,14 +19687,14 @@ function indexInfraResource(cls, className, sf, ctx) {
 }
 function resolveInfraResourceRef(el, ctx, owner, file, line) {
   const unwrapped = unwrapInfraResourceExpression(unwrapForwardRef(unwrapInfraResourceExpression(el)));
-  const identifier = ts4.isIdentifier(unwrapped) ? unwrapped : ts4.isPropertyAccessExpression(unwrapped) && ts4.isIdentifier(unwrapped.name) ? unwrapped.name : undefined;
+  const identifier = ts7.isIdentifier(unwrapped) ? unwrapped : ts7.isPropertyAccessExpression(unwrapped) && ts7.isIdentifier(unwrapped.name) ? unwrapped.name : undefined;
   let symbol = identifier ? ctx.checker.getSymbolAtLocation(identifier) : undefined;
   const visited = new Set;
-  while (symbol && symbol.flags & ts4.SymbolFlags.Alias && !visited.has(symbol)) {
+  while (symbol && symbol.flags & ts7.SymbolFlags.Alias && !visited.has(symbol)) {
     visited.add(symbol);
     symbol = ctx.checker.getAliasedSymbol(symbol);
   }
-  const declaration = symbol?.declarations?.find(ts4.isClassDeclaration);
+  const declaration = symbol?.declarations?.find(ts7.isClassDeclaration);
   const resource = declaration ? ctx.infraResources.get(declaration) : undefined;
   if (!resource) {
     pushResourceError(ctx, "unknown-resource", `${owner} 引用的资源 '${nodeText(el)}' 未声明为 @InfraResource`, file, line, "引用实际声明了 @InfraResource({ name, kind }) 的类，不能依赖其他文件的同名类。");
@@ -19130,7 +19707,7 @@ function parseModuleInfraResources(value, ctx, owner, file, line) {
   if (!value)
     return names;
   const array = unwrapInfraResourceExpression(value);
-  if (!ts4.isArrayLiteralExpression(array)) {
+  if (!ts7.isArrayLiteralExpression(array)) {
     pushResourceError(ctx, "unknown-resource", `${owner} 的 resources 必须是静态数组`, file, line, "使用 resources: [ResourceClass]；省略该属性表示不声明资源。");
     return names;
   }
@@ -19145,14 +19722,14 @@ function parseInfraResourceUseRefs(value, ctx, owner, file, line) {
   if (!value)
     return [];
   const array = unwrapInfraResourceExpression(value);
-  if (!ts4.isArrayLiteralExpression(array)) {
+  if (!ts7.isArrayLiteralExpression(array)) {
     pushResourceError(ctx, "unknown-resource", `${owner} 的 uses 必须是静态数组`, file, line, '使用 uses: [{ resource: ResourceClass, operations: ["read"] }]。');
     return [];
   }
   const uses = new Map;
   for (const element of array.elements) {
     const entry = unwrapInfraResourceExpression(element);
-    if (!ts4.isObjectLiteralExpression(entry) || entry.properties.some((property) => !ts4.isPropertyAssignment(property) || ts4.isComputedPropertyName(property.name) || !["resource", "operations"].includes(propertyName(property.name))) || new Set(entry.properties.map((property) => property.name && propertyName(property.name))).size !== entry.properties.length) {
+    if (!ts7.isObjectLiteralExpression(entry) || entry.properties.some((property) => !ts7.isPropertyAssignment(property) || ts7.isComputedPropertyName(property.name) || !["resource", "operations"].includes(propertyName(property.name))) || new Set(entry.properties.map((property) => property.name && propertyName(property.name))).size !== entry.properties.length) {
       pushResourceError(ctx, "unknown-resource", `${owner} 的 uses 项必须是显式的 { resource, operations } 对象`, file, lineOf(element), "使用显式属性，不要使用对象/数组展开、简写、计算属性或重复属性。");
       continue;
     }
@@ -19170,14 +19747,14 @@ function parseInfraResourceUseRefs(value, ctx, owner, file, line) {
       operations.add("read");
     } else {
       const operationArray = unwrapInfraResourceExpression(operationsEl);
-      if (!ts4.isArrayLiteralExpression(operationArray) || operationArray.elements.length === 0) {
+      if (!ts7.isArrayLiteralExpression(operationArray) || operationArray.elements.length === 0) {
         pushResourceError(ctx, "invalid-resource-operation", `${owner} 对资源 '${resource}' 的 operations 必须是非空静态数组`, file, lineOf(operationsEl), "仅省略 operations 时默认 read；显式填写时必须包含有效操作。");
         continue;
       }
       let invalid = false;
       for (const operationEl of operationArray.elements) {
         const operation = unwrapInfraResourceExpression(operationEl);
-        if (!ts4.isStringLiteral(operation) || !isInfraResourceOperation(operation.text)) {
+        if (!ts7.isStringLiteral(operation) || !isInfraResourceOperation(operation.text)) {
           pushResourceError(ctx, "invalid-resource-operation", `${owner} 对资源 '${resource}' 声明了无效操作 '${nodeText(operationEl)}'`, file, lineOf(operationEl), `operations 只能包含字符串字面量 ${INFRA_RESOURCE_OPERATIONS.join(" | ")}。`);
           invalid = true;
           continue;
@@ -19222,11 +19799,11 @@ import { join as join4 } from "node:path";
 
 // src/type-safety.ts
 import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
-import { dirname as dirname3, join as join3, relative as relative3, resolve as resolve2, sep as sep3 } from "node:path";
-import * as ts6 from "@typescript/typescript6";
+import { dirname as dirname3, join as join3, relative as relative3, resolve as resolve3, sep as sep3 } from "node:path";
+import * as ts9 from "@typescript/typescript6";
 
 // src/sql-safety.ts
-import * as ts5 from "@typescript/typescript6";
+import * as ts8 from "@typescript/typescript6";
 var SQL_SAFETY_DIAGNOSTIC_CODES = {
   "sql-result-assertion": { errorCode: "SC6007", docsUrl: "https://supacloud.dev/errors/SC6007" },
   "sql-raw-dynamic": { errorCode: "SC6008", docsUrl: "https://supacloud.dev/errors/SC6008" }
@@ -19234,10 +19811,10 @@ var SQL_SAFETY_DIAGNOSTIC_CODES = {
 function scanDrizzleSql(sourceFile, checker, file, strict) {
   const diagnostics = [];
   const importedSql = (expression) => {
-    const symbol = checker.getSymbolAtLocation(ts5.isPropertyAccessExpression(expression) ? expression.name : expression);
+    const symbol = checker.getSymbolAtLocation(ts8.isPropertyAccessExpression(expression) ? expression.name : expression);
     if (!symbol)
       return false;
-    const target = symbol.flags & ts5.SymbolFlags.Alias ? checker.getAliasedSymbol(symbol) : symbol;
+    const target = symbol.flags & ts8.SymbolFlags.Alias ? checker.getAliasedSymbol(symbol) : symbol;
     return target.name === "sql" && (target.declarations ?? []).some((declaration) => /(?:^|\/)node_modules\/drizzle-orm\//.test(declaration.getSourceFile().fileName.replaceAll("\\", "/")));
   };
   const report = (code, node, message) => {
@@ -19251,16 +19828,16 @@ function scanDrizzleSql(sourceFile, checker, file, strict) {
     });
   };
   const visit = (node) => {
-    if (ts5.isTaggedTemplateExpression(node) && importedSql(node.tag) && node.typeArguments?.some((type) => type.kind !== ts5.SyntaxKind.UnknownKeyword)) {
+    if (ts8.isTaggedTemplateExpression(node) && importedSql(node.tag) && node.typeArguments?.some((type) => type.kind !== ts8.SyntaxKind.UnknownKeyword)) {
       report("sql-result-assertion", node, "Drizzle sql<T> asserts a result type without checking SQL or decoding rows. Use sql<unknown> and a schema decoder at the result boundary.");
     }
-    if (ts5.isCallExpression(node) && ts5.isPropertyAccessExpression(node.expression) && node.expression.name.text === "raw" && importedSql(node.expression.expression)) {
+    if (ts8.isCallExpression(node) && ts8.isPropertyAccessExpression(node.expression) && node.expression.name.text === "raw" && importedSql(node.expression.expression)) {
       const argument = node.arguments[0];
-      if (!argument || !ts5.isStringLiteral(argument) && !ts5.isNoSubstitutionTemplateLiteral(argument)) {
+      if (!argument || !ts8.isStringLiteral(argument) && !ts8.isNoSubstitutionTemplateLiteral(argument)) {
         report("sql-raw-dynamic", node, "Dynamic sql.raw bypasses parameter binding. Interpolate values with sql templates; keep reviewed static DDL in migrations.");
       }
     }
-    ts5.forEachChild(node, visit);
+    ts8.forEachChild(node, visit);
   };
   visit(sourceFile);
   return diagnostics;
@@ -19292,7 +19869,7 @@ function scanGeneratedArtifacts(artifacts, strict = true) {
   for (const [file, content] of Object.entries(artifacts)) {
     if (content === undefined)
       continue;
-    const sourceFile = ts6.createSourceFile(file, content, ts6.ScriptTarget.Latest, true, ts6.ScriptKind.TS);
+    const sourceFile = ts9.createSourceFile(file, content, ts9.ScriptTarget.Latest, true, ts9.ScriptKind.TS);
     for (const node of descendantsOfKind2(sourceFile, isAnyKeyword)) {
       diagnostics.push(makeDiagnostic("generated-any", `生成产物 ${file} 包含 any；严格生成模式要求使用 unknown、具体接口或泛型约束。`, sourceFile, node, strict));
     }
@@ -19300,31 +19877,31 @@ function scanGeneratedArtifacts(artifacts, strict = true) {
   return diagnostics;
 }
 function scanProductionSource(options) {
-  const rootDir = resolve2(options.rootDir);
-  const configPath = ts6.findConfigFile(rootDir, ts6.sys.fileExists) ?? join3(rootDir, "tsconfig.json");
+  const rootDir = resolve3(options.rootDir);
+  const configPath = ts9.findConfigFile(rootDir, ts9.sys.fileExists) ?? join3(rootDir, "tsconfig.json");
   const projectConfig = existsSync2(configPath) ? readProjectConfig2(configPath) : {
     options: {
       strict: true,
       skipLibCheck: true,
-      target: ts6.ScriptTarget.ES2022,
-      module: ts6.ModuleKind.ESNext,
-      moduleResolution: ts6.ModuleResolutionKind.Bundler
+      target: ts9.ScriptTarget.ES2022,
+      module: ts9.ModuleKind.ESNext,
+      moduleResolution: ts9.ModuleResolutionKind.Bundler
     },
     errors: []
   };
   const include = options.include ?? ["**/*.ts", "**/*.tsx", "**/*.mts", "**/*.cts"];
-  const rootNames = ts6.sys.readDirectory(rootDir, [".ts", ".tsx", ".mts", ".cts"], ["node_modules", "dist"], include).filter((file) => isProductionSourcePath(rootDir, file, [...DEFAULT_EXCLUDES, ...options.exclude ?? []]));
+  const rootNames = ts9.sys.readDirectory(rootDir, [".ts", ".tsx", ".mts", ".cts"], ["node_modules", "dist"], include).filter((file) => isProductionSourcePath(rootDir, file, [...DEFAULT_EXCLUDES, ...options.exclude ?? []]));
   const compilerOptions = { ...projectConfig.options, noEmit: true };
-  const host = ts6.createCompilerHost(compilerOptions);
+  const host = ts9.createCompilerHost(compilerOptions);
   host.getCurrentDirectory = () => dirname3(configPath);
-  const program = ts6.createProgram(rootNames, compilerOptions, host);
+  const program = ts9.createProgram(rootNames, compilerOptions, host);
   const outDir = options.outDir ? normalizeRelative(rootDir, options.outDir) : undefined;
   const excludes = [...DEFAULT_EXCLUDES, ...options.exclude ?? []];
   const sourceFiles = program.getSourceFiles().filter((sourceFile) => isProductionSource(rootDir, sourceFile, excludes, outDir));
   const diagnostics = [...projectConfig.errors, ...program.getOptionsDiagnostics()].map((diagnostic) => ({
     severity: "error",
     code: "source-config",
-    message: ts6.flattenDiagnosticMessageText(diagnostic.messageText, `
+    message: ts9.flattenDiagnosticMessageText(diagnostic.messageText, `
 `),
     file: diagnostic.file ? normalizeRelative(rootDir, diagnostic.file.fileName) : normalizeRelative(rootDir, configPath),
     ...diagnostic.file && diagnostic.start !== undefined ? { line: diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start).line + 1 } : {},
@@ -19341,7 +19918,7 @@ function scanProductionSource(options) {
     diagnostics.push({
       severity: "error",
       code: "source-typescript",
-      message: ts6.flattenDiagnosticMessageText(diagnostic.messageText, `
+      message: ts9.flattenDiagnosticMessageText(diagnostic.messageText, `
 `),
       ...diagnostic.file ? { file: normalizeRelative(rootDir, diagnostic.file.fileName) } : {},
       ...diagnostic.file && diagnostic.start !== undefined ? { line: diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start).line + 1 } : {},
@@ -19351,9 +19928,9 @@ function scanProductionSource(options) {
   for (const sourceFile of sourceFiles) {
     scanSourceFile(sourceFile, checker, rootDir, diagnostics, options.strict ?? false);
     diagnostics.push(...scanDrizzleSql(sourceFile, checker, normalizeRelative(rootDir, sourceFile.fileName), options.strict ?? false));
-    const scanner = ts6.createScanner(ts6.ScriptTarget.Latest, false, sourceFile.languageVariant, sourceFile.text);
-    for (let kind = scanner.scan();kind !== ts6.SyntaxKind.EndOfFileToken; kind = scanner.scan()) {
-      if ((kind === ts6.SyntaxKind.SingleLineCommentTrivia || kind === ts6.SyntaxKind.MultiLineCommentTrivia) && /@ts-(?:ignore|nocheck|expect-error)\b/.test(scanner.getTokenText())) {
+    const scanner = ts9.createScanner(ts9.ScriptTarget.Latest, false, sourceFile.languageVariant, sourceFile.text);
+    for (let kind = scanner.scan();kind !== ts9.SyntaxKind.EndOfFileToken; kind = scanner.scan()) {
+      if ((kind === ts9.SyntaxKind.SingleLineCommentTrivia || kind === ts9.SyntaxKind.MultiLineCommentTrivia) && /@ts-(?:ignore|nocheck|expect-error)\b/.test(scanner.getTokenText())) {
         diagnostics.push({
           severity: "error",
           code: "source-type-suppression",
@@ -19373,22 +19950,22 @@ function scanSourceFile(sourceFile, checker, rootDir, diagnostics, strict) {
     diagnostics.push(makeDiagnostic("source-any", "生产源码使用了显式 any；请改用 unknown、具体接口或泛型约束。", sourceFile, node, strict, rootDir));
   }
   for (const node of descendants(sourceFile)) {
-    if (ts6.isAsExpression(node)) {
-      if (ts6.isAsExpression(node.parent) || ts6.isTypeAssertionExpression(node.parent))
+    if (ts9.isAsExpression(node)) {
+      if (ts9.isAsExpression(node.parent) || ts9.isTypeAssertionExpression(node.parent))
         continue;
       const assertedType = node.type.getText(sourceFile);
       if (assertedType === "const")
         continue;
       diagnostics.push(makeDiagnostic("source-type-assertion", `生产源码包含类型断言 ${node.getText(sourceFile)}；请优先使用类型守卫、satisfies 或显式边界解析。`, sourceFile, node, strict, rootDir));
-    } else if (ts6.isTypeAssertionExpression(node)) {
-      if (ts6.isAsExpression(node.parent) || ts6.isTypeAssertionExpression(node.parent))
+    } else if (ts9.isTypeAssertionExpression(node)) {
+      if (ts9.isAsExpression(node.parent) || ts9.isTypeAssertionExpression(node.parent))
         continue;
       diagnostics.push(makeDiagnostic("source-type-assertion", `生产源码包含类型断言 ${node.getText(sourceFile)}；请优先使用类型守卫、satisfies 或显式边界解析。`, sourceFile, node, strict, rootDir));
-    } else if (ts6.isNonNullExpression(node)) {
+    } else if (ts9.isNonNullExpression(node)) {
       diagnostics.push(makeDiagnostic("source-non-null-assertion", `生产源码包含非空断言 ${node.getText(sourceFile)}；请显式处理 null/undefined。`, sourceFile, node, strict, rootDir));
     }
   }
-  for (const declaration of descendantsOfKind2(sourceFile, ts6.isVariableDeclaration)) {
+  for (const declaration of descendantsOfKind2(sourceFile, ts9.isVariableDeclaration)) {
     const initializer = declaration.initializer;
     if (!initializer || declaration.type)
       continue;
@@ -19404,11 +19981,11 @@ function scanSourceFile(sourceFile, checker, rootDir, diagnostics, strict) {
     if (isLetDeclaration(declaration) && isLiteralSyntax(initializer) && !isLiteralType(declarationType)) {
       diagnostics.push(makeDiagnostic("source-implicit-widening", `变量 ${declaration.name.getText(sourceFile)} 的字面量类型从 ${checker.typeToString(initializerType, initializer)} 隐式宽化为 ${checker.typeToString(declarationType, declaration)}；请补充类型或使用 const。`, sourceFile, declaration, strict, rootDir));
     }
-    if (ts6.isObjectLiteralExpression(initializer) && isConstDeclaration(declaration) && initializer.getText(sourceFile).length > 0 && initializer.properties.some((property) => ts6.isPropertyAssignment(property) && property.initializer !== undefined && !ts6.isAsExpression(property.initializer) && isLiteralExpression(property.initializer))) {
+    if (ts9.isObjectLiteralExpression(initializer) && isConstDeclaration(declaration) && initializer.getText(sourceFile).length > 0 && initializer.properties.some((property) => ts9.isPropertyAssignment(property) && property.initializer !== undefined && !ts9.isAsExpression(property.initializer) && isLiteralExpression(property.initializer))) {
       diagnostics.push(makeDiagnostic("source-implicit-widening", `常量对象 ${declaration.name.getText(sourceFile)} 的字面量属性会隐式宽化；请补充对象类型或使用 as const。`, sourceFile, declaration, strict, rootDir));
     }
   }
-  for (const parameter of descendantsOfKind2(sourceFile, ts6.isParameter)) {
+  for (const parameter of descendantsOfKind2(sourceFile, ts9.isParameter)) {
     if (parameter.type)
       continue;
     for (const name of bindingNames(parameter.name)) {
@@ -19419,10 +19996,10 @@ function scanSourceFile(sourceFile, checker, rootDir, diagnostics, strict) {
   }
 }
 function readProjectConfig2(configPath) {
-  const config = ts6.readConfigFile(configPath, (file) => readFileSync2(file, "utf8"));
+  const config = ts9.readConfigFile(configPath, (file) => readFileSync2(file, "utf8"));
   if (config.error)
     return { options: {}, errors: [config.error] };
-  const parsed = ts6.parseJsonConfigFileContent(config.config, ts6.sys, dirname3(configPath));
+  const parsed = ts9.parseJsonConfigFileContent(config.config, ts9.sys, dirname3(configPath));
   return { options: parsed.options, errors: parsed.errors };
 }
 function isProductionSource(rootDir, sourceFile, excludes, outDir) {
@@ -19442,42 +20019,42 @@ function globMatches(value, pattern) {
   return new RegExp(`^${escaped}$`).test(value);
 }
 function bindingNames(name) {
-  if (ts6.isIdentifier(name))
+  if (ts9.isIdentifier(name))
     return [name];
-  return name.elements.flatMap((element) => ts6.isBindingElement(element) ? bindingNames(element.name) : []);
+  return name.elements.flatMap((element) => ts9.isBindingElement(element) ? bindingNames(element.name) : []);
 }
 function isLiteralExpression(node) {
   if (!node)
     return false;
   return [
-    ts6.SyntaxKind.StringLiteral,
-    ts6.SyntaxKind.NumericLiteral,
-    ts6.SyntaxKind.TrueKeyword,
-    ts6.SyntaxKind.FalseKeyword
+    ts9.SyntaxKind.StringLiteral,
+    ts9.SyntaxKind.NumericLiteral,
+    ts9.SyntaxKind.TrueKeyword,
+    ts9.SyntaxKind.FalseKeyword
   ].includes(node.kind);
 }
 function isLiteralSyntax(node) {
-  return ts6.isStringLiteral(node) || ts6.isNumericLiteral(node) || node.kind === ts6.SyntaxKind.TrueKeyword || node.kind === ts6.SyntaxKind.FalseKeyword;
+  return ts9.isStringLiteral(node) || ts9.isNumericLiteral(node) || node.kind === ts9.SyntaxKind.TrueKeyword || node.kind === ts9.SyntaxKind.FalseKeyword;
 }
 function isLiteralType(type) {
-  return (type.flags & (ts6.TypeFlags.StringLiteral | ts6.TypeFlags.NumberLiteral | ts6.TypeFlags.BooleanLiteral | ts6.TypeFlags.BigIntLiteral)) !== 0;
+  return (type.flags & (ts9.TypeFlags.StringLiteral | ts9.TypeFlags.NumberLiteral | ts9.TypeFlags.BooleanLiteral | ts9.TypeFlags.BigIntLiteral)) !== 0;
 }
 function isAnyType(type) {
-  return (type.flags & ts6.TypeFlags.Any) !== 0;
+  return (type.flags & ts9.TypeFlags.Any) !== 0;
 }
 function isLetDeclaration(declaration) {
-  return ts6.isVariableDeclarationList(declaration.parent) && (declaration.parent.flags & ts6.NodeFlags.Let) !== 0;
+  return ts9.isVariableDeclarationList(declaration.parent) && (declaration.parent.flags & ts9.NodeFlags.Let) !== 0;
 }
 function isConstDeclaration(declaration) {
-  return ts6.isVariableDeclarationList(declaration.parent) && (declaration.parent.flags & ts6.NodeFlags.Const) !== 0;
+  return ts9.isVariableDeclarationList(declaration.parent) && (declaration.parent.flags & ts9.NodeFlags.Const) !== 0;
 }
 function descendants(root) {
   const result = [];
   const visit = (node) => {
     result.push(node);
-    ts6.forEachChild(node, visit);
+    ts9.forEachChild(node, visit);
   };
-  ts6.forEachChild(root, visit);
+  ts9.forEachChild(root, visit);
   return result;
 }
 function descendantsOfKind2(root, predicate) {
@@ -19485,9 +20062,9 @@ function descendantsOfKind2(root, predicate) {
   const visit = (node) => {
     if (predicate(node))
       result.push(node);
-    ts6.forEachChild(node, visit);
+    ts9.forEachChild(node, visit);
   };
-  ts6.forEachChild(root, visit);
+  ts9.forEachChild(root, visit);
   return result;
 }
 function makeDiagnostic(code, message, fileOrSourceFile, node, strict, rootDir) {
@@ -19508,7 +20085,7 @@ function normalizeRelative(rootDir, filePath) {
   return relative3(rootDir, filePath).split(sep3).join("/").replace(/^\.\//, "");
 }
 function isAnyKeyword(node) {
-  return node.kind === ts6.SyntaxKind.AnyKeyword;
+  return node.kind === ts9.SyntaxKind.AnyKeyword;
 }
 
 // src/compile.ts
@@ -19927,12 +20504,12 @@ init_delivery_context();
 
 // src/watch.ts
 import { existsSync as existsSync4, watch } from "node:fs";
-import { dirname as dirname7, relative as relative8, resolve as resolve9, sep as sep8 } from "node:path";
+import { dirname as dirname7, relative as relative8, resolve as resolve10, sep as sep8 } from "node:path";
 
 // src/incremental.ts
 import { createHash as createHash7 } from "node:crypto";
 import { access as access3, readdir as readdir3, readFile as readFile4 } from "node:fs/promises";
-import { isAbsolute as isAbsolute3, relative as relative7, resolve as resolve8, sep as sep7 } from "node:path";
+import { isAbsolute as isAbsolute3, relative as relative7, resolve as resolve9, sep as sep7 } from "node:path";
 init_graphql_inputs();
 function createDependencyGraphCache() {
   return {
@@ -20013,11 +20590,11 @@ async function readSourceBytes(path) {
   return readFile4(path);
 }
 async function updateSnapshot(previous, options, changedPaths) {
-  const rootDir = resolve8(options.rootDir);
-  const outDir = resolve8(options.outDir);
+  const rootDir = resolve9(options.rootDir);
+  const outDir = resolve9(options.outDir);
   const files = { ...previous.files };
   await Promise.all(changedPaths.map(async (changedPath) => {
-    const absolutePath = isAbsolute3(changedPath) ? resolve8(changedPath) : resolve8(rootDir, changedPath);
+    const absolutePath = isAbsolute3(changedPath) ? resolve9(changedPath) : resolve9(rootDir, changedPath);
     const relativeChangedPath = relative7(rootDir, absolutePath);
     if (relativeChangedPath === ".." || relativeChangedPath.startsWith(`..${sep7}`))
       return;
@@ -20035,8 +20612,8 @@ async function updateSnapshot(previous, options, changedPaths) {
   return { files, optionsKey: optionsKeyOf(options) };
 }
 async function createSnapshot(options) {
-  const rootDir = resolve8(options.rootDir);
-  const outDir = resolve8(options.outDir);
+  const rootDir = resolve9(options.rootDir);
+  const outDir = resolve9(options.outDir);
   const paths = await listSourceFiles(rootDir, outDir);
   const files = {};
   const entries = await Promise.all(paths.map(async (path) => {
@@ -20059,8 +20636,8 @@ async function createSnapshot(options) {
 }
 function optionsKeyOf(options) {
   return JSON.stringify({
-    rootDir: resolve8(options.rootDir),
-    outDir: resolve8(options.outDir),
+    rootDir: resolve9(options.rootDir),
+    outDir: resolve9(options.outDir),
     include: options.include,
     strict: options.strict,
     writeOnError: options.writeOnError,
@@ -20084,7 +20661,7 @@ async function listSourceFiles(rootDir, outDir) {
   const result = [];
   const visit = async (directory) => {
     for (const entry of await readdir3(directory, { withFileTypes: true })) {
-      const path = resolve8(directory, entry.name);
+      const path = resolve9(directory, entry.name);
       if (entry.isDirectory()) {
         if (entry.name === "node_modules" || entry.name === ".git" || path === outDir)
           continue;
@@ -20219,8 +20796,8 @@ function isCompilerConfigurationPath(rootDir, changedPath) {
   ].includes(relativePath) || /^tsconfig\.[^/]+\.json$/.test(relativePath);
 }
 function watchProject(options) {
-  const rootDir = resolve9(options.rootDir);
-  const outDir = resolve9(options.outDir);
+  const rootDir = resolve10(options.rootDir);
+  const outDir = resolve10(options.outDir);
   const debounceMs = options.debounceMs ?? DEFAULT_DEBOUNCE_MS;
   let timer;
   let closed = false;
@@ -20230,7 +20807,7 @@ function watchProject(options) {
   const pendingPaths = new Set;
   let watcher;
   let schemaWatcher;
-  const schemaPath = options.graphql ? resolve9(rootDir, options.graphql.schema) : undefined;
+  const schemaPath = options.graphql ? resolve10(rootDir, options.graphql.schema) : undefined;
   const incremental = createIncrementalCompiler();
   let initialEvent;
   let resolveReady = () => {
@@ -20340,7 +20917,7 @@ function watchProject(options) {
     watcher = watch(rootDir, { recursive: true }, (_eventType, filename) => {
       if (!filename)
         return schedule();
-      const changedPath = resolve9(rootDir, filename.toString());
+      const changedPath = resolve10(rootDir, filename.toString());
       const relativePath = relative8(outDir, changedPath);
       if (!relativePath.startsWith("..") && relativePath !== "")
         return;
@@ -20353,7 +20930,7 @@ function watchProject(options) {
       while (!existsSync4(directory) && dirname7(directory) !== directory)
         directory = dirname7(directory);
       schemaWatcher = watch(directory, { recursive: true }, (_eventType, filename) => {
-        if (!filename || resolve9(directory, filename.toString()) === schemaPath)
+        if (!filename || resolve10(directory, filename.toString()) === schemaPath)
           schedule(schemaPath);
       });
     }
@@ -20378,7 +20955,7 @@ function watchProject(options) {
 // src/config.ts
 init_graphql_options();
 import { existsSync as existsSync5 } from "node:fs";
-import { join as join8, resolve as resolve10 } from "node:path";
+import { join as join8, resolve as resolve11 } from "node:path";
 import { pathToFileURL } from "node:url";
 
 // src/delivery-schema.ts
@@ -20476,8 +21053,8 @@ function validateGovernanceConfig(config) {
 function resolveSupacloudConfig(config = {}, cwd = process.cwd()) {
   const resolved = defineSupacloudConfig(config);
   return {
-    rootDir: resolve10(cwd, resolved.root ?? DEFAULT_SUPACLOUD_CONFIG.root),
-    outDir: resolve10(cwd, resolved.outDir ?? DEFAULT_SUPACLOUD_CONFIG.outDir),
+    rootDir: resolve11(cwd, resolved.root ?? DEFAULT_SUPACLOUD_CONFIG.root),
+    outDir: resolve11(cwd, resolved.outDir ?? DEFAULT_SUPACLOUD_CONFIG.outDir),
     include: resolved.include ?? [...DEFAULT_SUPACLOUD_CONFIG.include],
     strict: resolved.strict ?? DEFAULT_SUPACLOUD_CONFIG.strict,
     requireRouteContracts: resolved.requireRouteContracts ?? DEFAULT_SUPACLOUD_CONFIG.requireRouteContracts,
@@ -20495,7 +21072,7 @@ function resolveSupacloudConfig(config = {}, cwd = process.cwd()) {
     treeShakeUnusedProviders: resolved.treeShakeUnusedProviders ?? DEFAULT_SUPACLOUD_CONFIG.treeShakeUnusedProviders,
     graphql: resolved.graphql ? {
       ...resolved.graphql,
-      schema: resolve10(cwd, resolved.graphql.schema)
+      schema: resolve11(cwd, resolved.graphql.schema)
     } : undefined
   };
 }
@@ -20516,213 +21093,67 @@ function compileOptionsFromConfig(config, cwd = process.cwd()) {
   return resolveSupacloudConfig(config, cwd);
 }
 
-// src/fixes.ts
-import { randomUUID } from "node:crypto";
-import { lstat as lstat2, readFile as readFile5, realpath as realpath3, rename as rename3, unlink as unlink2, writeFile as writeFile3 } from "node:fs/promises";
-import { dirname as dirname8, isAbsolute as isAbsolute4, relative as relative9, resolve as resolve11, sep as sep9 } from "node:path";
-import * as ts9 from "@typescript/typescript6";
-async function applyDiagnosticFix(fix, options = {}) {
-  if (!fix || typeof fix.targetFile !== "string")
-    throw new Error("Invalid DiagnosticFix");
-  const root = await realpath3(options.rootDir ?? process.cwd());
-  const file = resolve11(root, fix.targetFile);
-  const stat = await lstat2(file);
-  const resolved = await realpath3(file);
-  const relativePath = relative9(root, resolved);
-  if (stat.isSymbolicLink() || !stat.isFile() || isAbsolute4(relativePath) || relativePath === ".." || relativePath.startsWith(`..${sep9}`)) {
-    throw new Error("Fix target must be a regular file inside rootDir");
-  }
-  const original = await readFile5(file, "utf8");
-  let source = parse5(file, original);
-  let content;
-  switch (fix.type) {
-    case "set_command_mode": {
-      if (fix.property !== "transaction" && fix.property !== "idempotency" || fix.value !== "required" && fix.value !== "none") {
-        throw new Error("Command mode fix requires an explicit property and policy value");
-      }
-      const object = decoratorObject(findClass(source, fix.command), "Command");
-      const current = property(object, fix.property);
-      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, ts9.factory.createStringLiteral(fix.value));
-      break;
-    }
-    case "add_module_import": {
-      if (!fix.importPath || !fix.symbol)
-        throw new Error("Module fix requires importPath and symbol");
-      identifier2(fix.symbol);
-      const withImport = importSymbol(source, fix.importPath, fix.symbol);
-      source = parse5(file, withImport);
-      const object = unique(moduleObjects(source).filter((candidate) => !fix.targetModule || stringProperty(candidate, "name") === fix.targetModule), "target module");
-      const imports = property(object, "imports");
-      if (imports && !ts9.isArrayLiteralExpression(imports.initializer)) {
-        throw new Error("Module imports must be a static array");
-      }
-      const values = imports && ts9.isArrayLiteralExpression(imports.initializer) ? imports.initializer.elements : [];
-      if (values.some(ts9.isSpreadElement))
-        throw new Error("Module imports cannot contain spread elements");
-      content = values.some((value) => ts9.isIdentifier(value) && value.text === fix.symbol) ? withImport : replaceProperty(source, object, "imports", ts9.factory.createArrayLiteralExpression([
-        ...values,
-        ts9.factory.createIdentifier(fix.symbol)
-      ]));
-      break;
-    }
-    case "add_command_permission": {
-      const permission = options.permission ?? fix.permission;
-      if (!permission?.trim()) {
-        throw new Error("Permission fix requires an explicit permission; privileges are never inferred");
-      }
-      const command = findClass(source, fix.command);
-      const object = decoratorObject(command, "Command");
-      const current = property(object, "permission");
-      if (current && (!ts9.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", ts9.factory.createStringLiteral(permission));
-      break;
-    }
-    case "add_route_parameter_binding": {
-      const controller = findClass(source, fix.controller);
-      const method = unique(controller.members.filter((member) => ts9.isMethodDeclaration(member) && nameOf(member.name) === fix.route), "route handler");
-      const parameter = unique(method.parameters.filter((candidate) => ts9.isIdentifier(candidate.name) && candidate.name.text === fix.parameter), "same-named route parameter");
-      const binding = fix.binding === "param" ? "Param" : fix.binding === "query" ? "Query" : undefined;
-      if (!binding)
-        throw new Error("Invalid route binding");
-      const decorators = ts9.getDecorators(parameter) ?? [];
-      if (decorators.length > 0)
-        throw new Error("Parameter already has a decorator");
-      const framework = unique(source.statements.filter((statement) => ts9.isImportDeclaration(statement) && statement.importClause?.namedBindings && ts9.isNamedImports(statement.importClause.namedBindings) && statement.importClause.namedBindings.elements.some((element) => ["Controller", "Get", "Post", "Put", "Patch", "Delete", "Head", "Options"].includes(element.name.text))), "framework import");
-      if (!ts9.isImportDeclaration(framework) || !ts9.isStringLiteral(framework.moduleSpecifier)) {
-        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(parse5(file, edited), framework.moduleSpecifier.text, binding);
-      break;
-    }
-    default:
-      throw new Error(`Diagnostic fix '${fix.type}' requires a manual semantic decision; no files changed`);
-  }
-  parse5(file, content);
-  const result = { file, changed: content !== original, content };
-  if (options.dryRun === false && result.changed) {
-    const temporary = `${file}.supacloud-fix-${randomUUID()}`;
-    try {
-      await writeFile3(temporary, content, { encoding: "utf8", flag: "wx", mode: stat.mode });
-      if (await readFile5(file, "utf8") !== original)
-        throw new Error("Target changed while preparing the fix");
-      await rename3(temporary, file);
-    } finally {
-      await unlink2(temporary).catch(() => {});
-    }
-  }
-  return result;
-}
-function parse5(file, text) {
-  const result = ts9.transpileModule(text, {
-    fileName: file,
-    reportDiagnostics: true,
-    compilerOptions: { target: ts9.ScriptTarget.ESNext, experimentalDecorators: true }
-  });
-  if (result.diagnostics?.some((item) => item.category === ts9.DiagnosticCategory.Error)) {
-    throw new Error("Cannot fix syntactically invalid TypeScript");
-  }
-  return ts9.createSourceFile(file, text, ts9.ScriptTarget.Latest, true, ts9.ScriptKind.TS);
-}
-function unique(items, description) {
-  if (items.length !== 1)
-    throw new Error(`Expected exactly one ${description}; found ${items.length}`);
-  return items[0];
-}
-function identifier2(value) {
-  if (!/^[A-Za-z_$][\w$]*$/.test(value))
-    throw new Error(`Invalid identifier '${value}'`);
-}
-function nameOf(name) {
-  if (!name)
-    return "";
-  return ts9.isIdentifier(name) || ts9.isStringLiteral(name) || ts9.isNumericLiteral(name) ? name.text : "";
-}
-function property(object, key) {
-  if (object.properties.some((item) => !ts9.isPropertyAssignment(item) || ts9.isComputedPropertyName(item.name))) {
-    throw new Error("Fix requires explicit static object properties");
-  }
-  const values = object.properties.filter((item) => ts9.isPropertyAssignment(item) && nameOf(item.name) === key);
-  if (values.length > 1)
-    throw new Error(`Duplicate '${key}' property`);
-  return values[0];
-}
-function stringProperty(object, key) {
-  const value = property(object, key)?.initializer;
-  return value && ts9.isStringLiteral(value) ? value.text : undefined;
-}
-function replaceProperty(source, object, key, value) {
-  const previous = property(object, key);
-  const replacement = ts9.factory.createPropertyAssignment(key, value);
-  const properties = object.properties.map((item) => item === previous ? replacement : item);
-  if (!previous)
-    properties.push(replacement);
-  const updated = ts9.factory.updateObjectLiteralExpression(object, properties);
-  return source.text.slice(0, object.getStart(source)) + ts9.createPrinter().printNode(ts9.EmitHint.Expression, updated, source) + source.text.slice(object.end);
-}
-function findClass(source, name) {
-  return unique(source.statements.filter((statement) => ts9.isClassDeclaration(statement) && statement.name?.text === name), `class '${name}'`);
-}
-function decoratorObject(node, name) {
-  const decorator = unique((ts9.getDecorators(node) ?? []).filter((item) => ts9.isCallExpression(item.expression) && item.expression.expression.getText() === name), `@${name} decorator`);
-  const argument = ts9.isCallExpression(decorator.expression) ? decorator.expression.arguments[0] : undefined;
-  if (!argument || !ts9.isObjectLiteralExpression(argument))
-    throw new Error(`@${name} requires a static object`);
-  return argument;
-}
-function moduleObjects(source) {
-  const result = [];
-  for (const statement of source.statements) {
-    if (ts9.isClassDeclaration(statement) && (ts9.getDecorators(statement) ?? []).some((item) => ts9.isCallExpression(item.expression) && item.expression.expression.getText() === "Module")) {
-      result.push(decoratorObject(statement, "Module"));
-    }
-    if (ts9.isVariableStatement(statement)) {
-      for (const declaration of statement.declarationList.declarations) {
-        const call = declaration.initializer;
-        if (call && ts9.isCallExpression(call) && ["defineModule", "defineFeatureSlice"].includes(call.expression.getText()) && call.arguments[0] && ts9.isObjectLiteralExpression(call.arguments[0])) {
-          result.push(call.arguments[0]);
-        }
+// src/cli.ts
+init_fixes();
+
+// src/diagnostics.ts
+function createDiagnosticReport(diagnostics) {
+  return { format: 1, entries: diagnostics.map((diagnostic) => {
+    const repair = createDiagnosticRepairPlan([diagnostic])[0];
+    return {
+      diagnostic: { ...diagnostic },
+      ...repair ? { repair } : {},
+      ...diagnostic.suggestion ? { guidance: diagnostic.suggestion } : {}
+    };
+  }) };
+}
+function toEditorDiagnostics(diagnostics) {
+  return createDiagnosticReport(diagnostics).entries.map((entry) => ({
+    range: {
+      start: {
+        line: Math.max(0, (entry.diagnostic.line ?? 1) - 1),
+        character: Math.max(0, entry.diagnostic.column ?? 0)
+      },
+      end: {
+        line: Math.max(0, (entry.diagnostic.endLine ?? entry.diagnostic.line ?? 1) - 1),
+        character: Math.max(0, entry.diagnostic.endColumn ?? entry.diagnostic.column ?? 0)
       }
-    }
-  }
-  return result;
+    },
+    severity: entry.diagnostic.severity === "error" ? 1 : 2,
+    source: "supacloud",
+    code: entry.diagnostic.errorCode ?? entry.diagnostic.code,
+    ...entry.diagnostic.docsUrl ? { codeDescription: { href: entry.diagnostic.docsUrl } } : {},
+    message: entry.diagnostic.message + (entry.guidance ? `
+${entry.guidance}` : ""),
+    data: { format: 1, ...entry }
+  }));
 }
-function importSymbol(source, path, symbol) {
-  identifier2(symbol);
-  const current = resolve11(source.fileName).replace(/\.(tsx?|mts|cts)$/, "");
-  const target = resolve11(dirname8(source.fileName), path).replace(/\.(tsx?|mts|cts)$/, "");
-  if (current === target)
-    return source.text;
-  const matches = source.statements.filter((item) => ts9.isImportDeclaration(item) && ts9.isStringLiteral(item.moduleSpecifier) && item.moduleSpecifier.text === path);
-  if (matches.length > 1)
-    throw new Error(`Ambiguous imports from '${path}'`);
-  const match = matches[0];
-  if (match && ts9.isImportDeclaration(match) && match.importClause?.namedBindings && ts9.isNamedImports(match.importClause.namedBindings) && !match.importClause.isTypeOnly) {
-    if (match.importClause.namedBindings.elements.some((item) => item.name.text === symbol))
-      return source.text;
-    const bindings = match.importClause.namedBindings;
-    const updated = ts9.factory.updateNamedImports(bindings, [
-      ...bindings.elements,
-      ts9.factory.createImportSpecifier(false, undefined, ts9.factory.createIdentifier(symbol))
-    ]);
-    return source.text.slice(0, bindings.getStart(source)) + ts9.createPrinter().printNode(ts9.EmitHint.Unspecified, updated, source) + source.text.slice(bindings.end);
+async function createEditorCodeActions(diagnostics, options = {}) {
+  await Promise.resolve().then(() => init_fixes());
+  const actions = [];
+  for (const entry of createDiagnosticReport(diagnostics).entries) {
+    if (entry.repair?.readiness !== "preview")
+      continue;
+    try {
+      const preview = await applyDiagnosticFix(entry.repair.fix, { ...options, dryRun: true });
+      if (!preview.changed)
+        continue;
+      const title = `Apply ${entry.repair.type}`;
+      actions.push({ title, kind: "quickfix", command: {
+        title,
+        command: "supacloud.applyDiagnosticFix",
+        arguments: [{ fix: entry.repair.fix, expectedSourceHash: preview.sourceHash }]
+      }, data: { file: preview.file, preview: preview.content } });
+    } catch {}
   }
-  if (match)
-    throw new Error(`Import from '${path}' is not a named value import`);
-  return `import { ${symbol} } from ${JSON.stringify(path)};
-${source.text}`;
+  return actions;
 }
 
 // src/cli.ts
 init_graphql_options();
 
 // src/delivery-plan.ts
-import { createHash as createHash8 } from "node:crypto";
+import { createHash as createHash9 } from "node:crypto";
 init_validate();
 var compare2 = (a, b) => a < b ? -1 : a > b ? 1 : 0;
 var sorted = (values) => [...new Set(values)].sort(compare2);
@@ -20920,7 +21351,7 @@ function createDeliveryPlan(graph, input) {
     deploymentReady: false,
     targets: [...targets.values()].sort((a, b) => compare2(a.name, b.name))
   };
-  const topologyDigest = createHash8("sha256").update(JSON.stringify(topology)).digest("hex");
+  const topologyDigest = createHash9("sha256").update(JSON.stringify(topology)).digest("hex");
   return parseDeliveryPlanResult({
     ok: true,
     plan: { ...topology, topologyDigest },
@@ -20957,8 +21388,8 @@ function formatDeliveryPlan(result) {
 // src/delivery-build.ts
 import { mkdir as mkdir3, mkdtemp, readFile as readFile7, realpath as realpath4, rename as rename4, rm as rm2 } from "node:fs/promises";
 import { readFileSync as readFileSync3 } from "node:fs";
-import { dirname as dirname9, join as join10, relative as relative10, resolve as resolve14, sep as sep10 } from "node:path";
-import * as ts12 from "@typescript/typescript6";
+import { dirname as dirname9, join as join10, relative as relative10, resolve as resolve15, sep as sep10 } from "node:path";
+import * as ts15 from "@typescript/typescript6";
 
 // src/delivery-build-schema.ts
 init_delivery_build_schema();
@@ -20999,23 +21430,23 @@ function renderDeliveryTarget(graph, target, options) {
 init_delivery_files2();
 import { isBuiltin } from "node:module";
 import { readFile as readFile6 } from "node:fs/promises";
-import { join as join9, resolve as resolve12 } from "node:path";
-import * as ts11 from "@typescript/typescript6";
+import { join as join9, resolve as resolve13 } from "node:path";
+import * as ts14 from "@typescript/typescript6";
 
 // src/delivery-imports.ts
-import * as ts10 from "@typescript/typescript6";
+import * as ts13 from "@typescript/typescript6";
 function staticDeliveryImports(path, contents) {
   if (!/\.[cm]?[jt]sx?$/.test(path))
     return contents;
-  const source = ts10.createSourceFile(path, new TextDecoder().decode(contents), ts10.ScriptTarget.Latest, true);
+  const source = ts13.createSourceFile(path, new TextDecoder().decode(contents), ts13.ScriptTarget.Latest, true);
   const computed = [];
   function scan(node) {
-    if (ts10.isCallExpression(node) && (node.expression.kind === ts10.SyntaxKind.ImportKeyword || ts10.isIdentifier(node.expression) && node.expression.text === "require")) {
+    if (ts13.isCallExpression(node) && (node.expression.kind === ts13.SyntaxKind.ImportKeyword || ts13.isIdentifier(node.expression) && node.expression.text === "require")) {
       const argument = node.arguments[0];
-      if (!argument || !ts10.isStringLiteral(argument) && !ts10.isNoSubstitutionTemplateLiteral(argument))
+      if (!argument || !ts13.isStringLiteral(argument) && !ts13.isNoSubstitutionTemplateLiteral(argument))
         computed.push(node);
     }
-    ts10.forEachChild(node, scan);
+    ts13.forEachChild(node, scan);
   }
   scan(source);
   if (computed.length === 0)
@@ -21023,36 +21454,36 @@ function staticDeliveryImports(path, contents) {
   const reject = () => {
     throw new Error("Computed module loading is not supported in independent delivery bundles.");
   };
-  if (!ts10.isExternalModule(source))
+  if (!ts13.isExternalModule(source))
     return reject();
-  const host = ts10.createCompilerHost({ noLib: true, noResolve: true, allowJs: true });
+  const host = ts13.createCompilerHost({ noLib: true, noResolve: true, allowJs: true });
   host.getSourceFile = (name) => name === path ? source : undefined;
-  const checker = ts10.createProgram([path], { noLib: true, noResolve: true, allowJs: true }, host).getTypeChecker();
+  const checker = ts13.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 = ts10.isIdentifier(node) ? ts10.isShorthandPropertyAssignment(node.parent) ? checker.getShorthandAssignmentValueSymbol(node.parent) : ts10.isExportSpecifier(node.parent) ? checker.getExportSpecifierLocalTargetSymbol(node.parent) : checker.getSymbolAtLocation(node) : undefined;
-      if (ts10.isIdentifier(node) && node !== declarationName && referenced === symbol) {
+      const referenced = ts13.isIdentifier(node) ? ts13.isShorthandPropertyAssignment(node.parent) ? checker.getShorthandAssignmentValueSymbol(node.parent) : ts13.isExportSpecifier(node.parent) ? checker.getExportSpecifierLocalTargetSymbol(node.parent) : checker.getSymbolAtLocation(node) : undefined;
+      if (ts13.isIdentifier(node) && node !== declarationName && referenced === symbol) {
         const use = node.parent;
-        if (!ts10.isCallExpression(use) || use.expression !== node || use.arguments.length !== 1 || use.questionDotToken || use.typeArguments?.length)
+        if (!ts13.isCallExpression(use) || use.expression !== node || use.arguments.length !== 1 || use.questionDotToken || use.typeArguments?.length)
           return reject();
         const value = use.arguments[0];
-        if (!value || !ts10.isStringLiteral(value) && !ts10.isNoSubstitutionTemplateLiteral(value))
+        if (!value || !ts13.isStringLiteral(value) && !ts13.isNoSubstitutionTemplateLiteral(value))
           return reject();
         references++;
-        replacements.set(use, ts10.factory.createCallExpression(call.expression, undefined, [value]));
+        replacements.set(use, ts13.factory.createCallExpression(call.expression, undefined, [value]));
       }
-      ts10.forEachChild(node, visit);
+      ts13.forEachChild(node, visit);
     };
     const statement = call.parent;
     const block = statement.parent;
     const declaration = block.parent;
-    if (call.expression.kind !== ts10.SyntaxKind.ImportKeyword || call.arguments.length !== 1 || !ts10.isReturnStatement(statement) || !ts10.isBlock(block) || block.statements.length !== 1 || !ts10.isFunctionDeclaration(declaration) || declaration.parent !== source || !declaration.name || declaration.modifiers?.length || declaration.asteriskToken || declaration.typeParameters?.length || declaration.parameters.length !== 1)
+    if (call.expression.kind !== ts13.SyntaxKind.ImportKeyword || call.arguments.length !== 1 || !ts13.isReturnStatement(statement) || !ts13.isBlock(block) || block.statements.length !== 1 || !ts13.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 || !ts10.isIdentifier(parameter.name) || parameter.initializer || parameter.dotDotDotToken || !argument || !ts10.isIdentifier(argument) || checker.getSymbolAtLocation(argument) !== checker.getSymbolAtLocation(parameter.name))
+    if (!parameter || !ts13.isIdentifier(parameter.name) || parameter.initializer || parameter.dotDotDotToken || !argument || !ts13.isIdentifier(argument) || checker.getSymbolAtLocation(argument) !== checker.getSymbolAtLocation(parameter.name))
       return reject();
     const symbol = checker.getSymbolAtLocation(declaration.name);
     if (!symbol || symbol.declarations?.length !== 1)
@@ -21064,22 +21495,22 @@ function staticDeliveryImports(path, contents) {
       return reject();
     removed.add(declaration);
   }
-  const transformed = ts10.transform(source, [(context) => {
+  const transformed = ts13.transform(source, [(context) => {
     const visit = (node) => {
-      if (ts10.isFunctionDeclaration(node) && removed.has(node))
+      if (ts13.isFunctionDeclaration(node) && removed.has(node))
         return;
-      const replacement = ts10.isCallExpression(node) ? replacements.get(node) : undefined;
+      const replacement = ts13.isCallExpression(node) ? replacements.get(node) : undefined;
       if (replacement)
         return replacement;
-      return ts10.visitEachChild(node, visit, context);
+      return ts13.visitEachChild(node, visit, context);
     };
-    return (node) => ts10.visitNode(node, visit, ts10.isSourceFile) ?? node;
+    return (node) => ts13.visitNode(node, visit, ts13.isSourceFile) ?? node;
   }]);
   try {
     const transformedSource = transformed.transformed[0];
     if (!transformedSource)
       return reject();
-    return new TextEncoder().encode(ts10.createPrinter().printFile(transformedSource));
+    return new TextEncoder().encode(ts13.createPrinter().printFile(transformedSource));
   } finally {
     transformed.dispose();
   }
@@ -21176,7 +21607,7 @@ async function bundleDeliveryTarget(name, code, project, generatedDirectory, opt
 async function bundleDeliveryTargetInProcess(name, code, project, generatedDirectory, options) {
   const inputs = new Map;
   const workingDirectory = process.cwd();
-  const entry = resolve12(generatedDirectory, `delivery-${name}.ts`);
+  const entry = resolve13(generatedDirectory, `delivery-${name}.ts`);
   const entryPattern = new RegExp(`^${entry.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}$`);
   const result = await Bun.build({
     entrypoints: [entry],
@@ -21199,7 +21630,7 @@ async function bundleDeliveryTargetInProcess(name, code, project, generatedDirec
           if (args.path === entry)
             return { contents: code, loader: "ts" };
           const bytes = await readFile6(args.path);
-          inputs.set(resolve12(args.path), digest(bytes));
+          inputs.set(resolve13(args.path), digest(bytes));
           return { contents: staticDeliveryImports(args.path, bytes), loader: args.loader };
         });
       }
@@ -21209,7 +21640,7 @@ async function bundleDeliveryTargetInProcess(name, code, project, generatedDirec
     throw new Error("Independent bundle failed or has no dependency metadata.");
   const runtimeImports = new Set;
   for (const [path, metadata] of Object.entries(result.metafile.inputs)) {
-    if (resolve12(workingDirectory, path) !== entry && !inputs.has(resolve12(workingDirectory, path))) {
+    if (resolve13(workingDirectory, path) !== entry && !inputs.has(resolve13(workingDirectory, path))) {
       throw new Error("Bundler reported an input that was not captured by the delivery snapshot.");
     }
     for (const imported of metadata.imports) {
@@ -21227,16 +21658,16 @@ async function bundleDeliveryTargetInProcess(name, code, project, generatedDirec
     const bytes = new Uint8Array(await output.arrayBuffer());
     if (/\.[cm]?js$/.test(path)) {
       let check = function(node) {
-        const specifier = ts11.isImportDeclaration(node) || ts11.isExportDeclaration(node) ? node.moduleSpecifier : ts11.isCallExpression(node) && (node.expression.kind === ts11.SyntaxKind.ImportKeyword || ts11.isIdentifier(node.expression) && /^(?:__)?require$/.test(node.expression.text) || ts11.isPropertyAccessExpression(node.expression) && node.expression.name.text === "require" && ts11.isMetaProperty(node.expression.expression) && node.expression.expression.keywordToken === ts11.SyntaxKind.ImportKeyword) ? node.arguments[0] : undefined;
-        if (specifier && ts11.isStringLiteralLike(specifier)) {
+        const specifier = ts14.isImportDeclaration(node) || ts14.isExportDeclaration(node) ? node.moduleSpecifier : ts14.isCallExpression(node) && (node.expression.kind === ts14.SyntaxKind.ImportKeyword || ts14.isIdentifier(node.expression) && /^(?:__)?require$/.test(node.expression.text) || ts14.isPropertyAccessExpression(node.expression) && node.expression.name.text === "require" && ts14.isMetaProperty(node.expression.expression) && node.expression.expression.keywordToken === ts14.SyntaxKind.ImportKeyword) ? node.arguments[0] : undefined;
+        if (specifier && ts14.isStringLiteralLike(specifier)) {
           if (!isBuiltin(specifier.text) && specifier.text !== "bun" && !specifier.text.startsWith("bun:")) {
             throw new Error("Independent bundles cannot retain external package imports.");
           }
           runtimeImports.add(specifier.text);
         }
-        ts11.forEachChild(node, check);
+        ts14.forEachChild(node, check);
       };
-      const source = ts11.createSourceFile(path, new TextDecoder().decode(bytes), ts11.ScriptTarget.Latest, true);
+      const source = ts14.createSourceFile(path, new TextDecoder().decode(bytes), ts14.ScriptTarget.Latest, true);
       check(source);
     }
     files.set(`bundle/${path}`, bytes);
@@ -21526,14 +21957,14 @@ interface DeliveryWorkerHost {
 
 // src/delivery-migrations.ts
 init_delivery_files2();
-import { resolve as resolve13 } from "node:path";
+import { resolve as resolve14 } from "node:path";
 async function prepareDeliveryMigrations(project, generatedRoot, declarations = []) {
   const entries = [];
   const files = new Map;
   const inputs = new Map;
   let totalBytes = 0;
   for (const declaration of [...declarations].sort((a, b) => BigInt(a.version) < BigInt(b.version) ? -1 : BigInt(a.version) > BigInt(b.version) ? 1 : 0)) {
-    const source = resolve13(project, declaration.source);
+    const source = resolve14(project, declaration.source);
     if (!inside(project, source) || inside(generatedRoot, source))
       throw new Error("Invalid migration source.");
     const bytes = await readBoundedOwned(project, source, 1048576);
@@ -21584,7 +22015,7 @@ async function buildDeliveryProject(options, delivery) {
     const settings = parseDeliveryOptions(delivery);
     if (typeof Bun === "undefined")
       throw new Error("Independent delivery builds require Bun.");
-    const configPath = ts12.findConfigFile(resolve14(options.rootDir), ts12.sys.fileExists);
+    const configPath = ts15.findConfigFile(resolve15(options.rootDir), ts15.sys.fileExists);
     if (!configPath)
       throw new Error("Independent delivery builds require a project tsconfig.json.");
     const lexicalProject = dirname9(configPath);
@@ -21592,19 +22023,19 @@ async function buildDeliveryProject(options, delivery) {
     const sourceRoot = await realpath4(options.rootDir);
     if (!inside(project, sourceRoot))
       throw new Error("Application sources must be inside the project.");
-    const requested = resolve14(options.outDir, "delivery");
+    const requested = resolve15(options.outDir, "delivery");
     if (!inside(lexicalProject, requested))
       throw new Error("Output must be inside the application project.");
-    const buildRoot = resolve14(project, relative10(lexicalProject, requested));
-    const generatedRoot = resolve14(project, relative10(lexicalProject, options.outDir));
+    const buildRoot = resolve15(project, relative10(lexicalProject, requested));
+    const generatedRoot = resolve15(project, relative10(lexicalProject, options.outDir));
     if (inside(generatedRoot, sourceRoot))
       throw new Error("Output must not contain the application source root.");
     const configInputs = new Map;
-    const parsedConfig = ts12.getParsedCommandLineOfConfigFile(await realpath4(configPath), {}, {
-      ...ts12.sys,
+    const parsedConfig = ts15.getParsedCommandLineOfConfigFile(await realpath4(configPath), {}, {
+      ...ts15.sys,
       readFile(path) {
         const contents = readFileSync3(path, "utf8");
-        configInputs.set(resolve14(path), digest(contents));
+        configInputs.set(resolve15(path), digest(contents));
         return contents;
       },
       onUnRecoverableConfigFileDiagnostic() {
@@ -21642,7 +22073,7 @@ async function buildDeliveryProject(options, delivery) {
         if (!target || (kind === "worker" ? target.kind !== "jobs" : target.kind === "jobs")) {
           throw new Error("Delivery host kind does not match its target.");
         }
-        const path = resolve14(sourceRoot, app.source);
+        const path = resolve15(sourceRoot, app.source);
         if (inside(generatedRoot, path) || !/\.[cm]?ts$/.test(path))
           throw new Error("Hosts require application TypeScript source.");
         hosts.set(app.target, { path, kind, hash: digest(await readOwned(sourceRoot, path)) });
@@ -21721,7 +22152,7 @@ async function buildDeliveryProject(options, delivery) {
       for (const [name, contents] of Object.entries(generated))
         await writeArtifact(stage, `generated/${name}`, contents);
       {
-        const program = ts12.createProgram({
+        const program = ts15.createProgram({
           rootNames: [
             ...parsedConfig.fileNames.filter((path) => !inside(generatedRoot, path)),
             ...Object.keys(generated).map((name) => join10(stage, "generated", name))
@@ -21729,12 +22160,12 @@ async function buildDeliveryProject(options, delivery) {
           options: { ...parsedConfig.options, rootDir: project },
           ...parsedConfig.projectReferences ? { projectReferences: parsedConfig.projectReferences } : {}
         });
-        const diagnostics = ts12.getPreEmitDiagnostics(program);
-        if (diagnostics.some((item) => item.category === ts12.DiagnosticCategory.Error)) {
-          return failed(diagnostics.filter((item) => item.category === ts12.DiagnosticCategory.Error).map((item) => ({
+        const diagnostics = ts15.getPreEmitDiagnostics(program);
+        if (diagnostics.some((item) => item.category === ts15.DiagnosticCategory.Error)) {
+          return failed(diagnostics.filter((item) => item.category === ts15.DiagnosticCategory.Error).map((item) => ({
             severity: "error",
             code: "delivery-generated-type-error",
-            message: ts12.flattenDiagnosticMessageText(item.messageText, `
+            message: ts15.flattenDiagnosticMessageText(item.messageText, `
 `),
             ...item.file ? { file: item.file.fileName } : {}
           })));
@@ -21769,7 +22200,7 @@ async function buildDeliveryProject(options, delivery) {
       }));
       const assetInputs = {};
       for (const asset of assets.filter((asset) => asset.target === target.name)) {
-        const path = resolve14(sourceRoot, asset.source);
+        const path = resolve15(sourceRoot, asset.source);
         const bytes = await readOwned(sourceRoot, path);
         const hash = digest(bytes);
         const previousHash = snapshots.get(path);
@@ -21879,13 +22310,13 @@ async function buildDeliveryProject(options, delivery) {
 
 // src/migrations.ts
 import { rename as rename5, readFile as readFile9, writeFile as writeFile4, rm as rm3 } from "node:fs/promises";
-import { relative as relative11, resolve as resolve16 } from "node:path";
-import * as ts13 from "@typescript/typescript6";
+import { relative as relative11, resolve as resolve17 } from "node:path";
+import * as ts16 from "@typescript/typescript6";
 
 // src/migration-policy.ts
 import { readFile as readFile8 } from "node:fs/promises";
 import { readFileSync as readFileSync4 } from "node:fs";
-import { resolve as resolve15 } from "node:path";
+import { resolve as resolve16 } from "node:path";
 var cachedCompilerVersion;
 function compilerVersion() {
   if (cachedCompilerVersion !== undefined)
@@ -21899,9 +22330,9 @@ function compilerVersion() {
 }
 function migrationDependencies() {
   return {
-    "@supacloud/app": "0.19.0",
+    "@supacloud/app": "0.21.0",
     "@supacloud/compiler": compilerVersion(),
-    "@supacloud/elysia": "0.21.0",
+    "@supacloud/elysia": "0.23.0",
     elysia: "2.0.0-beta.19",
     typescript: "7.0.2"
   };
@@ -21910,7 +22341,7 @@ async function checkMigrationDependencies(rootDir) {
   const problems = [];
   for (const [name, expected] of Object.entries(migrationDependencies())) {
     try {
-      const manifest = JSON.parse(await readFile8(resolve15(rootDir, "node_modules", name, "package.json"), "utf8"));
+      const manifest = JSON.parse(await readFile8(resolve16(rootDir, "node_modules", name, "package.json"), "utf8"));
       if (!manifest || typeof manifest !== "object" || !("name" in manifest) || manifest.name !== name || !("version" in manifest) || manifest.version !== expected) {
         problems.push(`${name}: requires tested installed version ${expected}`);
       }
@@ -21924,29 +22355,29 @@ async function checkMigrationDependencies(rootDir) {
 // src/migrations.ts
 var ROUTE_DECORATORS2 = new Set(["Get", "Post", "Put", "Patch", "Delete", "Head", "Options"]);
 var MIGRATION_COMPILER_OPTIONS = {
-  target: ts13.ScriptTarget.ES2022,
-  module: ts13.ModuleKind.ESNext,
-  moduleResolution: ts13.ModuleResolutionKind.Bundler,
+  target: ts16.ScriptTarget.ES2022,
+  module: ts16.ModuleKind.ESNext,
+  moduleResolution: ts16.ModuleResolutionKind.Bundler,
   noEmit: true,
   skipLibCheck: true
 };
 function migrationCompilerOptions(rootDir) {
   if (!rootDir)
     return MIGRATION_COMPILER_OPTIONS;
-  const configPath = ts13.findConfigFile(rootDir, ts13.sys.fileExists);
+  const configPath = ts16.findConfigFile(rootDir, ts16.sys.fileExists);
   if (!configPath)
     return MIGRATION_COMPILER_OPTIONS;
   const configHost = {
-    ...ts13.sys,
+    ...ts16.sys,
     onUnRecoverableConfigFileDiagnostic: (_diagnostic) => {}
   };
-  const parsed = ts13.getParsedCommandLineOfConfigFile(configPath, {}, configHost);
+  const parsed = ts16.getParsedCommandLineOfConfigFile(configPath, {}, configHost);
   if (!parsed || parsed.errors.length > 0)
     return MIGRATION_COMPILER_OPTIONS;
   return { ...parsed.options, noEmit: true, skipLibCheck: true };
 }
 function propertyName2(property) {
-  if (ts13.isIdentifier(property) || ts13.isStringLiteral(property) || ts13.isNumericLiteral(property))
+  if (ts16.isIdentifier(property) || ts16.isStringLiteral(property) || ts16.isNumericLiteral(property))
     return property.text;
   return;
 }
@@ -21956,7 +22387,7 @@ function lineOf2(sourceFile, node) {
 function resolveSymbol(symbol, checker) {
   if (!symbol)
     return;
-  for (let guard = 0;guard < 4 && (symbol.flags & ts13.SymbolFlags.Alias) !== 0; guard += 1) {
+  for (let guard = 0;guard < 4 && (symbol.flags & ts16.SymbolFlags.Alias) !== 0; guard += 1) {
     const aliased = checker.getAliasedSymbol(symbol);
     if (aliased === symbol)
       break;
@@ -21965,12 +22396,12 @@ function resolveSymbol(symbol, checker) {
   return symbol;
 }
 function symbolForExpression(expression, checker) {
-  const location = ts13.isIdentifier(expression) ? expression : ts13.isPropertyAccessExpression(expression) ? expression.name : ts13.isElementAccessExpression(expression) && expression.argumentExpression && ts13.isStringLiteral(expression.argumentExpression) ? expression : undefined;
+  const location = ts16.isIdentifier(expression) ? expression : ts16.isPropertyAccessExpression(expression) ? expression.name : ts16.isElementAccessExpression(expression) && expression.argumentExpression && ts16.isStringLiteral(expression.argumentExpression) ? expression : undefined;
   return location ? resolveSymbol(checker.getSymbolAtLocation(location), checker) : undefined;
 }
 function unwrapExpression(expression) {
   let current = expression;
-  while (ts13.isAsExpression(current) || ts13.isSatisfiesExpression(current) || ts13.isParenthesizedExpression(current) || ts13.isTypeAssertionExpression(current)) {
+  while (ts16.isAsExpression(current) || ts16.isSatisfiesExpression(current) || ts16.isParenthesizedExpression(current) || ts16.isTypeAssertionExpression(current)) {
     current = current.expression;
   }
   return current;
@@ -21985,7 +22416,7 @@ function isRouteDecoratorCall(node, checker) {
   if (node.arguments.length < 2)
     return false;
   const name = node.expression.getText(node.getSourceFile());
-  if (ts13.isIdentifier(node.expression) && ROUTE_DECORATORS2.has(node.expression.text))
+  if (ts16.isIdentifier(node.expression) && ROUTE_DECORATORS2.has(node.expression.text))
     return true;
   if (ROUTE_DECORATORS2.has(name))
     return true;
@@ -21999,14 +22430,14 @@ function resolveStaticObjectLiteral2(input, checker, seen = new Set) {
   if (seen.has(expression))
     return;
   seen.add(expression);
-  if (ts13.isObjectLiteralExpression(expression))
+  if (ts16.isObjectLiteralExpression(expression))
     return expression;
-  if (ts13.isCallExpression(expression) && isDefineRouteContractCall(expression, checker)) {
+  if (ts16.isCallExpression(expression) && isDefineRouteContractCall(expression, checker)) {
     return resolveStaticObjectLiteral2(expression.arguments[0], checker, seen);
   }
   const symbol = symbolForExpression(expression, checker);
   for (const declaration of symbol?.declarations ?? []) {
-    if (ts13.isVariableDeclaration(declaration) && declaration.initializer) {
+    if (ts16.isVariableDeclaration(declaration) && declaration.initializer) {
       const resolved = resolveStaticObjectLiteral2(declaration.initializer, checker, seen);
       if (resolved)
         return resolved;
@@ -22020,25 +22451,25 @@ function displayFile(rootDir, fileName) {
 }
 function createMigrationProgram(fileNames, sourceOverrides, rootDir) {
   const compilerOptions = migrationCompilerOptions(rootDir);
-  const host = ts13.createCompilerHost(compilerOptions);
+  const host = ts16.createCompilerHost(compilerOptions);
   const getSourceFile = host.getSourceFile.bind(host);
   const fileExists = host.fileExists.bind(host);
   const readFile = host.readFile.bind(host);
   const currentDirectory = host.getCurrentDirectory.bind(host);
-  host.fileExists = (fileName) => sourceOverrides.has(resolve16(fileName)) || fileExists(fileName);
-  host.readFile = (fileName) => sourceOverrides.get(resolve16(fileName)) ?? readFile(fileName);
+  host.fileExists = (fileName) => sourceOverrides.has(resolve17(fileName)) || fileExists(fileName);
+  host.readFile = (fileName) => sourceOverrides.get(resolve17(fileName)) ?? readFile(fileName);
   host.getSourceFile = (fileName, languageVersion, onError, shouldCreateNewSourceFile) => {
-    const source = sourceOverrides.get(resolve16(fileName));
-    return source === undefined ? getSourceFile(fileName, languageVersion, onError, shouldCreateNewSourceFile) : ts13.createSourceFile(fileName, source, languageVersion, true);
+    const source = sourceOverrides.get(resolve17(fileName));
+    return source === undefined ? getSourceFile(fileName, languageVersion, onError, shouldCreateNewSourceFile) : ts16.createSourceFile(fileName, source, languageVersion, true);
   };
   host.getCurrentDirectory = () => rootDir ?? currentDirectory();
-  return ts13.createProgram(fileNames, compilerOptions, host);
+  return ts16.createProgram(fileNames, compilerOptions, host);
 }
 function routeResponseProperties(object) {
-  const responseProperties = object.properties.filter((property) => ts13.isPropertyAssignment(property) && propertyName2(property.name) === "response");
+  const responseProperties = object.properties.filter((property) => ts16.isPropertyAssignment(property) && propertyName2(property.name) === "response");
   return {
     response: responseProperties[0],
-    hasResponses: object.properties.some((property) => (ts13.isPropertyAssignment(property) || ts13.isShorthandPropertyAssignment(property)) && propertyName2(property.name) === "responses"),
+    hasResponses: object.properties.some((property) => (ts16.isPropertyAssignment(property) || ts16.isShorthandPropertyAssignment(property)) && propertyName2(property.name) === "responses"),
     duplicateResponse: responseProperties.length > 1
   };
 }
@@ -22054,15 +22485,15 @@ function planRouteResponseMigration(sourceFiles, checker, rootDir, includedFiles
     issues.push(issue);
   };
   for (const sourceFile of sourceFiles) {
-    const sourcePath = resolve16(sourceFile.fileName);
+    const sourcePath = resolve17(sourceFile.fileName);
     if (!includedFiles.has(sourcePath))
       continue;
     const visit = (node) => {
-      if (ts13.isCallExpression(node) && isRouteDecoratorCall(node, checker)) {
+      if (ts16.isCallExpression(node) && isRouteDecoratorCall(node, checker)) {
         const options = node.arguments[1];
         const object = options && resolveStaticObjectLiteral2(options, checker);
         if (object) {
-          const objectPath = resolve16(object.getSourceFile().fileName);
+          const objectPath = resolve17(object.getSourceFile().fileName);
           const properties = routeResponseProperties(object);
           if (properties.response) {
             if (!includedFiles.has(objectPath)) {
@@ -22078,7 +22509,7 @@ function planRouteResponseMigration(sourceFiles, checker, rootDir, includedFiles
           }
         }
       }
-      ts13.forEachChild(node, visit);
+      ts16.forEachChild(node, visit);
     };
     visit(sourceFile);
   }
@@ -22105,13 +22536,13 @@ function planRouteResponseMigration(sourceFiles, checker, rootDir, includedFiles
         line: lineOf2(sourceFile, response)
       });
     } else {
-      const replacements = replacementsByFile.get(resolve16(sourceFile.fileName)) ?? [];
+      const replacements = replacementsByFile.get(resolve17(sourceFile.fileName)) ?? [];
       replacements.push({
         start: response.getStart(sourceFile),
         end: response.getEnd(),
         text: `responses: { 200: ${response.initializer.getText(sourceFile)} }`
       });
-      replacementsByFile.set(resolve16(sourceFile.fileName), replacements);
+      replacementsByFile.set(resolve17(sourceFile.fileName), replacements);
     }
   }
   return { replacementsByFile, issues };
@@ -22124,7 +22555,7 @@ function applyReplacements(source, replacements) {
   return content;
 }
 function migrateRouteResponse(source, fileName) {
-  const absoluteFile = resolve16(fileName);
+  const absoluteFile = resolve17(fileName);
   const sourceOverrides = new Map([[absoluteFile, source]]);
   const program = createMigrationProgram([absoluteFile], sourceOverrides);
   const sourceFile = program.getSourceFile(absoluteFile);
@@ -22140,7 +22571,7 @@ function migrateRouteResponse(source, fileName) {
       }]
     };
   }
-  const plan = planRouteResponseMigration([sourceFile], program.getTypeChecker(), resolve16("."), new Set([absoluteFile]));
+  const plan = planRouteResponseMigration([sourceFile], program.getTypeChecker(), resolve17("."), new Set([absoluteFile]));
   const replacements = plan.replacementsByFile.get(absoluteFile) ?? [];
   return {
     changed: replacements.length > 0,
@@ -22150,7 +22581,7 @@ function migrateRouteResponse(source, fileName) {
   };
 }
 function migrateRouteResponseProject(files, rootDir, sourceByPath) {
-  const absoluteFiles = files.map((file) => resolve16(file));
+  const absoluteFiles = files.map((file) => resolve17(file));
   const program = createMigrationProgram(absoluteFiles, sourceByPath, rootDir);
   const sourceFiles = absoluteFiles.map((file) => program.getSourceFile(file)).filter((file) => file !== undefined);
   const plan = planRouteResponseMigration(sourceFiles, program.getTypeChecker(), rootDir, new Set(absoluteFiles));
@@ -22163,11 +22594,11 @@ function migrateRouteResponseProject(files, rootDir, sourceByPath) {
       changed: replacements.length > 0,
       content: applyReplacements(source, replacements),
       replacements: replacements.length,
-      issues: plan.issues.filter((issue) => resolve16(rootDir, issue.file) === file)
+      issues: plan.issues.filter((issue) => resolve17(rootDir, issue.file) === file)
     });
   }
   for (const issue of plan.issues) {
-    const path = resolve16(rootDir, issue.file);
+    const path = resolve17(rootDir, issue.file);
     if (!results.has(path) && sourceByPath.has(path)) {
       results.set(path, {
         changed: false,
@@ -22186,6 +22617,13 @@ var SUPACLOUD_MIGRATIONS = [
     to: "0.12.0",
     description: "Replace deprecated route response schemas with explicit HTTP status maps.",
     apply: migrateRouteResponse
+  },
+  {
+    id: "http-provider-entrypoint",
+    from: "0.12.0",
+    to: "0.13.0",
+    description: "Move provider-only withInterceptors imports to the shared HTTP feature entry; reject ambiguous uses.",
+    apply: migrateHttpProviderImports
   }
 ];
 async function writeAtomically(path, content) {
@@ -22198,7 +22636,7 @@ async function writeAtomically(path, content) {
   }
 }
 async function migrateProject(options) {
-  const rootDir = resolve16(options.rootDir);
+  const rootDir = resolve17(options.rootDir);
   let migrations = SUPACLOUD_MIGRATIONS;
   const preflightIssues = [];
   if (options.fromVersion !== undefined || options.toVersion !== undefined) {
@@ -22238,7 +22676,7 @@ async function migrateProject(options) {
     }
   }
   const include = options.include ?? ["**/*.ts", "**/*.tsx", "**/*.mts", "**/*.cts"];
-  const files = ts13.sys.readDirectory(rootDir, [".ts", ".tsx", ".mts", ".cts"], ["node_modules", "dist", "generated"], include).sort();
+  const files = ts16.sys.readDirectory(rootDir, [".ts", ".tsx", ".mts", ".cts"], ["node_modules", "dist", "generated"], include).sort();
   const results = [];
   const issues = [];
   const pendingWrites = new Map;
@@ -22254,7 +22692,7 @@ async function migrateProject(options) {
     }
   };
   for (const filePath of files) {
-    sourceByPath.set(resolve16(filePath), await readFile9(filePath, "utf8"));
+    sourceByPath.set(resolve17(filePath), await readFile9(filePath, "utf8"));
   }
   const originalSources = new Map(sourceByPath);
   const writtenFiles = new Set;
@@ -22263,7 +22701,7 @@ async function migrateProject(options) {
     if (projectResults)
       appendIssues(projectResults.issues);
     for (const filePath of files) {
-      const absoluteFile = resolve16(filePath);
+      const absoluteFile = resolve17(filePath);
       const file = relative11(rootDir, absoluteFile) || absoluteFile;
       const before = sourceByPath.get(absoluteFile);
       if (before === undefined)
@@ -22323,13 +22761,13 @@ async function migrateProject(options) {
 }
 
 // src/migration-assess.ts
-import { createHash as createHash9 } from "node:crypto";
+import { createHash as createHash10 } from "node:crypto";
 import { readFile as readFile11 } from "node:fs/promises";
-import { join as join11, resolve as resolve18 } from "node:path";
+import { join as join11, resolve as resolve19 } from "node:path";
 
 // src/openapi-tools.ts
 import { mkdir as mkdir4, readFile as readFile10, rename as rename6, unlink as unlink3, writeFile as writeFile5 } from "node:fs/promises";
-import { dirname as dirname10, resolve as resolve17 } from "node:path";
+import { dirname as dirname10, resolve as resolve18 } from "node:path";
 import { pathToFileURL as pathToFileURL2 } from "node:url";
 
 class OpenApiDocumentError extends Error {
@@ -22720,7 +23158,7 @@ function serializeOpenApiJson(document, space = 2) {
 }
 async function readOpenApiJson(path) {
   try {
-    const value = JSON.parse(await readFile10(resolve17(path), "utf8"));
+    const value = JSON.parse(await readFile10(resolve18(path), "utf8"));
     return parseOpenApiDocument(value);
   } catch (error) {
     if (error instanceof OpenApiDocumentError)
@@ -22729,7 +23167,7 @@ async function readOpenApiJson(path) {
   }
 }
 async function writeOpenApiJson(document, outputPath, space = 2) {
-  const path = resolve17(outputPath);
+  const path = resolve18(outputPath);
   const content = serializeOpenApiJson(document, space);
   await mkdir4(dirname10(path), { recursive: true });
   try {
@@ -22750,7 +23188,7 @@ async function writeOpenApiJson(document, outputPath, space = 2) {
 }
 async function loadGeneratedOpenApiDocument(modulePath) {
   try {
-    const moduleUrl = pathToFileURL2(resolve17(modulePath));
+    const moduleUrl = pathToFileURL2(resolve18(modulePath));
     moduleUrl.searchParams.set("supacloud-openapi-export", "1");
     const loaded = await import(moduleUrl.href);
     if (!isRecord(loaded))
@@ -22847,17 +23285,17 @@ function arrayLength(value) {
   return Array.isArray(value) ? value.length : undefined;
 }
 async function sha256(path) {
-  return createHash9("sha256").update(await readFile11(path)).digest("hex");
+  return createHash10("sha256").update(await readFile11(path)).digest("hex");
 }
 function overallStatus(findings) {
   return findings.reduce((current, finding) => STATUS_PRIORITY[finding.status] > STATUS_PRIORITY[current] ? finding.status : current, "compatible");
 }
 async function assessMigration(options) {
-  const projectDir = resolve18(options.projectDir);
+  const projectDir = resolve19(options.projectDir);
   const compile = {
     ...options.compile,
-    rootDir: resolve18(options.compile.rootDir),
-    outDir: resolve18(options.compile.outDir)
+    rootDir: resolve19(options.compile.rootDir),
+    outDir: resolve19(options.compile.outDir)
   };
   const findings = [];
   const dependencyProblems = await checkMigrationDependencies(projectDir);
@@ -22937,8 +23375,8 @@ async function assessMigration(options) {
   }
   let openApi;
   if (options.baselineOpenApiPath && options.currentOpenApiPath) {
-    const baselinePath = resolve18(projectDir, options.baselineOpenApiPath);
-    const currentPath = resolve18(projectDir, options.currentOpenApiPath);
+    const baselinePath = resolve19(projectDir, options.baselineOpenApiPath);
+    const currentPath = resolve19(projectDir, options.currentOpenApiPath);
     try {
       const diff = diffOpenApiDocuments(await readOpenApiJson(baselinePath), await readOpenApiJson(currentPath));
       openApi = {
@@ -23032,6 +23470,7 @@ function printUsage() {
 Usage:
   supacloud-compiler compile [rootDir] [options]
   supacloud-compiler check   [rootDir] [options]
+  supacloud-compiler diagnostics [rootDir] [--json]
   supacloud-compiler dev     [rootDir] [options]
   supacloud-compiler graph   [rootDir] [options]
   supacloud-compiler explain <name> [rootDir] [options]
@@ -23053,6 +23492,7 @@ Usage:
 Commands:
   compile             Compile application modules and generate artifacts
   check               Check artifact drift and run governance gates
+  diagnostics         Read-only editor diagnostics and validated semantic code actions
   dev                 Watch source files and recompile on changes
   graph               Print the discovered application graph
   explain             Explain a module, provider, or external token
@@ -23131,7 +23571,7 @@ async function run() {
       process.exitCode = 1;
     return;
   }
-  if (!command || !["compile", "check", "dev", "graph", "explain", "context", "dev-context", "environment-bindings", "doctor", "migrate", "migration-assess", "fix", "graphql-schema", "plan", "build-delivery", "openapi-export", "openapi-diff"].includes(command)) {
+  if (!command || !["compile", "check", "diagnostics", "dev", "graph", "explain", "context", "dev-context", "environment-bindings", "doctor", "migrate", "migration-assess", "fix", "graphql-schema", "plan", "build-delivery", "openapi-export", "openapi-diff"].includes(command)) {
     console.error(`Error: unknown command "${command}"`);
     printUsage();
     process.exit(1);
@@ -23300,7 +23740,7 @@ async function run() {
     } else if (arg === "--dry-run") {
       dryRun = true;
     } else if (arg === "--write") {
-      if (command === "context" || command === "dev-context" || command === "environment-bindings")
+      if (command === "context" || command === "dev-context" || command === "diagnostics" || command === "environment-bindings")
         throw new Error(`${command} is read-only; --write is not supported`);
       if (command === "plan" || command === "migration-assess")
         throw new Error(`${command} is read-only; --write is not supported`);
@@ -23365,7 +23805,7 @@ async function run() {
       throw new Error("Build context requires a manifest, target, subject, events, request ID and --json");
     }
     try {
-      const pack = await createDeliveryExecutionContextPack(contextManifest, contextTarget, query, await readExecutionMetadata(resolve22(executionEventsPath)), executionRequestId);
+      const pack = await createDeliveryExecutionContextPack(contextManifest, contextTarget, query, await readExecutionMetadata(resolve23(executionEventsPath)), executionRequestId);
       console.log(JSON.stringify(pack, null, 2));
     } catch (error) {
       console.log(JSON.stringify({
@@ -23384,7 +23824,7 @@ async function run() {
     const currentPath = openApiDiffPaths[1];
     if (!basePath || !currentPath)
       throw new Error("openapi-diff requires two JSON file paths");
-    const result = diffOpenApiDocuments(await readOpenApiJson(resolve22(process.cwd(), basePath)), await readOpenApiJson(resolve22(process.cwd(), currentPath)));
+    const result = diffOpenApiDocuments(await readOpenApiJson(resolve23(process.cwd(), basePath)), await readOpenApiJson(resolve23(process.cwd(), currentPath)));
     console.log(json ? JSON.stringify(result, null, 2) : formatOpenApiDiff(result));
     if (!result.ok)
       process.exitCode = 1;
@@ -23399,8 +23839,8 @@ async function run() {
     if (!modulePath || !outputPath)
       throw new Error("openapi-export requires an OpenAPI module and output path");
     const result = await exportGeneratedOpenApiJson({
-      modulePath: resolve22(process.cwd(), modulePath),
-      outputPath: resolve22(process.cwd(), outputPath),
+      modulePath: resolve23(process.cwd(), modulePath),
+      outputPath: resolve23(process.cwd(), outputPath),
       ...openApiExportSpace === undefined ? {} : { space: openApiExportSpace }
     });
     console.log(json ? JSON.stringify({ ok: true, ...result }, null, 2) : result.written ? `OpenAPI JSON written: ${result.path}` : `OpenAPI JSON matches: ${result.path}`);
@@ -23408,7 +23848,7 @@ async function run() {
   }
   if (command === "migrate") {
     const result = await migrateProject({
-      rootDir: rootDir ? resolve22(process.cwd(), rootDir) : process.cwd(),
+      rootDir: rootDir ? resolve23(process.cwd(), rootDir) : process.cwd(),
       write: !dryRun,
       ...fromVersion === undefined ? {} : { fromVersion },
       ...toVersion === undefined ? {} : { toVersion }
@@ -23446,8 +23886,8 @@ async function run() {
   if (checkSchema && command !== "graphql-schema")
     throw new Error("--check is only supported by graphql-schema");
   const defaults = resolveSupacloudConfig(loadedConfig, process.cwd());
-  const resolvedRoot = rootDir ? resolve22(process.cwd(), rootDir) : defaults.rootDir;
-  const resolvedOut = outDir ? resolve22(process.cwd(), outDir) : defaults.outDir;
+  const resolvedRoot = rootDir ? resolve23(process.cwd(), rootDir) : defaults.rootDir;
+  const resolvedOut = outDir ? resolve23(process.cwd(), outDir) : defaults.outDir;
   const configured = compileOptionsFromConfig({
     ...loadedConfig,
     root: resolvedRoot,
@@ -23466,7 +23906,7 @@ async function run() {
     let delivery = loadedConfig.delivery;
     if (deliveryPath !== undefined) {
       try {
-        delivery = JSON.parse(await readFile14(resolve22(process.cwd(), deliveryPath), "utf8"));
+        delivery = JSON.parse(await readFile14(resolve23(process.cwd(), deliveryPath), "utf8"));
       } catch {
         throw new DeliveryConfigurationError;
       }
@@ -23524,9 +23964,24 @@ ${item.suggestion ?? ""}`).join(`
   } else if (command === "fix") {
     if (!query)
       throw new Error("fix requires a JSON file containing one DiagnosticFix");
-    const fix = JSON.parse(await readFile14(resolve22(process.cwd(), query), "utf8"));
-    const result = await applyDiagnosticFix(fix, { rootDir: resolvedRoot, dryRun });
+    const input = JSON.parse(await readFile14(resolve23(process.cwd(), query), "utf8"));
+    const envelope = input && typeof input === "object" && "fix" in input;
+    if (envelope && (typeof input.expectedSourceHash !== "string" || !/^[a-f0-9]{64}$/.test(input.expectedSourceHash))) {
+      throw new Error("Editor fix requires the source hash from its validated preview");
+    }
+    const result = await applyDiagnosticFix(envelope ? input.fix : input, {
+      rootDir: resolvedRoot,
+      dryRun,
+      ...envelope ? { expectedSourceHash: input.expectedSourceHash } : {}
+    });
     console.log(JSON.stringify({ ok: true, ...result }, null, 2));
+  } else if (command === "diagnostics") {
+    const result = await checkProject(compileDefaults);
+    console.log(JSON.stringify({
+      report: createDiagnosticReport(result.diagnostics),
+      diagnostics: toEditorDiagnostics(result.diagnostics),
+      actions: await createEditorCodeActions(result.diagnostics, { rootDir: resolvedRoot })
+    }, null, 2));
   } else if (command === "compile") {
     const result = await compileProject(compileDefaults);
     const errors = result.diagnostics.filter((d) => d.severity === "error");
@@ -23650,7 +24105,7 @@ Source change detected; compiling...`);
       process.exitCode = 1;
       return;
     }
-    const file = resolve22(rootDir ? resolve22(process.cwd(), rootDir) : process.cwd(), bindingsFile ?? "supacloud.environments.json");
+    const file = resolve23(rootDir ? resolve23(process.cwd(), rootDir) : process.cwd(), bindingsFile ?? "supacloud.environments.json");
     try {
       const document = await readEnvironmentBindingsFile(file);
       const graph = await analyzeProject(resolvedRoot);
@@ -23685,7 +24140,7 @@ Source change detected; compiling...`);
     try {
       const result = await checkProject(compileDefaults);
       if (executionEventsPath && executionRequestId) {
-        const pack = createExecutionContextPack({ ...result.graph, diagnostics: result.diagnostics }, query, await readExecutionMetadata(resolve22(process.cwd(), executionEventsPath)), executionRequestId);
+        const pack = createExecutionContextPack({ ...result.graph, diagnostics: result.diagnostics }, query, await readExecutionMetadata(resolve23(process.cwd(), executionEventsPath)), executionRequestId);
         console.log(JSON.stringify(pack, null, 2));
         return;
       }