@supacloud/compiler 0.25.0 → 0.26.0

package/dist/index.js

@@ -128,7 +128,9 @@ function buildContractManifest(graph, artifacts) {
           ...route.responses === undefined ? {} : {
             responseSchemas: Object.fromEntries(Object.entries(route.responses).sort(([left], [right]) => left.localeCompare(right)))
           },
-          ...route.contract?.evidence === undefined ? {} : { evidence: route.contract.evidence }
+          ...route.contract?.evidence === undefined ? {} : { evidence: route.contract.evidence },
+          ...route.parse === undefined ? {} : { parse: route.parse },
+          ...route.allowDeleteBody === undefined ? {} : { allowDeleteBody: route.allowDeleteBody }
         });
       }
     }
@@ -217,7 +219,7 @@ function renderApplication(graph, options) {
       providers: mod.providers.filter((p) => p.providedIn !== "root" || p.multi || referencedTokens.has(p.token) || p.exported)
     }));
   }
-  const imports = new ImportManager;
+  const imports = new ImportManager(new Set(["CompiledApplicationModule"]));
   const factorySections = [];
   const descriptorEntries = [];
   for (const module of modules) {
@@ -234,7 +236,13 @@ function renderApplication(graph, options) {
     "",
     TYPE_GUARDS,
     "",
-    "export function createCompiledModules(): CompiledModule[] {",
+    ...modules.length > 0 ? [
+      'export type CompiledApplicationModule = Omit<CompiledModule, "name" | "createServices"> & (',
+      ...modules.map((module) => `  | { name: ${JSON.stringify(module.name)}; createServices: typeof create${pascalName(module.name)}Services }`),
+      ");"
+    ] : ["export type CompiledApplicationModule = CompiledModule;"],
+    "",
+    "export function createCompiledModules(): CompiledApplicationModule[] {",
     "  return [",
     ...descriptorEntries.map((entry) => indent(entry, 4) + ","),
     "  ];",
@@ -315,7 +323,9 @@ function renderApplication(graph, options) {
   };
 }
 async function generateApplication(graph, options) {
-  const rendered = renderApplication(graph, options);
+  return writeRenderedApplication(renderApplication(graph, options), options);
+}
+async function writeRenderedApplication(rendered, options) {
   await mkdir(options.outDir, { recursive: true });
   const applicationPath = join2(options.outDir, "application.ts");
   const manifestPath = join2(options.outDir, "app.manifest.json");
@@ -402,8 +412,12 @@ function indent(text, spaces) {
 }
 
 class ImportManager {
+  reserved;
   entries = new Map;
   lookup = new Map;
+  constructor(reserved = new Set) {
+    this.reserved = reserved;
+  }
   get size() {
     return this.entries.size;
   }
@@ -418,7 +432,7 @@ class ImportManager {
       return existing;
     let local = exported;
     let counter = 2;
-    while (this.entries.has(local)) {
+    while (this.entries.has(local) || this.reserved.has(local)) {
       local = `${exported}${counter}`;
       counter += 1;
     }
@@ -475,7 +489,7 @@ class ModuleGenerator {
   renderDescriptor() {
     const lines = [
       `{`,
-      `  name: ${JSON.stringify(this.module.name)},`,
+      `  name: ${JSON.stringify(this.module.name)} as const,`,
       `  createServices: create${this.pascal}Services,`
     ];
     if (this.hasFactoryContent("request")) {
@@ -614,6 +628,10 @@ class ModuleGenerator {
         if (route.contract !== undefined) {
           fields.push(`contract: ${JSON.stringify(route.contract)}`);
         }
+        if (route.parse === "none")
+          fields.push('parse: "none"');
+        if (route.allowDeleteBody === true)
+          fields.push("allowDeleteBody: true");
         if (route.schemaKinds !== undefined && Object.keys(route.schemaKinds).length > 0) {
           fields.push(`schemaKinds: ${JSON.stringify(route.schemaKinds)}`);
         }
@@ -713,7 +731,7 @@ ${indent(item, 2)}`).join(",")}
       `function create${this.pascal}Services(`,
       `  deps: Record<string, unknown>,`,
       `  imported: Record<string, Record<string, unknown>>,`,
-      `): Record<string, unknown> {`,
+      `) {`,
       indent(this.renderFactoryBody("services"), 2),
       `}`
     ].join(`
@@ -810,7 +828,7 @@ ${indent(item, 2)}`).join(",")}
 `);
     }
     const entries = [...returns.entries()].map(([key, expr]) => key === expr ? key : `${key}: ${expr}`);
-    lines.push(`return { ${entries.join(", ")} };`);
+    lines.push(`return retainPlatformDependencies({ ${entries.join(", ")} }, deps);`);
     return lines.join(`
 `);
   }
@@ -911,6 +929,9 @@ ${indent(item, 2)}`).join(",")}
         return this.depExpr(own.useExisting ?? token, kind, options);
       }
     }
+    if (own && factoryOfScope(own.scope) === "services" && kind !== "services" && !isSkipSelf && !isSelf) {
+      return `services.${camelName(token)}`;
+    }
     if (isSelf) {
       return isOptional ? "undefined" : `services.${camelName(token)}`;
     }
@@ -928,13 +949,14 @@ ${indent(item, 2)}`).join(",")}
         return `imported.${mod.name}.${camelName(token)}`;
       }
     }
-    if (isOptional && !this.graph.externalTokens.includes(token)) {
-      return "undefined";
-    }
     if (isSelf)
       return isOptional ? "undefined" : `services.${camelName(token)}`;
     if (kind === "services")
       return isOptional ? `(deps.${camelName(token)} ?? undefined)` : `deps.${camelName(token)}`;
+    if (!own || isSkipSelf) {
+      const external = `platformDependencies.get(services)?.${camelName(token)}`;
+      return isOptional ? `(${external} ?? undefined)` : external;
+    }
     return isOptional ? `(services.${camelName(token)} ?? undefined)` : `services.${camelName(token)}`;
   }
 }
@@ -962,7 +984,7 @@ function orderProviders(providers) {
 function renderClient(graph, options) {
   const rootDir = options?.rootDir ?? process.cwd();
   const outDir = options?.outDir ?? process.cwd();
-  const imports = new ImportManager;
+  const imports = new ImportManager(new Set(["ApiClientError", "ApiClientErrorCode", "ApiClientErrorDetails"]));
   const controllerEntries = [];
   const routeTypes = [];
   const schemaEntries = [];
@@ -1020,11 +1042,14 @@ function renderClient(graph, options) {
         }).filter((entry) => entry.length === 2));
         if (Object.keys(responseSchemas).length > 0)
           usesValue = true;
-        const paramNames = [...new Set((fullPath.match(/:([a-zA-Z0-9_]+)/g) ?? []).map((p) => p.slice(1)))];
+        const paramNames = [...new Set([
+          ...(fullPath.match(/:([a-zA-Z0-9_]+)/g) ?? []).map((p) => p.slice(1)),
+          ...fullPath.endsWith("/*") ? ["*"] : []
+        ])];
         const pathParamsType = paramNames.length > 0 ? `{ ${paramNames.map((p) => `${/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(p) ? p : JSON.stringify(p)}: string | number`).join("; ")} }` : "Record<string, string | number>";
         const paramsType = paramsSchema ? `Static<typeof ${paramsSchema.local}>${paramNames.length > 0 ? ` & ${pathParamsType}` : ""}` : pathParamsType;
         const queryType = querySchema ? `Static<typeof ${querySchema.local}>` : "Record<string, unknown>";
-        const bodyType = bodySchema ? `Static<typeof ${bodySchema.local}>` : "unknown";
+        const bodyType = route.parse === "none" ? "BodyInit" : bodySchema ? `Static<typeof ${bodySchema.local}>` : "unknown";
         const headersType = headersSchema ? `Static<typeof ${headersSchema.local}>` : "Record<string, string>";
         const cookieType = cookieSchema ? `Static<typeof ${cookieSchema.local}>` : "Record<string, string | number | boolean>";
         const responseTypes = [
@@ -1061,7 +1086,9 @@ function renderClient(graph, options) {
           ["queryTransforms", route.queryTransforms],
           ["queryDefaults", route.queryDefaults],
           ["title", route.title],
-          ["data", route.data]
+          ["data", route.data],
+          ["parse", route.parse],
+          ["allowDeleteBody", route.allowDeleteBody]
         ]) {
           if (value !== undefined)
             routeFields.push(`${key}: ${JSON.stringify(value)}`);
@@ -1095,7 +1122,7 @@ function renderClient(graph, options) {
         const responseSchemaArgument = responseSchemaEntries.length > 0 ? `{ ${responseSchemaEntries.map(([status, local]) => `${JSON.stringify(status)}: ${local}`).join(", ")} }` : "undefined";
         const responseKindArgument = responseKind === undefined ? "undefined" : JSON.stringify(responseKind);
         routeMethods.push(`
-    ${route.handler}: makeRoute<${requestTypeName}, ${responseType === "never" ? "never" : responseTypeName}>(${JSON.stringify(route.method)}, ${JSON.stringify(fullPath)}, ${responseSchemaArgument}, ${responseKindArgument}),`);
+    ${route.handler}: makeRoute<${requestTypeName}, ${responseType === "never" ? "never" : responseTypeName}>(${JSON.stringify(route.method)}, ${JSON.stringify(fullPath)}, ${responseSchemaArgument}, ${responseKindArgument}, ${route.parse === "none"}),`);
       }
       controllerEntries.push(`
   ${controllerKey}: {${routeMethods.join("")}
@@ -1126,6 +1153,40 @@ function renderClient(graph, options) {
     "",
     "export type ResponseDecoder<T> = (value: unknown) => T;",
     "",
+    'export type ApiClientErrorCode = "API_HTTP_ERROR" | "API_RESPONSE_INVALID" | "API_RESPONSE_UNDECLARED";',
+    "",
+    "export interface ApiClientErrorDetails {",
+    "  code: ApiClientErrorCode;",
+    "  method: string;",
+    "  path: string;",
+    "  status: number;",
+    "  requestId?: string | null;",
+    "  response?: Response;",
+    "}",
+    "",
+    "/** Transport/contract metadata, not proof that a failed write rolled back. */",
+    "export class ApiClientError extends Error {",
+    "  readonly code: ApiClientErrorCode;",
+    "  readonly method: string;",
+    "  readonly path: string;",
+    "  readonly status: number;",
+    "  readonly requestId: string | undefined;",
+    "  /** Undeclared HTTP response for explicit inspection; excluded from JSON serialization. */",
+    "  readonly response: Response | undefined;",
+    "  constructor(message: string, details: ApiClientErrorDetails) {",
+    "    super(message);",
+    '    this.name = "ApiClientError";',
+    "    const { code, method, path, status, requestId, response } = details;",
+    "    this.code = code;",
+    "    this.method = method;",
+    "    this.path = path;",
+    "    this.status = status;",
+    "    this.requestId = requestId && /^[A-Za-z0-9._:-]{1,256}$/.test(requestId) ? requestId : undefined;",
+    "    this.response = response;",
+    '    Object.defineProperty(this, "response", { enumerable: false });',
+    "  }",
+    "}",
+    "",
     "export type RouteMethod<",
     "  Options extends ClientRequestOptions = ClientRequestOptions,",
     "  Result = never,",
@@ -1179,6 +1240,13 @@ function renderClient(graph, options) {
     '    if (typeof value !== "string" && typeof value !== "number") throw new TypeError(`Missing route parameter: ${key}`);',
     "    return encodeURIComponent(String(value));",
     "  });",
+    '  if (path.endsWith("/*")) {',
+    '    const wildcard = params && Object.hasOwn(params, "*") ? params["*"] : undefined;',
+    '    if (typeof wildcard !== "string" && typeof wildcard !== "number") throw new TypeError("Missing route parameter: *");',
+    '    const segments = String(wildcard).split("/");',
+    '    if (segments.some(segment => segment === "." || segment === "..")) throw new TypeError("Wildcard dot segments are not supported by Fetch URLs");',
+    '    url = url.slice(0, -1) + segments.map(encodeURIComponent).join("/");',
+    "  }",
     "  if (query) {",
     "    const searchParams = new URLSearchParams();",
     "    for (const [k, v] of Object.entries(query)) {",
@@ -1365,6 +1433,10 @@ function renderClient(graph, options) {
     "export function createApiClient(config: ApiClientConfig = {}) {",
     "  const fetcher = config.fetch ?? globalThis.fetch.bind(globalThis);",
     '  const baseUrl = (config.baseUrl ?? "").replace(/\\/+$/, "");',
+    "  function rawBody(value: unknown): BodyInit {",
+    '    if (typeof value === "string" || value instanceof Blob || value instanceof FormData || value instanceof URLSearchParams || value instanceof ArrayBuffer || ArrayBuffer.isView(value) || value instanceof ReadableStream) return value as BodyInit;',
+    '    throw new TypeError("Raw routes require a BodyInit value; JSON encoding is not implicit");',
+    "  }",
     "",
     "  async function request<T>(",
     "    method: string,",
@@ -1373,6 +1445,7 @@ function renderClient(graph, options) {
     "    decode: ResponseDecoder<T>,",
     `    responseSchemas?: Readonly<Record<string, ${responseSchemaType}>>,`,
     "    responseKind?: string,",
+    "    raw?: boolean,",
     "  ): Promise<T>;",
     "  async function request<T>(",
     "    method: string,",
@@ -1381,6 +1454,7 @@ function renderClient(graph, options) {
     "    decode?: ResponseDecoder<T>,",
     `    responseSchemas?: Readonly<Record<string, ${responseSchemaType}>>,`,
     "    responseKind?: string,",
+    "    raw?: boolean,",
     "  ): Promise<T | unknown>;",
     "  async function request(",
     "    method: string,",
@@ -1394,11 +1468,12 @@ function renderClient(graph, options) {
     "    decode?: ResponseDecoder<T>,",
     `    responseSchemas?: Readonly<Record<string, ${responseSchemaType}>>,`,
     "    responseKind?: string,",
+    "    raw = false,",
     "  ): Promise<T | unknown> {",
     "    const url = `${baseUrl}${buildRouteUrl(path, options.params, options.query)}`;",
     '    const customHeaders = typeof config.headers === "function" ? await config.headers() : config.headers;',
     "    const headers: Record<string, string> = {",
-    '      "content-type": "application/json",',
+    '      ...(raw ? {} : { "content-type": "application/json" }),',
     "      ...customHeaders,",
     "      ...options.headers,",
     "    };",
@@ -1417,21 +1492,27 @@ function renderClient(graph, options) {
     "      return fetcher(reqPayload.url, {",
     "        method: reqPayload.method,",
     "        headers: reqPayload.headers,",
-    "        ...(reqPayload.body === undefined ? {} : { body: JSON.stringify(reqPayload.body) }),",
+    "        ...(reqPayload.body === undefined ? {} : { body: raw ? rawBody(reqPayload.body) : JSON.stringify(reqPayload.body) }),",
+    '        ...(raw && reqPayload.body instanceof ReadableStream ? { duplex: "half" } : {}),',
     "      });",
     "    };",
     "    const response = await executeChain(0, { method, url, headers, body: options.body });",
     "    const declaredSchema = responseSchemas ? selectResponseSchema(response.status, responseSchemas) : undefined;",
+    "    const failure = (code: ApiClientErrorCode, message: string) => new ApiClientError(message, {",
+    '      code, method, path, status: response.status, requestId: response.headers.get("x-request-id"),',
+    '      ...(code === "API_HTTP_ERROR" ? { response } : {}),',
+    "    });",
     "    if (!response.ok && declaredSchema === undefined) {",
-    "      const errBody = await response.text();",
-    "      throw new Error(`API request failed: ${method} ${path} -> ${response.status} ${errBody}`);",
+    '      throw failure("API_HTTP_ERROR", `API request failed: ${method} ${path} -> ${response.status}`);',
     "    }",
     '    const contentType = response.headers?.get("content-type") ?? "";',
     "    let value: unknown;",
     "    if ([204, 205, 304].includes(response.status)) {",
     "      value = undefined;",
     '    } else if (contentType.includes("application/json") || contentType.includes("+json")) {',
-    "      value = await response.json();",
+    "      const responseText = await response.text();",
+    "      try { value = JSON.parse(responseText); }",
+    '      catch { throw failure("API_RESPONSE_INVALID", "Response is not valid JSON"); }',
     '    } else if (responseKind === "binary" || contentType.includes("application/octet-stream")) {',
     "      value = await response.arrayBuffer();",
     '    } else if (responseKind === "stream") {',
@@ -1442,20 +1523,24 @@ function renderClient(graph, options) {
     "    if (!responseSchemas) return decode ? decode(value) : value;",
     "    if (declaredSchema === undefined) {",
     '      const transportSuccess = response.ok && (responseKind === "binary" || responseKind === "stream");',
-    "      if (!transportSuccess) throw new Error(`No response schema declared for HTTP ${response.status}`);",
+    '      if (!transportSuccess) throw failure("API_RESPONSE_UNDECLARED", `No response schema declared for HTTP ${response.status}`);',
     "      return decode ? decode(value) : value;",
     "    }",
-    ...usesValue ? ["    const checked = decodeResponseSchema(value, response.status, responseSchemas, { normalize: config.normalize ?? true });"] : ["    const checked = value;"],
+    ...usesValue ? [
+      "    let checked: unknown;",
+      "    try { checked = decodeResponseSchema(value, response.status, responseSchemas, { normalize: config.normalize ?? true }); }",
+      '    catch { throw failure("API_RESPONSE_INVALID", "Response does not match schema"); }'
+    ] : ["    const checked = value;"],
     "    return decode ? decode(checked) : checked;",
     "  }",
     "",
-    `  function makeRoute<Options extends ClientRequestOptions, Result = never>(method: string, path: string, responseSchemas?: Readonly<Record<string, ${responseSchemaType}>>, responseKind?: string): RouteMethod<Options, Result> {`,
+    `  function makeRoute<Options extends ClientRequestOptions, Result = never>(method: string, path: string, responseSchemas?: Readonly<Record<string, ${responseSchemaType}>>, responseKind?: string, raw = false): RouteMethod<Options, Result> {`,
     "    function route<T>(options: Options, decode: ResponseDecoder<T>): Promise<T>;",
     "    function route(options: Options): Promise<Result>;",
     "    function route(options?: Options): Promise<unknown>;",
     "    function route<T>(options?: Options, decode?: ResponseDecoder<T>): Promise<T | unknown> {",
     "      const requestOptions = options ?? {};",
-    "      return request(method, path, requestOptions, decode, responseSchemas, responseKind);",
+    "      return request(method, path, requestOptions, decode, responseSchemas, responseKind, raw);",
     "    }",
     "    return route as RouteMethod<Options, Result>;",
     "  }",
@@ -1512,11 +1597,15 @@ function renderOpenApi(graph, options) {
   for (const module of graph.modules) {
     for (const controller of module.controllers) {
       for (const route of controller.routes) {
+        const documentation = route.data?.openapi;
+        if (documentation !== null && typeof documentation === "object" && "hide" in documentation && documentation.hide === true)
+          continue;
         const fullPath = joinRoutePaths(controller.path, route.path);
         const responseEntries = normalizedResponseEntries(route.responses);
         const hasResponseMap = responseEntries.length > 0;
         const pathParams = [...new Set([
           ...(fullPath.match(/:([A-Za-z0-9_]+)/g) ?? []).map((item) => item.slice(1)),
+          ...fullPath.endsWith("/*") ? ["*"] : [],
           ...route.pathParams ?? []
         ].filter((item) => item.length > 0))];
         const queryParams = [...new Set([
@@ -1549,6 +1638,8 @@ function renderOpenApi(graph, options) {
           }).filter((entry) => entry.length === 2)) } : {},
           responseContentType,
           responseKind: responseKind ?? (route.nativeResponse ? "native-response" : undefined),
+          ...route.parse === undefined ? {} : { parse: route.parse },
+          ...route.allowDeleteBody === undefined ? {} : { allowDeleteBody: route.allowDeleteBody },
           module: module.name,
           controller: controller.className,
           handler: route.handler,
@@ -1632,6 +1723,8 @@ function renderOpenApi(graph, options) {
     "  canMatch?: readonly string[];",
     "  canDeactivate?: readonly string[];",
     "  contract?: Record<string, unknown>;",
+    '  parse?: "none";',
+    "  allowDeleteBody?: true;",
     "  data?: Record<string, unknown>;",
     "  requiresAuth?: boolean;",
     "};",
@@ -1829,8 +1922,15 @@ function renderOpenApi(graph, options) {
     '  return { $ref: `#/components/schemas/${encodeURIComponent(name).replaceAll("%2F", "/")}` };',
     "}",
     "",
+    "function wildcardParameterName(path: string): string {",
+    "  const names = new Set([...path.matchAll(/:([A-Za-z0-9_]+)/g)].map(match => match[1]));",
+    '  let name = "wildcard";',
+    '  while (names.has(name)) name += "_";',
+    "  return name;",
+    "}",
+    "",
     "function openApiPath(path: string): string {",
-    '  return path.replace(/:([A-Za-z0-9_]+)/g, "{$1}");',
+    '  return path.replace(/:([A-Za-z0-9_]+)/g, "{$1}").replace(/\\/\\*$/, `/{${wildcardParameterName(path)}}`);',
     "}",
     "",
     "function responseHasBody(status: string, kind: string | undefined): boolean {",
@@ -1860,7 +1960,7 @@ function renderOpenApi(graph, options) {
     "  const parameters: Record<string, unknown>[] = [];",
     "  const paramsSchema = definition.paramsSchema ? OPENAPI_SCHEMA_REGISTRY[definition.paramsSchema as keyof typeof OPENAPI_SCHEMA_REGISTRY] : undefined;",
     "  for (const name of definition.pathParams) parameters.push({",
-    '    name, in: "path", required: true, schema: schemaProperty(paramsSchema, name),',
+    '    name: name === "*" ? wildcardParameterName(definition.path) : name, in: "path", required: true, schema: schemaProperty(paramsSchema, name),',
     "  });",
     "  const querySchema = definition.querySchema ? OPENAPI_SCHEMA_REGISTRY[definition.querySchema as keyof typeof OPENAPI_SCHEMA_REGISTRY] : undefined;",
     "  const queryNames = new Set([...(querySchema ? schemaPropertyNames(querySchema) : []), ...definition.queryParams]);",
@@ -1897,6 +1997,7 @@ function renderOpenApi(graph, options) {
     "    operationId: definition.operationId, tags: [...definition.tags], summary: definition.summary, responses,",
     "    ...(parameters.length === 0 ? {} : { parameters }),",
     '    ...(definition.bodySchema ? { requestBody: { required: !schemaAllowsUndefined(OPENAPI_SCHEMA_REGISTRY[definition.bodySchema as keyof typeof OPENAPI_SCHEMA_REGISTRY]), content: { "application/json": { schema: schemaReference(definition.bodySchema) } } } } : {}),',
+    '    ...(definition.parse === "none" ? { requestBody: { required: false, description: "Raw request bytes; validation and media types are owned by the domain handler.", content: { "*/*": { schema: { type: "string", format: "binary" } } } } } : {}),',
     "    ...(definition.requiresAuth ? { security: [{ bearerAuth: [] }] } : {}),",
     '    "x-supacloud": {',
     "      module: definition.module, controller: definition.controller, handler: definition.handler,",
@@ -1906,6 +2007,8 @@ function renderOpenApi(graph, options) {
     "      ...(definition.canMatch ? { canMatch: [...definition.canMatch] } : {}),",
     "      ...(definition.canDeactivate ? { canDeactivate: [...definition.canDeactivate] } : {}),",
     "      ...(definition.contract ? { contract: definition.contract } : {}),",
+    "      ...(definition.parse ? { parse: definition.parse } : {}),",
+    "      ...(definition.allowDeleteBody ? { allowDeleteBody: true } : {}),",
     "      ...(definition.data ? { data: definition.data } : {}),",
     "    },",
     "  };",
@@ -2001,6 +2104,8 @@ function renderPermissions(graph) {
 `);
 }
 var HEADER = "// GENERATED BY @supacloud/compiler — do not edit", INTERFACES = `export interface CompiledRoute {
+  parse?: "none";
+  allowDeleteBody?: true;
   method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "HEAD" | "OPTIONS";
   path: string;
   handler: string;
@@ -2153,6 +2258,12 @@ function resolveFactoryValue(value: unknown): unknown {
 }
 
 const scopeDestructions = new WeakMap<object, Promise<void>>();
+const platformDependencies = new WeakMap<object, Record<string, unknown>>();
+
+function retainPlatformDependencies<T extends Record<string, unknown>>(services: T, deps: Record<string, unknown>): T {
+  platformDependencies.set(services, deps);
+  return services;
+}
 
 function destroyScopeInstances(
   scope: Record<string, unknown>,
@@ -3611,6 +3722,7 @@ var COMPILER_DIAGNOSTIC_CODES = {
 };
 function validateGraph(graph, options = false) {
   const strict = typeof options === "boolean" ? options : options.strict ?? false;
+  const generateOpenApi = typeof options === "object" && options.generateOpenApi === true;
   const diagnostics = [];
   for (const module of graph.modules) {
     for (const owner of [...module.providers, ...module.controllers]) {
@@ -3746,7 +3858,7 @@ function validateGraph(graph, options = false) {
         }
         const fullPath = joinRoutePaths2(controller.path, route.path);
         const rawFullPath = joinRawRoutePaths(controller.path, route.path);
-        const key = `${route.method} ${fullPath}`;
+        const key = `${route.method} ${generateOpenApi ? fullPath.replace(/:[A-Za-z0-9_]+|\*$/g, "{}") : fullPath}`;
         const openApiMatch = route.path.match(/\{([a-zA-Z0-9_]+)\}/);
         if (openApiMatch) {
           error("missing-param-colon", `Route path '${route.path}' in '${controller.className}.${route.handler}' uses OpenAPI-style '{${openApiMatch[1]}}'. SupaCloud routes require Express/Angular-style ':${openApiMatch[1]}'.`, controller.file, undefined, `Replace '{${openApiMatch[1]}}' with ':${openApiMatch[1]}'.`);
@@ -3846,7 +3958,13 @@ function validateGraph(graph, options = false) {
             }
           }
         }
-        if ((route.method === "GET" || route.method === "HEAD" || route.method === "OPTIONS" || route.method === "DELETE") && (route.hasBodyBinding || route.body)) {
+        if (route.allowDeleteBody && (route.method !== "DELETE" || !route.body)) {
+          error("invalid-delete-body-opt-in", `Route ${controller.className}.${route.handler} allowDeleteBody requires DELETE and an explicit body schema.`, controller.file);
+        }
+        if (route.parse === "none" && (route.body || route.hasBodyBinding || route.contract?.body !== "domain" || !route.contract.evidence?.trim())) {
+          error("invalid-raw-body-contract", `Route ${controller.className}.${route.handler} parse: "none" requires domain body ownership and evidence, without a parsed body schema or @Body binding.`, controller.file);
+        }
+        if ((route.method === "GET" || route.method === "HEAD" || route.method === "OPTIONS" || route.method === "DELETE" && !route.allowDeleteBody) && (route.hasBodyBinding || route.body)) {
           error("disallowed-body-on-get-delete", `Route handler ${controller.className}.${route.handler} binds @Body() or declares body schema on HTTP ${route.method} route '${route.path}'. Request bodies are not supported on ${route.method} requests.`, controller.file, undefined, `Use POST, PUT, or PATCH for routes accepting a request body, or bind parameters via @Query() / @Param().`, {
             type: "remove_route_body_binding",
             targetFile: controller.file,
@@ -4558,6 +4676,7 @@ async function analyzeProject(rootDir, include, cache, changedPaths) {
     tokensByName: new Map,
     classesByName: new Map,
     variablesByName: new Map,
+    moduleHandlerFiles: new Map,
     diagnostics: []
   };
   const nativeTraitFiles = new Map;
@@ -4648,10 +4767,11 @@ async function analyzeProject(rootDir, include, cache, changedPaths) {
       const hasChangedFile = entry.ownedFiles.some((f) => changedFiles.has(f));
       const moduleFileExists = currentFileHashes.has(entry.module.file);
       const isAffectedByDep = affectedModuleNames.has(modName);
-      if (!hasChangedFile && !isAffectedByDep && moduleFileExists) {
+      if (!hasChangedFile && !isAffectedByDep && moduleFileExists && entry.handlerFiles !== undefined) {
         modulesToKeep.set(modName, entry);
         reusedModules.push(modName);
         finalModules.push(entry.module);
+        ctx.moduleHandlerFiles.set(modName, entry.handlerFiles);
         if (entry.diagnostics)
           finalDiagnostics.push(...entry.diagnostics);
       }
@@ -4671,6 +4791,7 @@ async function analyzeProject(rootDir, include, cache, changedPaths) {
       }
       cache.modules.set(parsed.name, {
         module: parsed,
+        handlerFiles: ctx.moduleHandlerFiles.get(parsed.name) ?? [],
         ownedFiles: [...ownedFiles],
         fileHashes,
         diagnostics: moduleDiagnostics
@@ -4839,6 +4960,7 @@ async function analyzeProject(rootDir, include, cache, changedPaths) {
     externalTokens,
     diagnostics: ctx.diagnostics.map(withDiagnosticMetadata),
     tokenNames,
+    moduleHandlerFiles: Object.fromEntries(ctx.moduleHandlerFiles),
     ...cache ? { cacheStats: { reusedModules, reanalyzedModules } } : {}
   };
 }
@@ -5051,6 +5173,7 @@ function parseModule(candidate, nameByNode, ctx) {
   arrayProp(options, "commands").forEach(collectHandler);
   arrayProp(options, "jobs").forEach(collectHandler);
   arrayProp(options, "queries").forEach(collectHandler);
+  ctx.moduleHandlerFiles.set(name, [...new Set([...handlerClasses].map((cls) => sourcePath(ctx.rootDir, cls.getSourceFile().fileName)))].sort());
   const commands = [];
   const jobs = [];
   const queries = [];
@@ -5229,6 +5352,25 @@ function resolveStaticObjectLiteral(input, ctx, seen = new Set) {
   }
   return ts4.isObjectLiteralExpression(input) ? input : undefined;
 }
+function routePolicyProperty(object, name, ctx, seen = new Set) {
+  if (seen.has(object))
+    return { unresolved: true };
+  const ancestry = new Set(seen).add(object);
+  let result = { unresolved: false };
+  for (const property of object.properties) {
+    if (ts4.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)) {
+      result = { unresolved: true };
+    } else if (propertyName(property.name) === name) {
+      result = ts4.isPropertyAssignment(property) ? { value: property.initializer, unresolved: false } : { unresolved: true };
+    }
+  }
+  return result;
+}
 function commandModeProp(object, name) {
   const value = stringLiteralProp(object, name);
   return value === "required" || value === "none" ? value : undefined;
@@ -5736,10 +5878,13 @@ function parseController(input, ctx) {
       const pathParams = [];
       const paramRegex = /:([a-zA-Z0-9_]+)/g;
       let match;
-      while ((match = paramRegex.exec(routePath)) !== null) {
+      const fullPath = joinRoutePaths(path, routePath);
+      while ((match = paramRegex.exec(fullPath)) !== null) {
         if (match[1] !== undefined)
           pathParams.push(match[1]);
       }
+      if (joinRoutePaths(path, routePath).endsWith("/*"))
+        pathParams.push("*");
       if (pathParams.length > 0)
         route.pathParams = pathParams;
       const paramBindings = [];
@@ -5890,6 +6035,40 @@ function parseController(input, ctx) {
       const optionsArg = args[1];
       const optionsObject = resolveStaticObjectLiteral(optionsArg, ctx);
       if (optionsObject) {
+        const parsePolicy = routePolicyProperty(optionsObject, "parse", ctx);
+        const deletePolicy = routePolicyProperty(optionsObject, "allowDeleteBody", ctx);
+        if (parsePolicy.unresolved || deletePolicy.unresolved) {
+          ctx.diagnostics.push({
+            severity: "error",
+            code: "unresolved-route-body-policy",
+            file,
+            message: `Route ${route.handler} body policy must be statically resolvable; dynamic spreads, computed keys and shorthand policies are unsupported.`
+          });
+        }
+        const parse = parsePolicy.value;
+        if (parse) {
+          if (ts4.isStringLiteral(parse) && parse.text === "none")
+            route.parse = "none";
+          else
+            ctx.diagnostics.push({
+              severity: "error",
+              code: "invalid-route-parser",
+              file,
+              message: `Route ${route.handler} parse must be the literal "none".`
+            });
+        }
+        const allowDeleteBody = deletePolicy.value;
+        if (allowDeleteBody) {
+          if (allowDeleteBody.kind === ts4.SyntaxKind.TrueKeyword)
+            route.allowDeleteBody = true;
+          else
+            ctx.diagnostics.push({
+              severity: "error",
+              code: "invalid-delete-body-opt-in",
+              file,
+              message: `Route ${route.handler} allowDeleteBody must be the literal true.`
+            });
+        }
         const legacyResponseExpr = getProp(optionsObject, "response");
         const responsesExpr = getProp(optionsObject, "responses");
         if (legacyResponseExpr !== undefined && responsesExpr !== undefined) {
@@ -7083,7 +7262,7 @@ async function compileProject(options) {
     ...options,
     ...options.cache ? { artifactHashes: options.cache.generatedHashes } : {}
   };
-  const written = !hasErrors || options.writeOnError === true ? await generateApplication(graph, generatedOptions) : [];
+  const written = !hasErrors || options.writeOnError === true ? await writeRenderedApplication(rendered, generatedOptions) : [];
   if (!hasErrors) {
     for (const [filename, content] of Object.entries(graphql.files)) {
       const path = join4(options.outDir, filename);
@@ -11441,6 +11620,48 @@ function importSymbol(source, path, symbol) {
   return `import { ${symbol} } from ${JSON.stringify(path)};
 ${source.text}`;
 }
+// src/repair-plan.ts
+function createDiagnosticRepairPlan(diagnostics) {
+  return diagnostics.flatMap((diagnostic) => {
+    const fix = diagnostic.fix;
+    if (!fix)
+      return [];
+    return [{
+      code: diagnostic.code,
+      ...diagnostic.errorCode === undefined ? {} : { errorCode: diagnostic.errorCode },
+      ...diagnostic.file === undefined ? {} : { file: diagnostic.file },
+      ...diagnostic.line === undefined ? {} : { line: diagnostic.line },
+      type: fix.type,
+      targetFile: fix.targetFile,
+      fix,
+      ...classifyFix(fix)
+    }];
+  });
+}
+function classifyFix(fix) {
+  switch (fix.type) {
+    case "set_command_mode":
+      if (fix.value !== "required" && fix.value !== "none") {
+        return { readiness: "input-required", reason: "Choose an explicit transaction or idempotency policy; no policy is inferred." };
+      }
+      break;
+    case "add_command_permission":
+      if (!fix.permission?.trim()) {
+        return { readiness: "input-required", reason: "Choose an explicit business permission; privileges are never inferred." };
+      }
+      break;
+    case "add_module_import":
+      if (!fix.importPath || !fix.symbol) {
+        return { readiness: "input-required", reason: "Supply the module import path and exported symbol before previewing." };
+      }
+      break;
+    case "add_route_parameter_binding":
+      break;
+    default:
+      return { readiness: "manual", reason: "The semantic fix executor does not implement this suggestion; edit and verify it manually." };
+  }
+  return { readiness: "preview", reason: "Preview with the semantic fix executor; source preconditions are checked before writing." };
+}
 // src/watch.ts
 import { existsSync as existsSync3, watch } from "node:fs";
 import { dirname as dirname7, relative as relative9, resolve as resolve10, sep as sep9 } from "node:path";
@@ -11880,9 +12101,9 @@ function compilerVersion() {
 }
 function migrationDependencies() {
   return {
-    "@supacloud/app": "0.16.0",
+    "@supacloud/app": "0.17.0",
     "@supacloud/compiler": compilerVersion(),
-    "@supacloud/elysia": "0.18.0",
+    "@supacloud/elysia": "0.19.0",
     elysia: "1.4.30",
     typescript: "7.0.2"
   };
@@ -11963,6 +12184,8 @@ function isDefineRouteContractCall(node, checker) {
   return resolveSymbol(checker.getSymbolAtLocation(node.expression), checker)?.name === "defineRouteContract";
 }
 function isRouteDecoratorCall(node, checker) {
+  if (node.arguments.length < 2)
+    return false;
   const name = node.expression.getText(node.getSourceFile());
   if (ts12.isIdentifier(node.expression) && ROUTE_DECORATORS2.has(node.expression.text))
     return true;
@@ -12247,7 +12470,7 @@ async function migrateProject(options) {
       const before = sourceByPath.get(absoluteFile);
       if (before === undefined)
         continue;
-      const result = projectResults?.results.get(absoluteFile) ?? migration.apply(before, file);
+      const result = projectResults ? projectResults.results.get(absoluteFile) ?? { changed: false, content: before, replacements: 0, issues: [] } : migration.apply(before, file);
       sourceByPath.set(absoluteFile, result.content);
       if (result.changed && result.issues.length === 0) {
         pendingWrites.set(absoluteFile, result.content);
@@ -13035,10 +13258,7 @@ function explainGraph(graph, subject) {
   throw new Error(`No module, provider, or external token named "${subject}". Known names: ${known.join(", ") || "(none)"}`);
 }
 function createContextPack(graph, subject) {
-  const subjectModule = graph.modules.find((module) => module.name === subject);
-  if (!subjectModule) {
-    throw new Error(`No module named "${subject}". Context packs require a module name.`);
-  }
+  const subjectModule = resolveContextModule(graph, subject);
   const byName = new Map(graph.modules.map((module) => [module.name, module]));
   const selected = new Set([subjectModule.name]);
   const reverseDependents = new Map;
@@ -13086,6 +13306,7 @@ function createContextPack(graph, subject) {
     module.file,
     ...module.providers.map((provider) => provider.file),
     ...module.controllers.map((controller) => controller.file),
+    ...graph.moduleHandlerFiles?.[module.name] ?? [],
     ...allAspects(module).flatMap((aspect) => aspect.file ? [aspect.file] : [])
   ]).concat(graphql ? [graphql.schema, ...queryDocuments] : []))].sort();
   const referencedTokens = new Set;
@@ -13115,6 +13336,18 @@ function createContextPack(graph, subject) {
     }
   };
 }
+function resolveContextModule(graph, subject) {
+  const exact = graph.modules.find((module) => module.name === subject);
+  if (exact)
+    return exact;
+  const matches = graph.modules.filter((module) => module.className === subject || module.providers.some((provider) => provider.token === subject || provider.useClass === subject) || module.controllers.some((controller) => controller.className === subject) || module.commands.some((command) => command.name === subject || command.className === subject) || (module.jobs ?? []).some((job) => job.name === subject || job.className === subject || job.serviceKey === subject) || module.queries.some((query) => query.name === subject || query.className === subject));
+  if (matches.length === 1)
+    return matches[0];
+  if (matches.length > 1) {
+    throw new Error(`Ambiguous context target "${subject}". Select a module name: ${matches.map((module) => module.name).sort().join(", ")}`);
+  }
+  throw new Error(`No context target named "${subject}". Select a module name: ${graph.modules.map((module) => module.name).sort().join(", ") || "(none)"}`);
+}
 function allAspects(module) {
   return [
     ...module.aspects ?? [],
@@ -13451,6 +13684,7 @@ export {
   createContextPack,
   createDeliveryPlan,
   createDependencyGraphCache,
+  createDiagnosticRepairPlan,
   createExecutionPlans,
   createIncrementalCompiler,
   createIncrementalProgramSession,