@supacloud/compiler 0.42.1 → 0.43.1

package/dist/index.js

@@ -34,8 +34,8 @@ function getModuleBoundaryProfile(name) {
     ...profile,
     rules: profile.rules.map((rule) => ({
       ...rule,
-      onlyDependOnLibsWithTags: rule.onlyDependOnLibsWithTags ? [...rule.onlyDependOnLibsWithTags] : undefined,
-      bannedDependenciesWithTags: rule.bannedDependenciesWithTags ? [...rule.bannedDependenciesWithTags] : undefined
+      ...rule.onlyDependOnLibsWithTags === undefined ? {} : { onlyDependOnLibsWithTags: [...rule.onlyDependOnLibsWithTags] },
+      ...rule.bannedDependenciesWithTags === undefined ? {} : { bannedDependenciesWithTags: [...rule.bannedDependenciesWithTags] }
     }))
   };
 }
@@ -251,7 +251,13 @@ var REQUEST_CONTEXT_TOKEN_NAME = "supacloud.request-context", JOB_CONTEXT_TOKEN_
 function validateFeatureSpec(spec, module) {
   const diagnostics = [];
   const error = (code, message) => {
-    diagnostics.push({ severity: "error", code, message, file: spec.file, line: spec.line });
+    diagnostics.push({
+      severity: "error",
+      code,
+      message,
+      ...spec.file === undefined ? {} : { file: spec.file },
+      ...spec.line === undefined ? {} : { line: spec.line }
+    });
   };
   if (!spec.name.trim() || spec.states.length === 0 || spec.states.some((state) => !state.trim()) || new Set(spec.states).size !== spec.states.length) {
     error("invalid-feature-states", "Feature name and states must be non-empty; states must be unique.");
@@ -289,7 +295,7 @@ function validateFeatureSpec(spec, module) {
       const routes = module.controllers.flatMap((controller) => controller.routes.filter((route) => `${route.method} ${joinRoutePaths(controller.path, route.path)}` === transition.route));
       if (routes.length !== 1) {
         error("feature-route-unresolved", `Transition ${transition.name} must reference exactly one route '${transition.route}' in module ${module.name}.`);
-      } else if (command && routes[0].command !== command.className) {
+      } else if (command && routes[0]?.command !== command.className) {
         error("feature-route-drift", `Route ${transition.route} is not bound to ${command.className}.`);
       }
     }
@@ -2657,7 +2663,7 @@ ${procedureMethods.join(`
     "",
     "function selectResponseSchema(status: number, schemas: Readonly<Record<string, unknown>>): unknown {",
     "  const family = `${Math.floor(status / 100)}xx`;",
-    "  return schemas[String(status)] ?? schemas[family] ?? schemas[family.toUpperCase()] ?? schemas.default;",
+    '  return schemas[String(status)] ?? schemas[family] ?? schemas[family.toUpperCase()] ?? schemas["default"];',
     "}",
     "",
     ...usesValue ? [
@@ -2685,16 +2691,16 @@ ${procedureMethods.join(`
       "function schemaReferenceTarget(ref: string, root: unknown): unknown {",
       '  const localRef = ref.startsWith("#/$defs/") ? ref.slice(8) : ref.startsWith("#/definitions/") ? ref.slice(14) : ref.startsWith("#/components/schemas/") ? ref.slice(21) : ref.startsWith("#") ? undefined : ref;',
       "  if (localRef !== undefined && isRecord(root)) {",
-      '    const defs = ref.startsWith("#/definitions/") ? root.definitions : ref.startsWith("#/components/schemas/") ? root.components : root.$defs;',
+      '    const defs = ref.startsWith("#/definitions/") ? root["definitions"] : ref.startsWith("#/components/schemas/") ? root["components"] : root["$defs"];',
       '    if (ref.startsWith("#/components/schemas/") && isRecord(defs)) {',
-      "      const components = defs.schemas;",
+      '      const components = defs["schemas"];',
       "      if (isRecord(components) && components[localRef] !== undefined) return components[localRef];",
       "    } else if (isRecord(defs) && defs[localRef] !== undefined) return defs[localRef];",
       "  }",
       "  for (const entry of API_SCHEMAS as readonly { name: string; schema: unknown }[]) {",
       "    if (entry.name === ref) return entry.schema;",
       "    if (!isRecord(entry.schema)) continue;",
-      "    if (entry.schema.$id === ref || entry.schema.$id === localRef) return entry.schema;",
+      '    if (entry.schema["$id"] === ref || entry.schema["$id"] === localRef) return entry.schema;',
       '    for (const key of ["$defs", "definitions"] as const) {',
       "      const defs = entry.schema[key];",
       "      if (isRecord(defs) && localRef !== undefined && defs[localRef] !== undefined) return defs[localRef];",
@@ -2721,52 +2727,52 @@ ${procedureMethods.join(`
       "  if (schema === true) return value;",
       "  if (schema === false || !isRecord(schema)) return schemaError();",
       '  if ("~codec" in schema || Object.getOwnPropertySymbols(schema).some((symbol) => String(symbol).includes("Transform"))) throw new Error("Response schema transforms are unsupported by the generated decoder");',
-      '  if (typeof schema.$ref === "string") {',
-      "    if (seenRefs.has(schema.$ref)) return schemaError();",
-      "    const target = schemaReferenceTarget(schema.$ref, root);",
+      '  if (typeof schema["$ref"] === "string") {',
+      '    if (seenRefs.has(schema["$ref"])) return schemaError();',
+      '    const target = schemaReferenceTarget(schema["$ref"], root);',
       "    if (target === undefined) return schemaError();",
-      "    const nextRefs = new Set(seenRefs); nextRefs.add(schema.$ref);",
+      '    const nextRefs = new Set(seenRefs); nextRefs.add(schema["$ref"]);',
       "    return decodeSchemaValue(target, value, root, nextRefs, normalize);",
       "  }",
-      "  if (schema.nullable === true && value === null) return value;",
-      '  if (Object.hasOwn(schema, "const") && !sameJsonValue(schema.const, value)) return schemaError();',
-      "  if (Array.isArray(schema.enum) && !schema.enum.some((entry) => sameJsonValue(entry, value))) return schemaError();",
-      "  if (Array.isArray(schema.anyOf)) {",
+      '  if (schema["nullable"] === true && value === null) return value;',
+      '  if (Object.hasOwn(schema, "const") && !sameJsonValue(schema["const"], value)) return schemaError();',
+      '  if (Array.isArray(schema["enum"]) && !schema["enum"].some((entry) => sameJsonValue(entry, value))) return schemaError();',
+      '  if (Array.isArray(schema["anyOf"])) {',
       "    const matches: unknown[] = [];",
-      "    for (const variant of schema.anyOf) { try { matches.push(decodeSchemaValue(variant, value, root, new Set(seenRefs), normalize)); } catch {} }",
+      '    for (const variant of schema["anyOf"]) { try { matches.push(decodeSchemaValue(variant, value, root, new Set(seenRefs), normalize)); } catch {} }',
       "    if (matches.length === 0) return schemaError();",
       "    return matches[0];",
       "  }",
-      "  if (Array.isArray(schema.oneOf)) {",
+      '  if (Array.isArray(schema["oneOf"])) {',
       "    const matches: unknown[] = [];",
-      "    for (const variant of schema.oneOf) { try { matches.push(decodeSchemaValue(variant, value, root, new Set(seenRefs), normalize)); } catch {} }",
+      '    for (const variant of schema["oneOf"]) { try { matches.push(decodeSchemaValue(variant, value, root, new Set(seenRefs), normalize)); } catch {} }',
       "    if (matches.length !== 1) return schemaError();",
       "    return matches[0];",
       "  }",
-      "  if (Array.isArray(schema.allOf)) {",
+      '  if (Array.isArray(schema["allOf"])) {',
       "    let output: unknown = value;",
-      "    for (const variant of schema.allOf) {",
+      '    for (const variant of schema["allOf"]) {',
       "      const decoded = decodeSchemaValue(variant, value, root, new Set(seenRefs), normalize);",
       "      output = isRecord(output) && isRecord(decoded) ? { ...output, ...decoded } : decoded;",
       "    }",
       "    return output;",
       "  }",
-      "  if (schema.not !== undefined) {",
-      "    try { decodeSchemaValue(schema.not, value, root, new Set(seenRefs), normalize); } catch { return value; }",
+      '  if (schema["not"] !== undefined) {',
+      '    try { decodeSchemaValue(schema["not"], value, root, new Set(seenRefs), normalize); } catch { return value; }',
       "    return schemaError();",
       "  }",
-      "  if (Array.isArray(schema.type)) {",
-      "    for (const type of schema.type) { try { return decodeSchemaValue({ ...schema, type }, value, root, new Set(seenRefs), normalize); } catch {} }",
+      '  if (Array.isArray(schema["type"])) {',
+      '    for (const type of schema["type"]) { try { return decodeSchemaValue({ ...schema, type }, value, root, new Set(seenRefs), normalize); } catch {} }',
       "    return schemaError();",
       "  }",
-      '  if (schema.type === "object" || (schema.type === undefined && (isRecord(schema.properties) || schema.required !== undefined))) {',
+      '  if (schema["type"] === "object" || (schema["type"] === undefined && (isRecord(schema["properties"]) || schema["required"] !== undefined))) {',
       "    if (!isRecord(value)) return schemaError();",
-      "    const properties = isRecord(schema.properties) ? schema.properties : {};",
-      "    const patterns = isRecord(schema.patternProperties) ? schema.patternProperties : {};",
-      "    const required = Array.isArray(schema.required) ? schema.required : [];",
+      '    const properties = isRecord(schema["properties"]) ? schema["properties"] : {};',
+      '    const patterns = isRecord(schema["patternProperties"]) ? schema["patternProperties"] : {};',
+      '    const required = Array.isArray(schema["required"]) ? schema["required"] : [];',
       '    for (const name of required) if (typeof name === "string" && !Object.hasOwn(value, name)) return schemaError();',
-      '    if (typeof schema.minProperties === "number" && Object.keys(value).length < schema.minProperties) return schemaError();',
-      '    if (typeof schema.maxProperties === "number" && Object.keys(value).length > schema.maxProperties) return schemaError();',
+      '    if (typeof schema["minProperties"] === "number" && Object.keys(value).length < schema["minProperties"]) return schemaError();',
+      '    if (typeof schema["maxProperties"] === "number" && Object.keys(value).length > schema["maxProperties"]) return schemaError();',
       "    const output: Record<string, unknown> = {};",
       "    for (const [name, item] of Object.entries(value)) {",
       "      const propertySchema = properties[name];",
@@ -2777,52 +2783,52 @@ ${procedureMethods.join(`
       "        if (applies) { output[name] = decodeSchemaValue(patternSchema, item, root, new Set<string>(), normalize); matched = true; }",
       "      }",
       "      if (matched) continue;",
-      "      if (schema.additionalProperties === false || schema.unevaluatedProperties === false || schema.additionalProperties === undefined) {",
+      '      if (schema["additionalProperties"] === false || schema["unevaluatedProperties"] === false || schema["additionalProperties"] === undefined) {',
       "        if (normalize) continue;",
       "        return schemaError();",
       "      }",
-      "      if (isRecord(schema.additionalProperties)) output[name] = decodeSchemaValue(schema.additionalProperties, item, root, new Set<string>(), normalize);",
-      "      else if (schema.additionalProperties === true) output[name] = item;",
+      '      if (isRecord(schema["additionalProperties"])) output[name] = decodeSchemaValue(schema["additionalProperties"], item, root, new Set<string>(), normalize);',
+      '      else if (schema["additionalProperties"] === true) output[name] = item;',
       "    }",
       "    return output;",
       "  }",
-      '  if (schema.type === "array") {',
+      '  if (schema["type"] === "array") {',
       "    if (!Array.isArray(value)) return schemaError();",
-      '    if (typeof schema.minItems === "number" && value.length < schema.minItems) return schemaError();',
-      '    if (typeof schema.maxItems === "number" && value.length > schema.maxItems) return schemaError();',
-      "    if (schema.uniqueItems === true) { const keys = value.map((item) => JSON.stringify(item)); if (new Set(keys).size !== keys.length) return schemaError(); }",
-      "    const tuple = Array.isArray(schema.prefixItems) ? schema.prefixItems : Array.isArray(schema.items) ? schema.items : undefined;",
+      '    if (typeof schema["minItems"] === "number" && value.length < schema["minItems"]) return schemaError();',
+      '    if (typeof schema["maxItems"] === "number" && value.length > schema["maxItems"]) return schemaError();',
+      '    if (schema["uniqueItems"] === true) { const keys = value.map((item) => JSON.stringify(item)); if (new Set(keys).size !== keys.length) return schemaError(); }',
+      '    const tuple = Array.isArray(schema["prefixItems"]) ? schema["prefixItems"] : Array.isArray(schema["items"]) ? schema["items"] : undefined;',
       "    if (tuple) {",
-      "      if (schema.additionalItems === false && value.length > tuple.length) return schemaError();",
-      "      return value.map((item, index) => index < tuple.length ? decodeSchemaValue(tuple[index], item, root, new Set<string>(), normalize) : schema.items && !Array.isArray(schema.items) ? decodeSchemaValue(schema.items, item, root, new Set<string>(), normalize) : item);",
+      '      if (schema["additionalItems"] === false && value.length > tuple.length) return schemaError();',
+      '      return value.map((item, index) => index < tuple.length ? decodeSchemaValue(tuple[index], item, root, new Set<string>(), normalize) : schema["items"] && !Array.isArray(schema["items"]) ? decodeSchemaValue(schema["items"], item, root, new Set<string>(), normalize) : item);',
       "    }",
-      "    if (schema.items === undefined || schema.items === true) return value;",
-      "    if (schema.items === false && value.length > 0) return schemaError();",
-      "    return value.map((item) => decodeSchemaValue(schema.items, item, root, new Set<string>(), normalize));",
+      '    if (schema["items"] === undefined || schema["items"] === true) return value;',
+      '    if (schema["items"] === false && value.length > 0) return schemaError();',
+      '    return value.map((item) => decodeSchemaValue(schema["items"], item, root, new Set<string>(), normalize));',
       "  }",
-      '  if (schema.type === "string") {',
+      '  if (schema["type"] === "string") {',
       '    if (typeof value !== "string") return schemaError();',
-      '    if (typeof schema.minLength === "number" && value.length < schema.minLength) return schemaError();',
-      '    if (typeof schema.maxLength === "number" && value.length > schema.maxLength) return schemaError();',
-      '    if (typeof schema.pattern === "string") { let matches = false; try { matches = new RegExp(schema.pattern).test(value); } catch { return schemaError(); } if (!matches) return schemaError(); }',
-      "    if (!matchesFormat(schema.format, value)) return schemaError();",
+      '    if (typeof schema["minLength"] === "number" && value.length < schema["minLength"]) return schemaError();',
+      '    if (typeof schema["maxLength"] === "number" && value.length > schema["maxLength"]) return schemaError();',
+      '    if (typeof schema["pattern"] === "string") { let matches = false; try { matches = new RegExp(schema["pattern"]).test(value); } catch { return schemaError(); } if (!matches) return schemaError(); }',
+      '    if (!matchesFormat(schema["format"], value)) return schemaError();',
       "    return value;",
       "  }",
-      '  if (schema.type === "boolean") { if (typeof value !== "boolean") return schemaError(); return value; }',
-      '  if (schema.type === "number" || schema.type === "integer") {',
-      '    if (typeof value !== "number" || !Number.isFinite(value) || (schema.type === "integer" && !Number.isInteger(value))) return schemaError();',
-      '    if (typeof schema.minimum === "number" && value < schema.minimum) return schemaError();',
-      '    if (typeof schema.maximum === "number" && value > schema.maximum) return schemaError();',
-      '    if (typeof schema.exclusiveMinimum === "number" && value <= schema.exclusiveMinimum) return schemaError();',
-      '    if (typeof schema.exclusiveMaximum === "number" && value >= schema.exclusiveMaximum) return schemaError();',
-      '    if (schema.exclusiveMinimum === true && typeof schema.minimum === "number" && value <= schema.minimum) return schemaError();',
-      '    if (schema.exclusiveMaximum === true && typeof schema.maximum === "number" && value >= schema.maximum) return schemaError();',
-      '    if (typeof schema.multipleOf === "number" && schema.multipleOf > 0 && Math.abs(value / schema.multipleOf - Math.round(value / schema.multipleOf)) > 1e-9) return schemaError();',
+      '  if (schema["type"] === "boolean") { if (typeof value !== "boolean") return schemaError(); return value; }',
+      '  if (schema["type"] === "number" || schema["type"] === "integer") {',
+      '    if (typeof value !== "number" || !Number.isFinite(value) || (schema["type"] === "integer" && !Number.isInteger(value))) return schemaError();',
+      '    if (typeof schema["minimum"] === "number" && value < schema["minimum"]) return schemaError();',
+      '    if (typeof schema["maximum"] === "number" && value > schema["maximum"]) return schemaError();',
+      '    if (typeof schema["exclusiveMinimum"] === "number" && value <= schema["exclusiveMinimum"]) return schemaError();',
+      '    if (typeof schema["exclusiveMaximum"] === "number" && value >= schema["exclusiveMaximum"]) return schemaError();',
+      '    if (schema["exclusiveMinimum"] === true && typeof schema["minimum"] === "number" && value <= schema["minimum"]) return schemaError();',
+      '    if (schema["exclusiveMaximum"] === true && typeof schema["maximum"] === "number" && value >= schema["maximum"]) return schemaError();',
+      '    if (typeof schema["multipleOf"] === "number" && schema["multipleOf"] > 0 && Math.abs(value / schema["multipleOf"] - Math.round(value / schema["multipleOf"])) > 1e-9) return schemaError();',
       "    return value;",
       "  }",
-      '  if (schema.type === "null") { if (value !== null) return schemaError(); return value; }',
-      '  if (schema.type === "void" || schema.type === "undefined") { if (value !== undefined) return schemaError(); return value; }',
-      '  if (schema.type === "never") return schemaError();',
+      '  if (schema["type"] === "null") { if (value !== null) return schemaError(); return value; }',
+      '  if (schema["type"] === "void" || schema["type"] === "undefined") { if (value !== undefined) return schemaError(); return value; }',
+      '  if (schema["type"] === "never") return schemaError();',
       "  return value;",
       "}",
       ""
@@ -2896,7 +2902,7 @@ ${procedureMethods.join(`
     "      ...options.headers,",
     "    };",
     '    if (options.cookie && !Object.keys(headers).some((key) => key.toLowerCase() === "cookie")) {',
-    '      headers.cookie = Object.entries(options.cookie).map(([key, value]) => `${key}=${encodeURIComponent(String(value))}`).join("; " );',
+    '      headers["cookie"] = Object.entries(options.cookie).map(([key, value]) => `${key}=${encodeURIComponent(String(value))}`).join("; " );',
     "    }",
     "    const interceptors = config.interceptors ?? [];",
     "    const executeChain = (",
@@ -3087,7 +3093,7 @@ 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;
+        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);
@@ -3274,11 +3280,11 @@ function renderOpenApi(graph, options) {
     "function isUndefinedSchema(value: unknown, seen = new WeakSet<object>(), refs = new Set<string>(), scope?: unknown): boolean {",
     "  if (!isRecord(value) || seen.has(value)) return false;",
     "  seen.add(value);",
-    "  const nextScope = isRecord(value.$defs) || isRecord(value.definitions) ? value : scope;",
+    '  const nextScope = isRecord(value["$defs"]) || isRecord(value["definitions"]) ? value : scope;',
     "  try {",
-    '    if (value.type === "undefined") return true;',
-    '    if (Array.isArray(value.type) && value.type.length > 0 && value.type.every((type) => type === "undefined")) return true;',
-    '    const ref = typeof value.$ref === "string" ? value.$ref : undefined;',
+    '    if (value["type"] === "undefined") return true;',
+    '    if (Array.isArray(value["type"]) && value["type"].length > 0 && value["type"].every((type) => type === "undefined")) return true;',
+    '    const ref = typeof value["$ref"] === "string" ? value["$ref"] : undefined;',
     "    if (ref !== undefined && !refs.has(ref)) {",
     "      const target = openApiSchemaRefTarget(ref, nextScope);",
     "      if (target !== undefined) {",
@@ -3302,10 +3308,10 @@ function renderOpenApi(graph, options) {
     "function cloneSchema(value: unknown, seen = new WeakSet<object>(), scope?: unknown): OpenApiSchema {",
     "  if (!isRecord(value)) return {};",
     "  if (seen.has(value)) return {};",
-    "  const nextScope = isRecord(value.$defs) || isRecord(value.definitions) ? value : scope;",
+    '  const nextScope = isRecord(value["$defs"]) || isRecord(value["definitions"]) ? value : scope;',
     "  if (isUndefinedSchema(value, new WeakSet<object>(), new Set<string>(), nextScope)) return {};",
     "  seen.add(value);",
-    '  if (value.type === "void" || value.type === "undefined") { seen.delete(value); return {}; }',
+    '  if (value["type"] === "void" || value["type"] === "undefined") { seen.delete(value); return {}; }',
     "  const allowed = new Set([",
     '    "$id", "$ref", "$schema", "$defs", "definitions", "title", "description", "type", "enum", "const", "examples", "default",',
     '    "deprecated", "readOnly", "writeOnly", "format", "pattern", "minLength", "maxLength", "minimum",',
@@ -3352,12 +3358,12 @@ function renderOpenApi(graph, options) {
     "function schemaAllowsUndefined(value: unknown, seen = new WeakSet<object>(), refs = new Set<string>(), scope?: unknown): boolean {",
     "  if (!isRecord(value) || seen.has(value)) return false;",
     "  seen.add(value);",
-    "  const nextScope = isRecord(value.$defs) || isRecord(value.definitions) ? value : scope;",
+    '  const nextScope = isRecord(value["$defs"]) || isRecord(value["definitions"]) ? value : scope;',
     "  try {",
     '    if (Object.getOwnPropertySymbols(value).some((symbol) => String(symbol).toLowerCase().includes("optional"))) return true;',
-    '    if (value.type === "undefined") return true;',
-    '    if (Array.isArray(value.type) && value.type.includes("undefined")) return true;',
-    '    const ref = typeof value.$ref === "string" ? value.$ref : undefined;',
+    '    if (value["type"] === "undefined") return true;',
+    '    if (Array.isArray(value["type"]) && value["type"].includes("undefined")) return true;',
+    '    const ref = typeof value["$ref"] === "string" ? value["$ref"] : undefined;',
     "    if (ref !== undefined && !refs.has(ref)) {",
     "      const target = openApiSchemaRefTarget(ref, nextScope);",
     "      if (target !== undefined) {",
@@ -3377,11 +3383,11 @@ function renderOpenApi(graph, options) {
     "",
     "function resolveRegistrySchema(value: unknown, seen = new Set<string>()): OpenApiSchema {",
     "  const schema = cloneSchema(value);",
-    '  const ref = typeof schema.$ref === "string" ? schema.$ref : undefined;',
+    '  const ref = typeof schema["$ref"] === "string" ? schema["$ref"] : undefined;',
     "  if (!ref || seen.has(ref)) return schema;",
     '  const localName = ref.startsWith("#/components/schemas/") ? ref.slice(21) : ref.startsWith("#/$defs/") ? ref.slice(8) : ref.startsWith("#/definitions/") ? ref.slice(14) : ref;',
     '  if (ref.startsWith("#/$defs/") || ref.startsWith("#/definitions/")) {',
-    '    const defs = ref.startsWith("#/$defs/") ? schema.$defs : schema.definitions;',
+    '    const defs = ref.startsWith("#/$defs/") ? schema["$defs"] : schema["definitions"];',
     "    if (isRecord(defs) && defs[localName] !== undefined) return resolveRegistrySchema(defs[localName], new Set([...seen, ref]));",
     "  }",
     "  for (const [name, candidate] of Object.entries(OPENAPI_SCHEMA_REGISTRY)) {",
@@ -3394,18 +3400,18 @@ function renderOpenApi(graph, options) {
     "",
     "function schemaProperty(schema: unknown, name: string): OpenApiSchema {",
     "  const document = resolveRegistrySchema(schema);",
-    "  const properties = document.properties;",
+    '  const properties = document["properties"];',
     '  return isRecord(properties) && isRecord(properties[name]) ? properties[name] : { type: "string" };',
     "}",
     "",
     "function schemaPropertyNames(schema: unknown): string[] {",
     "  const document = resolveRegistrySchema(schema);",
-    "  return isRecord(document.properties) ? Object.keys(document.properties).sort() : [];",
+    '  return isRecord(document["properties"]) ? Object.keys(document["properties"]).sort() : [];',
     "}",
     "",
     "function schemaRequired(schema: unknown, name: string): boolean {",
     "  const document = resolveRegistrySchema(schema);",
-    "  return Array.isArray(document.required) && document.required.includes(name);",
+    '  return Array.isArray(document["required"]) && document["required"].includes(name);',
     "}",
     "",
     "function schemaReference(name: string): OpenApiSchema {",
@@ -4050,24 +4056,24 @@ function assertGraphqlOptions(value) {
   if (unsupported.length) {
     fail(`Unsupported options: ${unsupported.join(", ")}. Configure only schema, documents, scalars and typedDocuments; server schema authoring modes are not supported.`);
   }
-  const schema = options.schema;
+  const schema = options["schema"];
   if (typeof schema !== "string" || !schema.trim() || schema !== schema.trim() || /[\r\n\0]/.test(schema) || /^[a-z][a-z0-9+.-]*:/i.test(schema) && !/^[a-z]:[\\/]/i.test(schema) || ![".graphql", ".gql", ".json"].includes(extname(schema))) {
     fail("graphql.schema must be a local .graphql, .gql or .json database snapshot. Export it with graphql-schema; URLs, inline SDL and executable schema sources are not supported.");
   }
-  if (options.documents !== undefined && (!Array.isArray(options.documents) || options.documents.some((pattern) => typeof pattern !== "string" || !pattern.trim()))) {
+  if (options["documents"] !== undefined && (!Array.isArray(options["documents"]) || options["documents"].some((pattern) => typeof pattern !== "string" || !pattern.trim()))) {
     fail("graphql.documents must contain local query/fragment glob strings.");
   }
-  if (options.typedDocuments !== undefined && typeof options.typedDocuments !== "boolean") {
+  if (options["typedDocuments"] !== undefined && typeof options["typedDocuments"] !== "boolean") {
     fail("graphql.typedDocuments must be a boolean output option.");
   }
-  if (options.mutations !== undefined && typeof options.mutations !== "boolean") {
+  if (options["mutations"] !== undefined && typeof options["mutations"] !== "boolean") {
     fail("graphql.mutations must be a boolean opt-in for database-backed mutation documents.");
   }
-  if (options.scalars !== undefined) {
-    if (!options.scalars || typeof options.scalars !== "object" || Array.isArray(options.scalars)) {
+  if (options["scalars"] !== undefined) {
+    if (!options["scalars"] || typeof options["scalars"] !== "object" || Array.isArray(options["scalars"])) {
       fail("graphql.scalars must be a map of explicit wire types.");
     }
-    for (const mapping of Object.values(options.scalars)) {
+    for (const mapping of Object.values(options["scalars"])) {
       if (typeof mapping === "string" && mapping.trim())
         continue;
       if (mapping && typeof mapping === "object" && !Array.isArray(mapping) && "input" in mapping && typeof mapping.input === "string" && mapping.input.trim() && "output" in mapping && typeof mapping.output === "string" && mapping.output.trim())
@@ -4090,7 +4096,7 @@ var init_graphql_options = __esm(() => {
 
 // src/graphql-inputs.ts
 import { resolve as resolve5 } from "node:path";
-import * as ts10 from "@typescript/typescript6";
+import * as ts11 from "@typescript/typescript6";
 function graphqlInputPaths(options) {
   if (!options.graphql)
     return [];
@@ -4101,7 +4107,7 @@ function graphqlInputPaths(options) {
   }
   const root = resolve5(options.rootDir);
   const schema = resolve5(root, options.graphql.schema);
-  const documents = ts10.sys.readDirectory(root, [".graphql", ".gql"], ["**/node_modules/**", "**/.git/**", resolve5(options.outDir)], options.graphql.documents ?? ["**/*.graphql", "**/*.gql"]).map((path) => resolve5(path)).filter((path) => path !== schema);
+  const documents = ts11.sys.readDirectory(root, [".graphql", ".gql"], ["**/node_modules/**", "**/.git/**", resolve5(options.outDir)], options.graphql.documents ?? ["**/*.graphql", "**/*.gql"]).map((path) => resolve5(path)).filter((path) => path !== schema);
   return [schema, ...[...new Set(documents)].sort()];
 }
 var init_graphql_inputs = __esm(() => {
@@ -4109,7 +4115,7 @@ var init_graphql_inputs = __esm(() => {
 });
 
 // src/graphql-runtime.ts
-import * as ts11 from "@typescript/typescript6";
+import * as ts12 from "@typescript/typescript6";
 import { resolve as resolve6 } from "node:path";
 function renderGraphqlValidators(source, operationNames, operationKinds = new Map) {
   const fileName = resolve6("/__supacloud_graphql__/contracts.ts");
@@ -4121,18 +4127,18 @@ function renderGraphqlValidators(source, operationNames, operationKinds = new Ma
     noPropertyAccessFromIndexSignature: true,
     noFallthroughCasesInSwitch: true,
     skipLibCheck: false,
-    target: ts11.ScriptTarget.ES2022,
+    target: ts12.ScriptTarget.ES2022,
     lib: ["lib.es2022.d.ts"],
     types: [],
     noEmit: true
   };
-  const host = ts11.createCompilerHost(options);
+  const host = ts12.createCompilerHost(options);
   const getSourceFile = host.getSourceFile.bind(host);
-  host.getSourceFile = (path, languageVersion, onError, shouldCreateNewSourceFile) => resolve6(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);
+  host.getSourceFile = (path, languageVersion, onError, shouldCreateNewSourceFile) => resolve6(path) === fileName ? ts12.createSourceFile(path, source, languageVersion, true) : getSourceFile(path, languageVersion, onError, shouldCreateNewSourceFile);
+  const program = ts12.createProgram([fileName], options, host);
+  const diagnostics = ts12.getPreEmitDiagnostics(program);
   if (diagnostics.length) {
-    throw new Error(`Generated GraphQL types cannot be validated: ${diagnostics.map((item) => ts11.flattenDiagnosticMessageText(item.messageText, `
+    throw new Error(`Generated GraphQL types cannot be validated: ${diagnostics.map((item) => ts12.flattenDiagnosticMessageText(item.messageText, `
 `)).join("; ")}`);
   }
   const checker = program.getTypeChecker();
@@ -4162,25 +4168,25 @@ function renderGraphqlValidators(source, operationNames, operationKinds = new Ma
     return name;
   }
   function expression(type) {
-    if (type.flags & ts11.TypeFlags.Any)
+    if (type.flags & ts12.TypeFlags.Any)
       return unsupported(type);
-    if (type.flags & ts11.TypeFlags.Unknown)
+    if (type.flags & ts12.TypeFlags.Unknown)
       return "true";
-    if (type.flags & ts11.TypeFlags.Never)
+    if (type.flags & ts12.TypeFlags.Never)
       return "false";
-    if (type.flags & ts11.TypeFlags.Null)
+    if (type.flags & ts12.TypeFlags.Null)
       return "value === null";
-    if (type.flags & ts11.TypeFlags.Undefined)
+    if (type.flags & ts12.TypeFlags.Undefined)
       return "value === undefined";
     if (type.isStringLiteral() || type.isNumberLiteral())
       return `value === ${JSON.stringify(type.value)}`;
-    if (type.flags & ts11.TypeFlags.BooleanLiteral)
+    if (type.flags & ts12.TypeFlags.BooleanLiteral)
       return `value === ${checker.typeToString(type)}`;
-    if (type.flags & ts11.TypeFlags.String)
+    if (type.flags & ts12.TypeFlags.String)
       return 'typeof value === "string"';
-    if (type.flags & ts11.TypeFlags.Number)
+    if (type.flags & ts12.TypeFlags.Number)
       return 'typeof value === "number" && Number.isFinite(value)';
-    if (type.flags & ts11.TypeFlags.Boolean)
+    if (type.flags & ts12.TypeFlags.Boolean)
       return 'typeof value === "boolean"';
     if (type.isUnion())
       return type.types.map((part) => `${reference(part)}(value)`).join(" || ");
@@ -4189,16 +4195,16 @@ function renderGraphqlValidators(source, operationNames, operationKinds = new Ma
     if (checker.isTupleType(type))
       return unsupported(type);
     if (checker.isArrayType(type)) {
-      const item = checker.getIndexTypeOfType(type, ts11.IndexKind.Number);
+      const item = checker.getIndexTypeOfType(type, ts12.IndexKind.Number);
       if (!item)
         return unsupported(type);
       return `isGraphqlArray(value) && Array.from(value).every(${reference(item)})`;
     }
-    if (type.flags & ts11.TypeFlags.Object) {
+    if (type.flags & ts12.TypeFlags.Object) {
       if (type.getCallSignatures().length || type.getConstructSignatures().length)
         return unsupported(type);
       const indexes = checker.getIndexInfosOfType(type);
-      if (indexes.some((index) => !(index.keyType.flags & ts11.TypeFlags.String)))
+      if (indexes.some((index) => !(index.keyType.flags & ts12.TypeFlags.String)))
         return unsupported(type);
       const properties = checker.getPropertiesOfType(type).map((property) => {
         const declaration = property.valueDeclaration ?? property.declarations?.[0];
@@ -4207,7 +4213,7 @@ function renderGraphqlValidators(source, operationNames, operationKinds = new Ma
         const check = reference(checker.getTypeOfSymbolAtLocation(property, declaration));
         const key = JSON.stringify(property.name);
         const present = `Object.prototype.hasOwnProperty.call(value, ${key})`;
-        return property.flags & ts11.SymbolFlags.Optional ? `(!${present} || ${check}(value[${key}]))` : `(${present} && ${check}(value[${key}]))`;
+        return property.flags & ts12.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(" && ");
@@ -4345,8 +4351,8 @@ async function renderGraphql(options) {
       severity: "error",
       code,
       message: error instanceof Error ? error.message : String(error),
-      file: source ? localPath(source) : undefined,
-      line: gql?.locations?.[0]?.line,
+      ...source === undefined ? {} : { file: localPath(source) },
+      ...gql?.locations?.[0]?.line === undefined ? {} : { line: gql.locations[0].line },
       suggestion: "Update the role-scoped local schema snapshot or correct the query, then recompile."
     });
   };
@@ -4396,8 +4402,8 @@ async function renderGraphql(options) {
         severity: "error",
         code: "graphql-query-only",
         message: "GraphQL subscriptions are not supported by the HTTP contract compiler. Use the governed Realtime transport for subscriptions.",
-        file: definition.loc ? localPath(definition.loc.source.name) : undefined,
-        line: definition.loc?.startToken.line,
+        ...definition.loc ? { file: localPath(definition.loc.source.name) } : {},
+        ...definition.loc?.startToken.line === undefined ? {} : { line: definition.loc.startToken.line },
         suggestion: "Remove this subscription from the GraphQL documents and use the supported Realtime contract."
       });
     } else if (definition.operation === "mutation" && !options.graphql.mutations) {
@@ -4405,8 +4411,8 @@ async function renderGraphql(options) {
         severity: "error",
         code: "graphql-query-only",
         message: "GraphQL mutations are disabled by default. Set graphql.mutations to true only after reviewing database grants, RLS, audit and idempotency behavior.",
-        file: definition.loc ? localPath(definition.loc.source.name) : undefined,
-        line: definition.loc?.startToken.line,
+        ...definition.loc ? { file: localPath(definition.loc.source.name) } : {},
+        ...definition.loc?.startToken.line === undefined ? {} : { line: definition.loc.startToken.line },
         suggestion: "Keep business writes in the governed Command API, or explicitly opt in with graphql.mutations: true."
       });
     }
@@ -5216,11 +5222,22 @@ var init_dependent = __esm(() => {
 });
 
 // node_modules/typebox/build/type/engine/enum/typescript_enum_to_enum_values.mjs
+function IsTypeScriptEnumLike(value) {
+  return IsObjectNotArray(value);
+}
+function TypeScriptEnumToEnumValues(type) {
+  const keys = Keys(type).filter((key) => isNaN(key));
+  return keys.reduce((result, key) => [...result, type[key]], []);
+}
 var init_typescript_enum_to_enum_values = __esm(() => {
   init_guard2();
 });
 
 // node_modules/typebox/build/type/types/enum.mjs
+function Enum(value, options) {
+  const values = IsTypeScriptEnumLike(value) ? TypeScriptEnumToEnumValues(value) : value;
+  return Create({ "~kind": "Enum" }, { enum: values }, options);
+}
 function IsEnum(value) {
   return IsKind(value, "Enum");
 }
@@ -15322,6 +15339,12 @@ function createExecutionSnapshot(graph, subjects = graph.modules.map((module) =>
     contexts: subjects.map((subject) => {
       const context = createContextPack(graph, subject);
       const owner = graph.modules.find((module) => module.name === context.subject);
+      if (owner === undefined)
+        throw new Error(`Execution context owner is missing: ${context.subject}`);
+      const modules = context.modules.map((module) => {
+        const file = executionSourceFile(module.file);
+        return { name: module.name, ...file === undefined ? {} : { file } };
+      });
       return {
         subject: context.subject,
         aliases: [...new Set([
@@ -15332,10 +15355,7 @@ function createExecutionSnapshot(graph, subjects = graph.modules.map((module) =>
           ...(owner.jobs ?? []).flatMap((job) => [job.name, job.className, job.serviceKey]),
           ...owner.queries.flatMap((query) => [query.name, query.className])
         ])],
-        modules: context.modules.map((module) => ({
-          name: module.name,
-          ...executionSourceFile(module.file) ? { file: executionSourceFile(module.file) } : {}
-        })),
+        modules,
         files: context.files,
         diagnostics: context.diagnostics.map((diagnostic) => {
           const repair = createDiagnosticRepairPlan([diagnostic])[0];
@@ -15681,10 +15701,11 @@ function createApplicationDevelopmentContext(graph, options = {}) {
     const providers = bound(names(module.providers.map((provider) => provider.token)), moduleIndex < APPLICATION_DEVELOPMENT_LIMITS2.modules ? remainingProviders : 0);
     remainingProviders -= providers.items.length;
     omittedProviders += providers.omitted;
+    const file = executionSourceFile(module.file);
     developmentModules.push({
       name: module.name,
       className: module.className,
-      ...executionSourceFile(module.file) ? { file: executionSourceFile(module.file) } : {},
+      ...file === undefined ? {} : { file },
       ...module.tags && module.tags.length > 0 ? { tags: names(module.tags) } : {},
       providers: providers.items,
       controllers: names(module.controllers.map((controller) => controller.className)),
@@ -15697,6 +15718,7 @@ function createApplicationDevelopmentContext(graph, options = {}) {
       for (const route of controller.routes) {
         const candidates = module.commands.filter((command) => command.className === route.command || command.name === route.command);
         const command = candidates.length === 1 ? candidates[0]?.name : undefined;
+        const kinds = schemaKinds(route);
         routes.push({
           module: module.name,
           method: route.method,
@@ -15705,7 +15727,7 @@ function createApplicationDevelopmentContext(graph, options = {}) {
           handler: route.handler,
           ...command === undefined ? {} : { command },
           aspects: (route.aspects ?? []).map((aspect) => aspect.name),
-          ...schemaKinds(route) ? { schemaKinds: schemaKinds(route) } : {}
+          ...kinds === undefined ? {} : { schemaKinds: kinds }
         });
       }
     }
@@ -15738,11 +15760,13 @@ function createApplicationDevelopmentContext(graph, options = {}) {
   const diagnostics = [];
   for (const diagnostic of graph.diagnostics ?? []) {
     const repair = createDiagnosticRepairPlan([diagnostic])[0];
+    const file = executionSourceFile(diagnostic.file);
+    const line = Number.isSafeInteger(diagnostic.line) && diagnostic.line !== undefined && diagnostic.line > 0 ? diagnostic.line : undefined;
     diagnostics.push({
       code: diagnostic.code,
       severity: diagnostic.severity,
-      ...executionSourceFile(diagnostic.file) ? { file: executionSourceFile(diagnostic.file) } : {},
-      ...Number.isSafeInteger(diagnostic.line) && diagnostic.line > 0 ? { line: diagnostic.line } : {},
+      ...file === undefined ? {} : { file },
+      ...line === undefined ? {} : { line },
       ...repair ? { repair: { type: repair.type, readiness: repair.readiness } } : {}
     });
   }
@@ -15992,7 +16016,7 @@ var init_application_configuration = __esm(() => {
 });
 
 // node_modules/@supacloud/delivery/src/application-activation.ts
-var ApplicationActivationIdSchema, ApplicationActivationWriteSchema, ApplicationActivationResultSchema, ApplicationActivationRetirementResultSchema;
+var ApplicationActivationIdSchema, ApplicationActivationWriteSchema, ApplicationActivationResultSchema, ApplicationActivationRetirementResultSchema, RollbackActivationSchema, ApplicationRollbackSnapshotSchema;
 var init_application_activation = __esm(() => {
   init_build();
   init_application_configuration();
@@ -16019,16 +16043,261 @@ var init_application_activation = __esm(() => {
     activation_id: ApplicationActivationIdSchema,
     retired_at: String2()
   }, { additionalProperties: false });
+  RollbackActivationSchema = _Object_({
+    release_id: ApplicationReleaseIdSchema,
+    configuration_id: ApplicationConfigurationIdSchema,
+    activation_id: ApplicationActivationIdSchema
+  }, { additionalProperties: false });
+  ApplicationRollbackSnapshotSchema = _Object_({
+    schema: Literal("supacloud.application-rollback-snapshot.v1"),
+    project_ref: String2({ pattern: "^[a-z0-9-]{1,20}$" }),
+    application_id: ApplicationIdSchema,
+    environment_id: ApplicationIdSchema,
+    active: Union([RollbackActivationSchema, Null()]),
+    previous: Union([RollbackActivationSchema, Null()])
+  }, { additionalProperties: false });
+});
+
+// node_modules/@supacloud/delivery/src/application-deploy-plan.ts
+var CandidateSchema, ApplicationDeployPlanSchema;
+var init_application_deploy_plan = __esm(() => {
+  init_build();
+  init_value2();
+  init_application_release();
+  init_application_activation();
+  init_application_configuration();
+  CandidateSchema = _Object_({
+    release_id: ApplicationReleaseIdSchema,
+    configuration_id: ApplicationConfigurationIdSchema
+  }, { additionalProperties: false });
+  ApplicationDeployPlanSchema = _Object_({
+    schema: Literal("supacloud.application-deploy-plan.v1"),
+    project_ref: String2({ pattern: "^[a-z0-9-]{1,20}$" }),
+    application_id: ApplicationIdSchema,
+    environment_id: ApplicationIdSchema,
+    candidate: CandidateSchema,
+    current: Union([_Object_({
+      ...CandidateSchema.properties,
+      activation_id: ApplicationActivationIdSchema
+    }, { additionalProperties: false }), Null()]),
+    expected_activation_id: Union([ApplicationActivationIdSchema, Null()]),
+    action: Union([Literal("activate"), Literal("no-op")]),
+    changes: _Object_({
+      release: Boolean2(),
+      configuration: Boolean2(),
+      targets: _Object_({
+        added: _Array_(String2()),
+        removed: _Array_(String2()),
+        changed: _Array_(String2())
+      }, { additionalProperties: false })
+    }, { additionalProperties: false }),
+    migrations: _Object_({
+      ledger_digest: ApplicationReleaseIdSchema,
+      ledger_compatible: Boolean2(),
+      project_migrations_applied: Boolean2(),
+      operator_provisioning: Union([
+        Literal("separate-verification-required"),
+        Literal("not-declared")
+      ])
+    }, { additionalProperties: false }),
+    compatibility: Literal("not-proven"),
+    execution_performed: Literal(false)
+  }, { additionalProperties: false });
+});
+
+// node_modules/@supacloud/delivery/src/application-release-operation.ts
+var closed6, nullableActivation, ApplicationReleaseRequestSchema, ApplicationReleaseResultSchema;
+var init_application_release_operation = __esm(() => {
+  init_build();
+  init_value2();
+  init_application_activation();
+  init_application_configuration();
+  init_application_release();
+  closed6 = { additionalProperties: false };
+  nullableActivation = Union([ApplicationActivationIdSchema, Null()]);
+  ApplicationReleaseRequestSchema = _Object_({
+    release_id: ApplicationReleaseIdSchema,
+    configuration_id: Optional(ApplicationConfigurationIdSchema),
+    configuration_write: Optional(ApplicationConfigurationWriteSchema),
+    activation_id: Optional(ApplicationActivationIdSchema),
+    expected_activation_id: Optional(nullableActivation),
+    expected_plan_sha256: Optional(ApplicationReleaseIdSchema)
+  }, closed6);
+  ApplicationReleaseResultSchema = _Object_({
+    schema: Literal("supacloud.application-release.v1"),
+    project_ref: String2({ pattern: "^[a-z0-9-]{1,20}$" }),
+    application_id: ApplicationIdSchema,
+    environment_id: ApplicationIdSchema,
+    release_id: ApplicationReleaseIdSchema,
+    configuration_id: ApplicationConfigurationIdSchema,
+    activation_id: ApplicationActivationIdSchema,
+    expected_activation_id: nullableActivation,
+    plan_sha256: ApplicationReleaseIdSchema,
+    action: Union([Literal("activate"), Literal("no-op")]),
+    replayed: Boolean2(),
+    execution_performed: Boolean2()
+  }, closed6);
+});
+
+// node_modules/@supacloud/delivery/src/application-history.ts
+var scope, timestamp, ApplicationActivationHistoryPositionSchema, cursorSchema, ApplicationActivationHistoryCursorSchema, entrySchema, ApplicationActivationHistorySchema;
+var init_application_history = __esm(() => {
+  init_build();
+  init_value2();
+  init_application_activation();
+  init_application_configuration();
+  init_application_release();
+  scope = {
+    project_ref: String2({ pattern: "^[a-z0-9-]{1,20}$" }),
+    application_id: ApplicationIdSchema,
+    environment_id: ApplicationIdSchema
+  };
+  timestamp = String2({ pattern: "^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}\\.\\d{6}Z$" });
+  ApplicationActivationHistoryPositionSchema = _Object_({
+    completed_at: timestamp,
+    activation_id: ApplicationActivationIdSchema
+  }, { additionalProperties: false });
+  cursorSchema = _Object_({
+    ...scope,
+    ...ApplicationActivationHistoryPositionSchema.properties
+  }, { additionalProperties: false });
+  ApplicationActivationHistoryCursorSchema = String2({
+    pattern: "^[A-Za-z0-9_-]+$",
+    maxLength: 1024,
+    minLength: 1
+  });
+  entrySchema = _Object_({
+    ...ApplicationActivationHistoryPositionSchema.properties,
+    release_id: ApplicationReleaseIdSchema,
+    configuration_id: Union([ApplicationConfigurationIdSchema, Null()]),
+    previous_activation_id: Union([ApplicationActivationIdSchema, Null()]),
+    is_active: Boolean2()
+  }, { additionalProperties: false });
+  ApplicationActivationHistorySchema = _Object_({
+    schema: Literal("supacloud.application-activation-history.v1"),
+    ...scope,
+    active_activation_id: Union([ApplicationActivationIdSchema, Null()]),
+    activations: _Array_(entrySchema, { maxItems: 100 }),
+    next_cursor: Union([ApplicationActivationHistoryCursorSchema, Null()])
+  }, { additionalProperties: false });
+});
+
+// node_modules/@supacloud/delivery/src/application-preview.ts
+var phaseStatus, closed7, ApplicationPreviewReceiptSchema;
+var init_application_preview = __esm(() => {
+  init_build();
+  init_value2();
+  init_application_configuration();
+  init_application_activation();
+  init_application_release();
+  phaseStatus = Union([
+    Literal("pending"),
+    Literal("ready"),
+    Literal("failed"),
+    Literal("cleaned")
+  ]);
+  closed7 = { additionalProperties: false };
+  ApplicationPreviewReceiptSchema = _Object_({
+    schema: Literal("supacloud.application-preview.v1"),
+    preview_id: String2({ pattern: "^[a-f0-9-]{8,64}$" }),
+    project_ref: String2({ pattern: "^[a-z0-9-]{1,20}$" }),
+    application_id: ApplicationIdSchema,
+    environment_id: ApplicationIdSchema,
+    release_id: ApplicationReleaseIdSchema,
+    expires_at: Optional(Union([String2({
+      pattern: "^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}\\.\\d{3}Z$",
+      maxLength: 24
+    }), Null()])),
+    status: Union([
+      Literal("planned"),
+      Literal("provisioning"),
+      Literal("ready"),
+      Literal("failed"),
+      Literal("cleaned")
+    ]),
+    resources: _Object_({
+      build_artifact: _Object_({ status: phaseStatus, release_id: ApplicationReleaseIdSchema }, closed7),
+      database_branch: _Object_({
+        status: phaseStatus,
+        branch_ref: String2({ pattern: "^[A-Za-z0-9_-]{1,20}$" }),
+        data_mode: Union([Literal("schema_only"), Literal("full_clone")])
+      }, closed7),
+      queue_namespace: _Object_({
+        status: phaseStatus,
+        namespace: String2({ minLength: 1, maxLength: 128 })
+      }, closed7),
+      storage_namespace: _Object_({
+        status: phaseStatus,
+        namespace: String2({ minLength: 1, maxLength: 128 })
+      }, closed7),
+      test_secret: _Object_({
+        status: phaseStatus,
+        name: String2({ minLength: 1, maxLength: 128 }),
+        value_issued: Literal(false)
+      }, closed7),
+      configuration_revision: _Object_({
+        status: phaseStatus,
+        configuration_id: Union([ApplicationConfigurationIdSchema, Null()])
+      }, closed7),
+      application_activation: _Object_({
+        status: phaseStatus,
+        activation_id: Union([ApplicationActivationIdSchema, Null()])
+      }, closed7),
+      smoke_test: _Object_({
+        status: phaseStatus,
+        checks: _Array_(String2({ minLength: 1, maxLength: 64 }), { maxItems: 32 }),
+        passed: _Array_(String2({ minLength: 1, maxLength: 64 }), { maxItems: 32 }),
+        failed: _Array_(String2({ minLength: 1, maxLength: 64 }), { maxItems: 32 })
+      }, closed7)
+    }, closed7),
+    cleanup: _Object_({
+      required: Boolean2(),
+      completed: Boolean2(),
+      error: Union([String2({ minLength: 1, maxLength: 128 }), Null()])
+    }, closed7)
+  }, closed7);
+});
+
+// node_modules/@supacloud/delivery/src/application-release-transfer.ts
+var projectRef, source, identity, ApplicationReleaseTransferPlanSchema, ApplicationReleaseTransferResultSchema;
+var init_application_release_transfer = __esm(() => {
+  init_build();
+  init_value2();
+  init_application_release();
+  projectRef = String2({ pattern: "^[A-Za-z0-9_-]{1,20}$" });
+  source = _Object_({
+    project_ref: projectRef,
+    release_id: ApplicationReleaseIdSchema,
+    manifest_sha256: ApplicationReleaseIdSchema
+  }, { additionalProperties: false });
+  identity = {
+    project_ref: projectRef,
+    application_id: ApplicationIdSchema,
+    source,
+    candidate_release_id: ApplicationReleaseIdSchema
+  };
+  ApplicationReleaseTransferPlanSchema = _Object_({
+    schema: Literal("supacloud.application-release-transfer-plan.v1"),
+    ...identity,
+    action: Union([Literal("materialize"), Literal("no-op")]),
+    execution_performed: Literal(false)
+  }, { additionalProperties: false });
+  ApplicationReleaseTransferResultSchema = _Object_({
+    schema: Literal("supacloud.application-release-transfer-result.v1"),
+    ...identity,
+    release: ApplicationReleaseRecordSchema,
+    activation_performed: Literal(false)
+  }, { additionalProperties: false });
 });
 
 // node_modules/@supacloud/delivery/src/deployment-evidence.ts
-var closed6, sha256, isoDate, status, evidenceStatus, DEPLOYMENT_EVIDENCE_SCHEMA = "supacloud.deployment-evidence.v1", DatabaseProviderSchema, componentName, DeploymentComponentEvidenceSchema, DeploymentEvidenceSchema;
+var closed8, sha256, isoDate, status, evidenceStatus, DEPLOYMENT_EVIDENCE_SCHEMA = "supacloud.deployment-evidence.v1", DatabaseProviderSchema, componentName, DeploymentComponentEvidenceSchema, DeploymentEvidenceSchema;
 var init_deployment_evidence = __esm(() => {
   init_build();
   init_value2();
   init_application_configuration();
   init_application_release();
-  closed6 = { additionalProperties: false };
+  closed8 = { additionalProperties: false };
   sha256 = String2({ pattern: "^[a-f0-9]{64}$" });
   isoDate = String2({ minLength: 20, maxLength: 40 });
   status = Union([
@@ -16054,19 +16323,19 @@ var init_deployment_evidence = __esm(() => {
         Literal("not-proven"),
         Literal("failed")
       ])
-    }, closed6),
+    }, closed8),
     backup: _Object_({
       status,
       latest_success_at: Union([isoDate, Null()]),
       freshness_seconds: Union([Integer({ minimum: 0 }), Null()])
-    }, closed6),
+    }, closed8),
     recovery: _Object_({
       status,
       drill_id: Union([String2({ minLength: 1, maxLength: 128 }), Null()]),
       rpo_seconds: Union([Integer({ minimum: 0 }), Null()]),
       rto_seconds: Union([Integer({ minimum: 0 }), Null()])
-    }, closed6)
-  }, closed6);
+    }, closed8)
+  }, closed8);
   componentName = Union([
     Literal("management-api"),
     Literal("web-console"),
@@ -16084,7 +16353,7 @@ var init_deployment_evidence = __esm(() => {
     status,
     health_check: Union([String2({ minLength: 1, maxLength: 256 }), Null()]),
     checked_at: Union([isoDate, Null()])
-  }, closed6);
+  }, closed8);
   DeploymentEvidenceSchema = _Object_({
     schema: Literal(DEPLOYMENT_EVIDENCE_SCHEMA),
     status: evidenceStatus,
@@ -16093,33 +16362,110 @@ var init_deployment_evidence = __esm(() => {
       project_ref: String2({ pattern: "^[a-z0-9-]{1,20}$" }),
       application_id: ApplicationIdSchema,
       environment_id: ApplicationIdSchema
-    }, closed6),
+    }, closed8),
     source: _Object_({
       commit_sha: Union([String2({ pattern: "^[0-9a-f]{7,64}$" }), Null()]),
       manifest_sha256: sha256,
       contract_schema: Union([String2({ minLength: 1, maxLength: 128 }), Null()]),
       environment_binding_version: Union([sha256, Null()])
-    }, closed6),
+    }, closed8),
     database: DatabaseProviderSchema,
     components: _Array_(DeploymentComponentEvidenceSchema, { minItems: 1, maxItems: 32 }),
     activation: _Object_({
       release_id: ApplicationReleaseIdSchema,
       configuration_id: ApplicationConfigurationIdSchema,
       activation_id: ApplicationConfigurationIdSchema
-    }, closed6),
+    }, closed8),
     health: _Object_({
       status,
       checked_at: Union([isoDate, Null()]),
       authenticated_smoke: status
-    }, closed6),
+    }, closed8),
     rollback: _Object_({
       release_id: Union([ApplicationReleaseIdSchema, Null()]),
       configuration_id: Union([ApplicationConfigurationIdSchema, Null()]),
       status: Union([Literal("ready"), Literal("not-ready"), Literal("unknown")]),
       result: Union([status, Null()])
-    }, closed6),
+    }, closed8),
     notes: _Array_(String2({ minLength: 1, maxLength: 512 }), { maxItems: 32 })
-  }, closed6);
+  }, closed8);
+});
+
+// node_modules/@supacloud/delivery/src/application-promotion.ts
+var closed9, projectRef2, sha2562, nullableActivation2, nullableDigest, observation, blocker, ApplicationPromotionPlanSchema;
+var init_application_promotion = __esm(() => {
+  init_build();
+  init_value2();
+  init_delivery_files();
+  init_application_activation();
+  init_application_configuration();
+  init_application_release();
+  closed9 = { additionalProperties: false };
+  projectRef2 = String2({ pattern: "^[a-z0-9-]{1,20}$" });
+  sha2562 = ApplicationReleaseIdSchema;
+  nullableActivation2 = Union([ApplicationActivationIdSchema, Null()]);
+  nullableDigest = Union([sha2562, Null()]);
+  observation = {
+    activation_id: nullableActivation2,
+    receipt_confirmed: Boolean2(),
+    ready: Boolean2(),
+    smoke_verified: Boolean2(),
+    evidence_sha256: nullableDigest,
+    migration_ledger_digest: nullableDigest
+  };
+  blocker = [
+    "SOURCE_NOT_ACTIVE",
+    "SOURCE_RECEIPT_UNCONFIRMED",
+    "SOURCE_NOT_READY",
+    "SOURCE_SMOKE_UNVERIFIED",
+    "TARGET_CONFIGURATION_MISSING",
+    "TARGET_CONFIGURATION_MISMATCH",
+    "MIGRATION_PENDING",
+    "MIGRATION_CONFLICT",
+    "OPERATOR_PROVISIONING_REQUIRED",
+    "BACKUP_REQUIRED"
+  ];
+  ApplicationPromotionPlanSchema = _Object_({
+    schema: Literal("supacloud.application-promotion-plan.v1"),
+    project_ref: projectRef2,
+    application_id: ApplicationIdSchema,
+    environment_id: ApplicationIdSchema,
+    manifest_sha256: sha2562,
+    plan_sha256: sha2562,
+    source: _Object_({
+      project_ref: projectRef2,
+      environment_id: ApplicationIdSchema,
+      release_id: sha2562,
+      ...observation
+    }, closed9),
+    target: _Object_({
+      candidate_release_id: sha2562,
+      current_release_id: Union([sha2562, Null()]),
+      artifact_action: Union([Literal("materialize"), Literal("reuse")]),
+      configuration_id: Union([ApplicationConfigurationIdSchema, Null()]),
+      configuration: Union([ApplicationConfigurationViewSchema, Null()]),
+      ...observation
+    }, closed9),
+    migrations: _Object_({
+      ledger_digest: sha2562,
+      ledger_compatible: Boolean2(),
+      project_migrations_applied: Boolean2(),
+      pending_versions: _Array_(String2({ pattern: "^\\d{1,20}$" }), { maxItems: 4096, uniqueItems: true }),
+      operator_provisioning_required: Boolean2()
+    }, closed9),
+    backup: _Object_({
+      required: Boolean2(),
+      confirmed: Literal(false)
+    }, closed9),
+    action: Union([Literal("promote"), Literal("no-op"), Literal("blocked")]),
+    blockers: _Array_(Enum([...blocker]), {
+      maxItems: blocker.length,
+      uniqueItems: true
+    }),
+    steps: _Array_(String2({ minLength: 1, maxLength: 64 }), { maxItems: 8, uniqueItems: true }),
+    execution_performed: Literal(false),
+    data_recovery: Literal("separate-required")
+  }, closed9);
 });
 
 // node_modules/@supacloud/delivery/src/application-runtime-identity.ts
@@ -16210,13 +16556,13 @@ async function readDeliveryMigrationArchive(manifestPath, target) {
     throw new Error("Invalid delivery migration archive.");
   }
 }
-var entrySchema, archiveSchema;
+var entrySchema2, archiveSchema;
 var init_delivery_migration_archive = __esm(() => {
   init_build();
   init_value2();
   init_delivery_artifact();
   init_delivery_files();
-  entrySchema = _Object_({
+  entrySchema2 = _Object_({
     version: String2({ pattern: "^[1-9][0-9]{0,18}$" }),
     name: String2({ pattern: "^[A-Za-z][A-Za-z0-9_-]{0,127}$" }),
     executor: Union([Literal("project-migration"), Literal("operator-provisioning")]),
@@ -16230,7 +16576,7 @@ var init_delivery_migration_archive = __esm(() => {
     compatibility: Literal("not-proven"),
     executionPerformed: Literal(false),
     dataRecovery: Literal("separate-required"),
-    migrations: _Array_(entrySchema, { minItems: 1, maxItems: 128 })
+    migrations: _Array_(entrySchema2, { minItems: 1, maxItems: 128 })
   }, { additionalProperties: false });
 });
 
@@ -16243,9 +16589,15 @@ var init_src = __esm(() => {
   init_worker_execution();
   init_worker_execution();
   init_application_activation();
+  init_application_deploy_plan();
+  init_application_release_operation();
+  init_application_history();
   init_application_release();
+  init_application_preview();
+  init_application_release_transfer();
   init_application_configuration();
   init_deployment_evidence();
+  init_application_promotion();
   init_application_runtime_identity();
   init_delivery_build_schema();
   init_delivery_migration_archive();
@@ -16261,7 +16613,7 @@ var init_delivery_migration_archive2 = __esm(() => {
 import { createHash as createHash9, randomUUID } from "node:crypto";
 import { lstat as lstat2, readFile as readFile6, realpath as realpath4, rename as rename4, unlink as unlink2, writeFile as writeFile3 } from "node:fs/promises";
 import { dirname as dirname8, isAbsolute as isAbsolute3, relative as relative8, resolve as resolve13, sep as sep8 } from "node:path";
-import * as ts15 from "@typescript/typescript6";
+import * as ts16 from "@typescript/typescript6";
 async function applyDiagnosticFix(fix, options = {}) {
   if (!fix || typeof fix.targetFile !== "string")
     throw new Error("Invalid DiagnosticFix");
@@ -16290,7 +16642,7 @@ async function applyDiagnosticFix(fix, options = {}) {
       if (!current || current.initializer.getText(source) !== fix.expectedExpression) {
         throw new Error("Command mode changed since diagnosis; analyze the project again");
       }
-      content = replaceProperty(source, object, fix.property, ts15.factory.createStringLiteral(fix.value));
+      content = replaceProperty(source, object, fix.property, ts16.factory.createStringLiteral(fix.value));
       break;
     }
     case "add_module_import": {
@@ -16301,15 +16653,15 @@ async function applyDiagnosticFix(fix, options = {}) {
       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 && !ts15.isArrayLiteralExpression(imports.initializer)) {
+      if (imports && !ts16.isArrayLiteralExpression(imports.initializer)) {
         throw new Error("Module imports must be a static array");
       }
-      const values = imports && ts15.isArrayLiteralExpression(imports.initializer) ? imports.initializer.elements : [];
-      if (values.some(ts15.isSpreadElement))
+      const values = imports && ts16.isArrayLiteralExpression(imports.initializer) ? imports.initializer.elements : [];
+      if (values.some(ts16.isSpreadElement))
         throw new Error("Module imports cannot contain spread elements");
-      content = values.some((value) => ts15.isIdentifier(value) && value.text === fix.symbol) ? withImport : replaceProperty(source, object, "imports", ts15.factory.createArrayLiteralExpression([
+      content = values.some((value) => ts16.isIdentifier(value) && value.text === fix.symbol) ? withImport : replaceProperty(source, object, "imports", ts16.factory.createArrayLiteralExpression([
         ...values,
-        ts15.factory.createIdentifier(fix.symbol)
+        ts16.factory.createIdentifier(fix.symbol)
       ]));
       break;
     }
@@ -16321,24 +16673,24 @@ async function applyDiagnosticFix(fix, options = {}) {
       const command = findClass(source, fix.command);
       const object = decoratorObject(command, "Command");
       const current = property(object, "permission");
-      if (current && (!ts15.isStringLiteral(current.initializer) || current.initializer.text !== permission)) {
+      if (current && (!ts16.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", ts15.factory.createStringLiteral(permission));
+      content = current ? original : replaceProperty(source, object, "permission", ts16.factory.createStringLiteral(permission));
       break;
     }
     case "add_route_parameter_binding": {
       const controller = findClass(source, fix.controller);
-      const method = unique(controller.members.filter((member) => ts15.isMethodDeclaration(member) && nameOf(member.name) === fix.route), "route handler");
-      const parameter = unique(method.parameters.filter((candidate) => ts15.isIdentifier(candidate.name) && candidate.name.text === fix.parameter), "same-named route parameter");
+      const method = unique(controller.members.filter((member) => ts16.isMethodDeclaration(member) && nameOf(member.name) === fix.route), "route handler");
+      const parameter = unique(method.parameters.filter((candidate) => ts16.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 = ts15.getDecorators(parameter) ?? [];
+      const decorators = ts16.getDecorators(parameter) ?? [];
       if (decorators.length > 0)
         throw new Error("Parameter already has a decorator");
-      const framework = unique(source.statements.filter((statement) => ts15.isImportDeclaration(statement) && statement.importClause?.namedBindings && ts15.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 (!ts15.isImportDeclaration(framework) || !ts15.isStringLiteral(framework.moduleSpecifier)) {
+      const framework = unique(source.statements.filter((statement) => ts16.isImportDeclaration(statement) && statement.importClause?.namedBindings && ts16.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 (!ts16.isImportDeclaration(framework) || !ts16.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));
@@ -16364,20 +16716,22 @@ async function applyDiagnosticFix(fix, options = {}) {
   return result;
 }
 function parse5(file, text) {
-  const result = ts15.transpileModule(text, {
+  const result = ts16.transpileModule(text, {
     fileName: file,
     reportDiagnostics: true,
-    compilerOptions: { target: ts15.ScriptTarget.ESNext, experimentalDecorators: true }
+    compilerOptions: { target: ts16.ScriptTarget.ESNext, experimentalDecorators: true }
   });
-  if (result.diagnostics?.some((item) => item.category === ts15.DiagnosticCategory.Error)) {
+  if (result.diagnostics?.some((item) => item.category === ts16.DiagnosticCategory.Error)) {
     throw new Error("Cannot fix syntactically invalid TypeScript");
   }
-  return ts15.createSourceFile(file, text, ts15.ScriptTarget.Latest, true, ts15.ScriptKind.TS);
+  return ts16.createSourceFile(file, text, ts16.ScriptTarget.Latest, true, ts16.ScriptKind.TS);
 }
 function unique(items, description) {
-  if (items.length !== 1)
+  const [item] = items;
+  if (items.length !== 1 || item === undefined) {
     throw new Error(`Expected exactly one ${description}; found ${items.length}`);
-  return items[0];
+  }
+  return item;
 }
 function identifier2(value) {
   if (!/^[A-Za-z_$][\w$]*$/.test(value))
@@ -16386,50 +16740,50 @@ function identifier2(value) {
 function nameOf(name) {
   if (!name)
     return "";
-  return ts15.isIdentifier(name) || ts15.isStringLiteral(name) || ts15.isNumericLiteral(name) ? name.text : "";
+  return ts16.isIdentifier(name) || ts16.isStringLiteral(name) || ts16.isNumericLiteral(name) ? name.text : "";
 }
 function property(object, key) {
-  if (object.properties.some((item) => !ts15.isPropertyAssignment(item) || ts15.isComputedPropertyName(item.name))) {
+  if (object.properties.some((item) => !ts16.isPropertyAssignment(item) || ts16.isComputedPropertyName(item.name))) {
     throw new Error("Fix requires explicit static object properties");
   }
-  const values = object.properties.filter((item) => ts15.isPropertyAssignment(item) && nameOf(item.name) === key);
+  const values = object.properties.filter((item) => ts16.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 && ts15.isStringLiteral(value) ? value.text : undefined;
+  return value && ts16.isStringLiteral(value) ? value.text : undefined;
 }
 function replaceProperty(source, object, key, value) {
   const previous = property(object, key);
-  const replacement = ts15.factory.createPropertyAssignment(key, value);
+  const replacement = ts16.factory.createPropertyAssignment(key, value);
   const properties = object.properties.map((item) => item === previous ? replacement : item);
   if (!previous)
     properties.push(replacement);
-  const updated = ts15.factory.updateObjectLiteralExpression(object, properties);
-  return source.text.slice(0, object.getStart(source)) + ts15.createPrinter().printNode(ts15.EmitHint.Expression, updated, source) + source.text.slice(object.end);
+  const updated = ts16.factory.updateObjectLiteralExpression(object, properties);
+  return source.text.slice(0, object.getStart(source)) + ts16.createPrinter().printNode(ts16.EmitHint.Expression, updated, source) + source.text.slice(object.end);
 }
 function findClass(source, name) {
-  return unique(source.statements.filter((statement) => ts15.isClassDeclaration(statement) && statement.name?.text === name), `class '${name}'`);
+  return unique(source.statements.filter((statement) => ts16.isClassDeclaration(statement) && statement.name?.text === name), `class '${name}'`);
 }
 function decoratorObject(node, name) {
-  const decorator = unique((ts15.getDecorators(node) ?? []).filter((item) => ts15.isCallExpression(item.expression) && item.expression.expression.getText() === name), `@${name} decorator`);
-  const argument = ts15.isCallExpression(decorator.expression) ? decorator.expression.arguments[0] : undefined;
-  if (!argument || !ts15.isObjectLiteralExpression(argument))
+  const decorator = unique((ts16.getDecorators(node) ?? []).filter((item) => ts16.isCallExpression(item.expression) && item.expression.expression.getText() === name), `@${name} decorator`);
+  const argument = ts16.isCallExpression(decorator.expression) ? decorator.expression.arguments[0] : undefined;
+  if (!argument || !ts16.isObjectLiteralExpression(argument))
     throw new Error(`@${name} requires a static object`);
   return argument;
 }
 function moduleObjects(source) {
   const result = [];
   for (const statement of source.statements) {
-    if (ts15.isClassDeclaration(statement) && (ts15.getDecorators(statement) ?? []).some((item) => ts15.isCallExpression(item.expression) && item.expression.expression.getText() === "Module")) {
+    if (ts16.isClassDeclaration(statement) && (ts16.getDecorators(statement) ?? []).some((item) => ts16.isCallExpression(item.expression) && item.expression.expression.getText() === "Module")) {
       result.push(decoratorObject(statement, "Module"));
     }
-    if (ts15.isVariableStatement(statement)) {
+    if (ts16.isVariableStatement(statement)) {
       for (const declaration of statement.declarationList.declarations) {
         const call = declaration.initializer;
-        if (call && ts15.isCallExpression(call) && ["defineModule", "defineFeatureSlice"].includes(call.expression.getText()) && call.arguments[0] && ts15.isObjectLiteralExpression(call.arguments[0])) {
+        if (call && ts16.isCallExpression(call) && ["defineModule", "defineFeatureSlice"].includes(call.expression.getText()) && call.arguments[0] && ts16.isObjectLiteralExpression(call.arguments[0])) {
           result.push(call.arguments[0]);
         }
       }
@@ -16443,19 +16797,19 @@ function importSymbol(source, path, symbol) {
   const target = resolve13(dirname8(source.fileName), path).replace(/\.(tsx?|mts|cts)$/, "");
   if (current === target)
     return source.text;
-  const matches = source.statements.filter((item) => ts15.isImportDeclaration(item) && ts15.isStringLiteral(item.moduleSpecifier) && item.moduleSpecifier.text === path);
+  const matches = source.statements.filter((item) => ts16.isImportDeclaration(item) && ts16.isStringLiteral(item.moduleSpecifier) && item.moduleSpecifier.text === path);
   if (matches.length > 1)
     throw new Error(`Ambiguous imports from '${path}'`);
   const match = matches[0];
-  if (match && ts15.isImportDeclaration(match) && match.importClause?.namedBindings && ts15.isNamedImports(match.importClause.namedBindings) && !match.importClause.isTypeOnly) {
+  if (match && ts16.isImportDeclaration(match) && match.importClause?.namedBindings && ts16.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 = ts15.factory.updateNamedImports(bindings, [
+    const updated = ts16.factory.updateNamedImports(bindings, [
       ...bindings.elements,
-      ts15.factory.createImportSpecifier(false, undefined, ts15.factory.createIdentifier(symbol))
+      ts16.factory.createImportSpecifier(false, undefined, ts16.factory.createIdentifier(symbol))
     ]);
-    return source.text.slice(0, bindings.getStart(source)) + ts15.createPrinter().printNode(ts15.EmitHint.Unspecified, updated, source) + source.text.slice(bindings.end);
+    return source.text.slice(0, bindings.getStart(source)) + ts16.createPrinter().printNode(ts16.EmitHint.Unspecified, updated, source) + source.text.slice(bindings.end);
   }
   if (match)
     throw new Error(`Import from '${path}' is not a named value import`);
@@ -16483,21 +16837,21 @@ function requestIdentifier(input) {
 }
 function decodeMetadata(input) {
   const envelope = record4(input);
-  if (Object.keys(envelope).some((key) => key !== "version" && key !== "events") || envelope.version !== 1 || !Array.isArray(envelope.events) || envelope.events.length > EXECUTION_CONTEXT_LIMITS.inputEvents)
+  if (Object.keys(envelope).some((key) => key !== "version" && key !== "events") || envelope["version"] !== 1 || !Array.isArray(envelope["events"]) || envelope["events"].length > EXECUTION_CONTEXT_LIMITS.inputEvents)
     return invalid();
-  const events = envelope.events.map((entry) => {
+  const events = envelope["events"].map((entry) => {
     const event = record4(entry);
-    if (Object.keys(event).some((key) => !["kind", "operation", "stage", "phase", "requestId", "durationMs", "attempt", "traceId"].includes(key)) || event.kind !== "route" && event.kind !== "command" && event.kind !== "job" || event.phase !== "started" && event.phase !== "succeeded" && event.phase !== "failed" || !metadataText(event.operation, 512) || !metadataText(event.stage, 256) || "requestId" in event && !requestIdentifier(event.requestId) || "traceId" in event && !requestIdentifier(event.traceId) || "attempt" in event && (typeof event.attempt !== "number" || !Number.isInteger(event.attempt) || event.attempt < 1 || event.attempt > 1e6) || "durationMs" in event && (typeof event.durationMs !== "number" || !Number.isFinite(event.durationMs) || event.durationMs < 0 || event.durationMs > Number.MAX_SAFE_INTEGER))
+    if (Object.keys(event).some((key) => !["kind", "operation", "stage", "phase", "requestId", "durationMs", "attempt", "traceId"].includes(key)) || event["kind"] !== "route" && event["kind"] !== "command" && event["kind"] !== "job" || event["phase"] !== "started" && event["phase"] !== "succeeded" && event["phase"] !== "failed" || !metadataText(event["operation"], 512) || !metadataText(event["stage"], 256) || "requestId" in event && !requestIdentifier(event["requestId"]) || "traceId" in event && !requestIdentifier(event["traceId"]) || "attempt" in event && (typeof event["attempt"] !== "number" || !Number.isInteger(event["attempt"]) || event["attempt"] < 1 || event["attempt"] > 1e6) || "durationMs" in event && (typeof event["durationMs"] !== "number" || !Number.isFinite(event["durationMs"]) || event["durationMs"] < 0 || event["durationMs"] > Number.MAX_SAFE_INTEGER))
       return invalid();
     return {
-      kind: event.kind,
-      operation: event.operation,
-      stage: event.stage,
-      phase: event.phase,
-      ...event.requestId === undefined ? {} : { requestId: event.requestId },
-      ...event.durationMs === undefined ? {} : { durationMs: event.durationMs },
-      ...event.attempt === undefined ? {} : { attempt: event.attempt },
-      ...event.traceId === undefined ? {} : { traceId: event.traceId }
+      kind: event["kind"],
+      operation: event["operation"],
+      stage: event["stage"],
+      phase: event["phase"],
+      ...event["requestId"] === undefined ? {} : { requestId: event["requestId"] },
+      ...event["durationMs"] === undefined ? {} : { durationMs: event["durationMs"] },
+      ...event["attempt"] === undefined ? {} : { attempt: event["attempt"] },
+      ...event["traceId"] === undefined ? {} : { traceId: event["traceId"] }
     };
   });
   if (Buffer.byteLength(JSON.stringify({ version: 1, events }), "utf8") > EXECUTION_CONTEXT_LIMITS.inputBytes)
@@ -16662,10 +17016,10 @@ function correlateSnapshot(snapshot, subject, events, requestId) {
     correlation: "current-graph-only",
     deploymentVerified: false,
     eventsTrusted: false,
-    modules: modules.slice(0, EXECUTION_CONTEXT_LIMITS.modules).map((module) => ({
-      name: module.name,
-      ...executionSourceFile(module.file) ? { file: executionSourceFile(module.file) } : {}
-    })),
+    modules: modules.slice(0, EXECUTION_CONTEXT_LIMITS.modules).map((module) => {
+      const file = executionSourceFile(module.file);
+      return { name: module.name, ...file === undefined ? {} : { file } };
+    }),
     files: files.slice(0, EXECUTION_CONTEXT_LIMITS.files),
     executionPlans: [...matchedPlans].slice(0, EXECUTION_CONTEXT_LIMITS.plans),
     events: retained,
@@ -16754,16 +17108,16 @@ async function createDeliveryExecutionContextPack(manifestPath, target, subject,
   if (!observations || typeof observations !== "object" || Array.isArray(observations))
     throw invalid();
   const envelope = observations;
-  if (Object.keys(envelope).some((key) => !["version", "events", "delivery"].includes(key)) || !envelope.delivery || typeof envelope.delivery !== "object" || Array.isArray(envelope.delivery))
+  if (Object.keys(envelope).some((key) => !["version", "events", "delivery"].includes(key)) || !envelope["delivery"] || typeof envelope["delivery"] !== "object" || Array.isArray(envelope["delivery"]))
     throw invalid();
-  const identity = envelope.delivery;
-  if (Object.keys(identity).length !== 2 || typeof identity.target !== "string" || typeof identity.objectId !== "string" || !/^[a-f0-9]{64}$/.test(identity.objectId))
+  const identity = envelope["delivery"];
+  if (Object.keys(identity).length !== 2 || typeof identity["target"] !== "string" || typeof identity["objectId"] !== "string" || !/^[a-f0-9]{64}$/.test(identity["objectId"]))
     throw invalid();
   let object;
   let snapshot;
   try {
     const { root, object: found, planned } = await readDeliverySelection(manifestPath, target);
-    if (!found || identity.target !== target || identity.objectId !== found.objectId) {
+    if (!found || identity["target"] !== target || identity["objectId"] !== found.objectId) {
       throw new DeliveryContextError("DELIVERY_CONTEXT_IDENTITY_MISMATCH");
     }
     object = found;
@@ -16780,7 +17134,7 @@ async function createDeliveryExecutionContextPack(manifestPath, target, subject,
     throw new DeliveryContextError("DELIVERY_CONTEXT_INTEGRITY_FAILED");
   }
   const pack = {
-    ...executionContextFromSnapshot(snapshot, subject, { version: envelope.version, events: envelope.events }, requestId),
+    ...executionContextFromSnapshot(snapshot, subject, { version: envelope["version"], events: envelope["events"] }, requestId),
     correlation: "verified-build-snapshot",
     delivery: { target, objectId: object.objectId, artifactVerified: true }
   };
@@ -16988,7 +17342,7 @@ var init_graphql_schema = __esm(() => {
 import { createHash as createHash12 } from "node:crypto";
 import { mkdir as mkdir6, readFile as readFile14 } from "node:fs/promises";
 import { dirname as dirname12, relative as relative12, resolve as resolve23 } from "node:path";
-import * as ts17 from "@typescript/typescript6";
+import * as ts18 from "@typescript/typescript6";
 function hash3(value) {
   return createHash12("sha256").update(value).digest("hex");
 }
@@ -17028,20 +17382,20 @@ async function generateDatabaseContracts(options, check = false) {
   const rootDir = resolve23(options.rootDir), outDir = resolve23(options.outDir);
   const postgrestTypes = resolve23(rootDir, options.postgrestTypes), drizzleSchema = resolve23(rootDir, options.drizzleSchema);
   const snapshot = await readFile14(postgrestTypes, "utf8");
-  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));
+  const syntax = ts18.createSourceFile(postgrestTypes, snapshot, ts18.ScriptTarget.Latest, true);
+  const database = syntax.statements.find((node) => (ts18.isTypeAliasDeclaration(node) || ts18.isInterfaceDeclaration(node)) && node.name.text === "Database" && node.modifiers?.some((modifier) => modifier.kind === ts18.SyntaxKind.ExportKeyword));
   if (!database)
     throw new Error("PostgREST snapshot must export Database from the official type generator");
-  const program = ts17.createProgram([postgrestTypes], {
+  const program = ts18.createProgram([postgrestTypes], {
     strict: true,
     noEmit: true,
     skipLibCheck: true,
     types: [],
-    target: ts17.ScriptTarget.ES2022,
-    module: ts17.ModuleKind.ESNext,
-    moduleResolution: ts17.ModuleResolutionKind.Bundler
+    target: ts18.ScriptTarget.ES2022,
+    module: ts18.ModuleKind.ESNext,
+    moduleResolution: ts18.ModuleResolutionKind.Bundler
   });
-  if (ts17.getPreEmitDiagnostics(program).length)
+  if (ts18.getPreEmitDiagnostics(program).length)
     throw new Error("PostgREST snapshot has TypeScript errors");
   const artifacts = await renderGraphql({
     rootDir,
@@ -17059,11 +17413,11 @@ async function generateDatabaseContracts(options, check = false) {
   };
   await addInput(postgrestTypes);
   await addInput(drizzleSchema);
-  const drizzleProgram = ts17.createProgram([drizzleSchema], {
+  const drizzleProgram = ts18.createProgram([drizzleSchema], {
     noEmit: true,
-    moduleResolution: ts17.ModuleResolutionKind.Bundler,
-    module: ts17.ModuleKind.ESNext,
-    target: ts17.ScriptTarget.ES2022,
+    moduleResolution: ts18.ModuleResolutionKind.Bundler,
+    module: ts18.ModuleKind.ESNext,
+    target: ts18.ScriptTarget.ES2022,
     types: [],
     skipLibCheck: true
   });
@@ -17437,7 +17791,6 @@ function readProjectConfig(rootDir) {
         skipLibCheck: true
       },
       errors: [],
-      projectReferences: undefined,
       configFingerprint: "defaults"
     };
   }
@@ -17459,7 +17812,7 @@ function readProjectConfig(rootDir) {
   return {
     options: parsed.options,
     errors: parsed.errors,
-    projectReferences: parsed.projectReferences,
+    ...parsed.projectReferences === undefined ? {} : { projectReferences: parsed.projectReferences },
     configFingerprint: JSON.stringify([...configReads])
   };
 }
@@ -20669,7 +21022,7 @@ 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 resolve3, sep as sep3 } from "node:path";
-import * as ts9 from "@typescript/typescript6";
+import * as ts10 from "@typescript/typescript6";
 
 // src/sql-safety.ts
 import * as ts8 from "@typescript/typescript6";
@@ -20712,6 +21065,198 @@ function scanDrizzleSql(sourceFile, checker, file, strict) {
   return diagnostics;
 }
 
+// src/source-semantics.ts
+import * as ts9 from "@typescript/typescript6";
+var SOURCE_SEMANTIC_DIAGNOSTIC_CODES = {
+  "source-unsafe-any": { errorCode: "SC6009", docsUrl: "https://supacloud.dev/errors/SC6009" },
+  "source-floating-promise": { errorCode: "SC6010", docsUrl: "https://supacloud.dev/errors/SC6010" },
+  "source-non-exhaustive-switch": { errorCode: "SC6011", docsUrl: "https://supacloud.dev/errors/SC6011" }
+};
+function scanSourceSemantics(source, checker, file, rootDir) {
+  const diagnostics = [];
+  const report = (code, node, message) => {
+    diagnostics.push({
+      severity: "error",
+      code,
+      ...SOURCE_SEMANTIC_DIAGNOSTIC_CODES[code],
+      file,
+      message,
+      line: source.getLineAndCharacterOfPosition(node.getStart(source)).line + 1
+    });
+  };
+  const unsafe = (value, target) => {
+    if (isUnknownBoundary(target, checker) || containsAny(target, checker, new Set, rootDir))
+      return;
+    if (containsAny(checker.getTypeAtLocation(value), checker, new Set, rootDir)) {
+      report("source-unsafe-any", value, "An any-containing value cannot enter a concrete type. Quarantine it as unknown and decode it before use.");
+    }
+  };
+  const declared = (node) => {
+    let hasAnyKeyword = false;
+    const visitType = (child) => {
+      if (child.kind === ts9.SyntaxKind.AnyKeyword)
+        hasAnyKeyword = true;
+      ts9.forEachChild(child, visitType);
+    };
+    visitType(node);
+    if (!hasAnyKeyword && containsAny(checker.getTypeAtLocation(node), checker, new Set, rootDir)) {
+      report("source-unsafe-any", node, "Declared application types must not hide any through aliases or generic arguments.");
+    }
+  };
+  const visit = (node) => {
+    if (ts9.isTypeAliasDeclaration(node))
+      declared(node.type);
+    if ((ts9.isVariableDeclaration(node) || ts9.isParameter(node) || ts9.isPropertyDeclaration(node) || ts9.isPropertySignature(node)) && node.type)
+      declared(node.type);
+    if (ts9.isVariableDeclaration(node) && node.initializer) {
+      const type = checker.getTypeAtLocation(node.name);
+      if (node.type)
+        unsafe(node.initializer, type);
+      else if (ts9.isIdentifier(node.name) && !ts9.isArrowFunction(node.initializer) && !ts9.isFunctionExpression(node.initializer) && !(type.flags & ts9.TypeFlags.Any) && containsAny(type, checker, new Set, rootDir)) {
+        report("source-unsafe-any", node.name, "Inferred values must not contain any, including nested and generic result types.");
+      }
+    }
+    if (ts9.isPropertyDeclaration(node) && !node.type && node.initializer && containsAny(checker.getTypeAtLocation(node.name), checker, new Set, rootDir)) {
+      report("source-unsafe-any", node.name, "Inferred class fields must not propagate any. Decode the value or quarantine it as unknown.");
+    }
+    if ((ts9.isFunctionDeclaration(node) || ts9.isMethodDeclaration(node) || ts9.isArrowFunction(node) || ts9.isFunctionExpression(node)) && !node.type && node.body) {
+      const signature = checker.getSignatureFromDeclaration(node);
+      if (signature && containsAny(checker.getReturnTypeOfSignature(signature), checker, new Set, rootDir)) {
+        report("source-unsafe-any", node.name ?? node, "Inferred function results must not propagate any. Return unknown at the boundary or a decoded concrete result.");
+      }
+    }
+    if (ts9.isFunctionLike(node) && node.type)
+      declared(node.type);
+    if (ts9.isBinaryExpression(node) && node.operatorToken.kind === ts9.SyntaxKind.EqualsToken) {
+      unsafe(node.right, checker.getTypeAtLocation(node.left));
+    }
+    if (ts9.isAsExpression(node) || ts9.isTypeAssertionExpression(node)) {
+      unsafe(node.expression, checker.getTypeAtLocation(node));
+    }
+    if (ts9.isReturnStatement(node) && node.expression) {
+      let owner = node.parent;
+      while (owner && !ts9.isFunctionLike(owner))
+        owner = owner.parent;
+      if (owner && ts9.isFunctionLike(owner) && owner.type) {
+        const signature = checker.getSignatureFromDeclaration(owner);
+        if (signature)
+          unsafe(node.expression, checker.getReturnTypeOfSignature(signature));
+      }
+    }
+    if (ts9.isCallExpression(node)) {
+      const signature = checker.getResolvedSignature(node);
+      const parameters = signature?.getParameters() ?? [];
+      node.arguments.forEach((argument, index) => {
+        const parameter = parameters[index] ?? parameters.at(-1);
+        if (!parameter)
+          return;
+        const type = checker.getTypeOfSymbolAtLocation(parameter, node);
+        const declaration = parameter.valueDeclaration;
+        const rest = declaration && ts9.isParameter(declaration) && declaration.dotDotDotToken;
+        const target = rest ? checker.getIndexTypeOfType(type, ts9.IndexKind.Number) ?? type : type;
+        unsafe(argument, target);
+      });
+    }
+    if (ts9.isExpressionStatement(node)) {
+      const expression = unwrap(node.expression);
+      if (isPromise(checker.getTypeAtLocation(expression), checker, expression) && !handlesRejection(expression, checker)) {
+        report("source-floating-promise", node, "Promise work must be awaited, returned, or have a callable rejection handler. void does not establish cancellation ownership.");
+      }
+    }
+    if (ts9.isSwitchStatement(node)) {
+      const type = checker.getTypeAtLocation(node.expression);
+      const members = type.isUnion() ? type.types : [type];
+      if (members.every(isFiniteLiteral)) {
+        const cases = node.caseBlock.clauses.filter(ts9.isCaseClause);
+        const missing = members.filter((member) => !cases.some((clause) => sameLiteral(member, checker.getTypeAtLocation(clause.expression))));
+        if (missing.length > 0) {
+          report("source-non-exhaustive-switch", node.expression, `Switch is missing cases for ${missing.map((member) => checker.typeToString(member)).join(", ")}. A default branch does not replace explicit union cases.`);
+        }
+      }
+    }
+    ts9.forEachChild(node, visit);
+  };
+  visit(source);
+  return diagnostics;
+}
+function containsAny(type, checker, seen, rootDir) {
+  if (type.flags & ts9.TypeFlags.Any)
+    return true;
+  if (seen.has(type))
+    return false;
+  seen.add(type);
+  if (type.isUnionOrIntersection())
+    return type.types.some((part) => containsAny(part, checker, seen, rootDir));
+  const declarations = type.getSymbol()?.declarations ?? [];
+  if (declarations.some((declaration) => ts9.isClassDeclaration(declaration) && (declaration.getSourceFile().isDeclarationFile || declaration.getSourceFile().fileName.replaceAll("\\", "/").includes("/node_modules/"))))
+    return false;
+  const arguments_ = isTypeReference2(type) ? checker.getTypeArguments(type) : type.aliasTypeArguments ?? [];
+  if (arguments_.some((argument) => containsAny(argument, checker, seen, rootDir)))
+    return true;
+  if (checker.getSignaturesOfType(type, ts9.SignatureKind.Call).some((signature) => {
+    const declaration = signature.getDeclaration();
+    return declaration !== undefined && isWithinRoot(declaration.getSourceFile().fileName, rootDir) && (containsAny(checker.getReturnTypeOfSignature(signature), checker, seen, rootDir) || signature.getParameters().some((parameter) => containsAny(checker.getTypeOfSymbolAtLocation(parameter, declaration), checker, seen, rootDir)));
+  }))
+    return true;
+  return checker.getPropertiesOfType(type).some((property) => {
+    const declaration = property.valueDeclaration ?? property.declarations?.[0];
+    return declaration !== undefined && isWithinRoot(declaration.getSourceFile().fileName, rootDir) && containsAny(checker.getTypeOfSymbolAtLocation(property, declaration), checker, seen, rootDir);
+  });
+}
+function isWithinRoot(file, rootDir) {
+  const normalizedFile = file.replaceAll("\\", "/");
+  const normalizedRoot = rootDir.replaceAll("\\", "/").replace(/\/+$/, "");
+  return normalizedFile === normalizedRoot || normalizedFile.startsWith(`${normalizedRoot}/`);
+}
+function isUnknownBoundary(type, checker) {
+  if (type.flags & (ts9.TypeFlags.Unknown | ts9.TypeFlags.Void))
+    return true;
+  const promised = promiseArgument(type, checker);
+  return promised !== undefined && Boolean(promised.flags & ts9.TypeFlags.Unknown);
+}
+function unwrap(expression) {
+  while (ts9.isParenthesizedExpression(expression) || ts9.isVoidExpression(expression))
+    expression = expression.expression;
+  return expression;
+}
+function isPromise(type, checker, node) {
+  return type.isUnion() ? type.types.some((part) => isPromise(part, checker, node)) : promiseArgument(type, checker) !== undefined;
+}
+function handlesRejection(expression, checker) {
+  if (!ts9.isCallExpression(expression) || !ts9.isPropertyAccessExpression(expression.expression))
+    return false;
+  const { name, expression: receiver } = expression.expression;
+  if (!isPromise(checker.getTypeAtLocation(receiver), checker, receiver))
+    return false;
+  const handler = name.text === "catch" ? expression.arguments[0] : name.text === "then" ? expression.arguments[1] : undefined;
+  return handler !== undefined && checker.getTypeAtLocation(handler).getCallSignatures().length > 0;
+}
+function isFiniteLiteral(type) {
+  return Boolean(type.flags & (ts9.TypeFlags.StringLiteral | ts9.TypeFlags.NumberLiteral | ts9.TypeFlags.BigIntLiteral | ts9.TypeFlags.BooleanLiteral | ts9.TypeFlags.Null | ts9.TypeFlags.Undefined));
+}
+function sameLiteral(left, right) {
+  if (left.flags !== right.flags)
+    return false;
+  if (left.isStringLiteral() && right.isStringLiteral())
+    return left.value === right.value;
+  if (left.isNumberLiteral() && right.isNumberLiteral())
+    return left.value === right.value;
+  return left === right;
+}
+function isTypeReference2(type) {
+  return Boolean(type.flags & ts9.TypeFlags.Object) && "objectFlags" in type && typeof type.objectFlags === "number" && Boolean(type.objectFlags & ts9.ObjectFlags.Reference) && "target" in type;
+}
+function promiseArgument(type, checker) {
+  if (type.flags & (ts9.TypeFlags.Any | ts9.TypeFlags.Unknown | ts9.TypeFlags.Never))
+    return;
+  const then = checker.getPropertyOfType(type, "then");
+  const declaration = then?.valueDeclaration ?? then?.declarations?.[0];
+  if (!then || !declaration || checker.getTypeOfSymbolAtLocation(then, declaration).getCallSignatures().length === 0)
+    return;
+  const awaited = checker.getAwaitedType(type);
+  return awaited !== type ? awaited : undefined;
+}
+
 // src/type-safety.ts
 var DEFAULT_EXCLUDES = [
   "**/*.test.ts",
@@ -20726,6 +21271,7 @@ var DEFAULT_EXCLUDES = [
 ];
 var TYPE_SAFETY_DIAGNOSTIC_CODES = {
   ...SQL_SAFETY_DIAGNOSTIC_CODES,
+  ...SOURCE_SEMANTIC_DIAGNOSTIC_CODES,
   "generated-any": { errorCode: "SC6001", docsUrl: "https://supacloud.dev/errors/SC6001" },
   "source-any": { errorCode: "SC6002", docsUrl: "https://supacloud.dev/errors/SC6002" },
   "source-type-assertion": { errorCode: "SC6003", docsUrl: "https://supacloud.dev/errors/SC6003" },
@@ -20738,7 +21284,7 @@ function scanGeneratedArtifacts(artifacts, strict = true) {
   for (const [file, content] of Object.entries(artifacts)) {
     if (content === undefined)
       continue;
-    const sourceFile = ts9.createSourceFile(file, content, ts9.ScriptTarget.Latest, true, ts9.ScriptKind.TS);
+    const sourceFile = ts10.createSourceFile(file, content, ts10.ScriptTarget.Latest, true, ts10.ScriptKind.TS);
     for (const node of descendantsOfKind2(sourceFile, isAnyKeyword)) {
       diagnostics.push(makeDiagnostic("generated-any", `生成产物 ${file} 包含 any；严格生成模式要求使用 unknown、具体接口或泛型约束。`, sourceFile, node, strict));
     }
@@ -20747,36 +21293,58 @@ function scanGeneratedArtifacts(artifacts, strict = true) {
 }
 function scanProductionSource(options) {
   const rootDir = resolve3(options.rootDir);
-  const configPath = ts9.findConfigFile(rootDir, ts9.sys.fileExists) ?? join3(rootDir, "tsconfig.json");
+  const configPath = ts10.findConfigFile(rootDir, ts10.sys.fileExists) ?? join3(rootDir, "tsconfig.json");
   const projectConfig = existsSync2(configPath) ? readProjectConfig2(configPath) : {
     options: {
       strict: true,
+      experimentalDecorators: true,
       skipLibCheck: true,
-      target: ts9.ScriptTarget.ES2022,
-      module: ts9.ModuleKind.ESNext,
-      moduleResolution: ts9.ModuleResolutionKind.Bundler
+      target: ts10.ScriptTarget.ES2022,
+      module: ts10.ModuleKind.ESNext,
+      moduleResolution: ts10.ModuleResolutionKind.Bundler
     },
     errors: []
   };
   const include = options.include ?? ["**/*.ts", "**/*.tsx", "**/*.mts", "**/*.cts"];
-  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 = ts9.createCompilerHost(compilerOptions);
+  const rootNames = ts10.sys.readDirectory(rootDir, [".ts", ".tsx", ".mts", ".cts"], ["node_modules", "dist"], include).filter((file) => isProductionSourcePath(rootDir, file, [...DEFAULT_EXCLUDES, ...options.exclude ?? []]));
+  const compilerOptions = {
+    ...projectConfig.options,
+    noCheck: false,
+    strict: true,
+    noImplicitAny: true,
+    strictNullChecks: true,
+    strictFunctionTypes: true,
+    strictBindCallApply: true,
+    strictPropertyInitialization: true,
+    strictBuiltinIteratorReturn: true,
+    noImplicitThis: true,
+    useUnknownInCatchVariables: true,
+    alwaysStrict: true,
+    noUncheckedIndexedAccess: true,
+    exactOptionalPropertyTypes: true,
+    noImplicitOverride: true,
+    noPropertyAccessFromIndexSignature: true,
+    noFallthroughCasesInSwitch: true,
+    forceConsistentCasingInFileNames: true,
+    noEmit: true
+  };
+  const host = ts10.createCompilerHost(compilerOptions);
   host.getCurrentDirectory = () => dirname3(configPath);
-  const program = ts9.createProgram(rootNames, compilerOptions, host);
+  const program = ts10.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: ts9.flattenDiagnosticMessageText(diagnostic.messageText, `
+    message: ts10.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 } : {},
     errorCode: `TS${diagnostic.code}`
   }));
   const checker = program.getTypeChecker();
+  const moduleResolutionCodes = new Set([2307, 2688, 2792]);
   for (const diagnostic of [
     ...program.getGlobalDiagnostics(),
     ...sourceFiles.flatMap((sourceFile) => [
@@ -20786,8 +21354,8 @@ function scanProductionSource(options) {
   ]) {
     diagnostics.push({
       severity: "error",
-      code: "source-typescript",
-      message: ts9.flattenDiagnosticMessageText(diagnostic.messageText, `
+      code: moduleResolutionCodes.has(diagnostic.code) ? "source-config" : "source-typescript",
+      message: ts10.flattenDiagnosticMessageText(diagnostic.messageText, `
 `),
       ...diagnostic.file ? { file: normalizeRelative(rootDir, diagnostic.file.fileName) } : {},
       ...diagnostic.file && diagnostic.start !== undefined ? { line: diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start).line + 1 } : {},
@@ -20796,10 +21364,11 @@ function scanProductionSource(options) {
   }
   for (const sourceFile of sourceFiles) {
     scanSourceFile(sourceFile, checker, rootDir, diagnostics, options.strict ?? false);
+    diagnostics.push(...scanSourceSemantics(sourceFile, checker, normalizeRelative(rootDir, sourceFile.fileName), rootDir));
     diagnostics.push(...scanDrizzleSql(sourceFile, checker, normalizeRelative(rootDir, sourceFile.fileName), options.strict ?? false));
-    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())) {
+    const scanner = ts10.createScanner(ts10.ScriptTarget.Latest, false, sourceFile.languageVariant, sourceFile.text);
+    for (let kind = scanner.scan();kind !== ts10.SyntaxKind.EndOfFileToken; kind = scanner.scan()) {
+      if ((kind === ts10.SyntaxKind.SingleLineCommentTrivia || kind === ts10.SyntaxKind.MultiLineCommentTrivia) && /@ts-(?:ignore|nocheck|expect-error)\b/.test(scanner.getTokenText())) {
         diagnostics.push({
           severity: "error",
           code: "source-type-suppression",
@@ -20819,22 +21388,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 (ts9.isAsExpression(node)) {
-      if (ts9.isAsExpression(node.parent) || ts9.isTypeAssertionExpression(node.parent))
+    if (ts10.isAsExpression(node)) {
+      if (ts10.isAsExpression(node.parent) || ts10.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 (ts9.isTypeAssertionExpression(node)) {
-      if (ts9.isAsExpression(node.parent) || ts9.isTypeAssertionExpression(node.parent))
+    } else if (ts10.isTypeAssertionExpression(node)) {
+      if (ts10.isAsExpression(node.parent) || ts10.isTypeAssertionExpression(node.parent))
         continue;
       diagnostics.push(makeDiagnostic("source-type-assertion", `生产源码包含类型断言 ${node.getText(sourceFile)}；请优先使用类型守卫、satisfies 或显式边界解析。`, sourceFile, node, strict, rootDir));
-    } else if (ts9.isNonNullExpression(node)) {
+    } else if (ts10.isNonNullExpression(node)) {
       diagnostics.push(makeDiagnostic("source-non-null-assertion", `生产源码包含非空断言 ${node.getText(sourceFile)}；请显式处理 null/undefined。`, sourceFile, node, strict, rootDir));
     }
   }
-  for (const declaration of descendantsOfKind2(sourceFile, ts9.isVariableDeclaration)) {
+  for (const declaration of descendantsOfKind2(sourceFile, ts10.isVariableDeclaration)) {
     const initializer = declaration.initializer;
     if (!initializer || declaration.type)
       continue;
@@ -20850,11 +21419,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 (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))) {
+    if (ts10.isObjectLiteralExpression(initializer) && isConstDeclaration(declaration) && initializer.getText(sourceFile).length > 0 && initializer.properties.some((property) => ts10.isPropertyAssignment(property) && property.initializer !== undefined && !ts10.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, ts9.isParameter)) {
+  for (const parameter of descendantsOfKind2(sourceFile, ts10.isParameter)) {
     if (parameter.type)
       continue;
     for (const name of bindingNames(parameter.name)) {
@@ -20865,10 +21434,10 @@ function scanSourceFile(sourceFile, checker, rootDir, diagnostics, strict) {
   }
 }
 function readProjectConfig2(configPath) {
-  const config = ts9.readConfigFile(configPath, (file) => readFileSync2(file, "utf8"));
+  const config = ts10.readConfigFile(configPath, (file) => readFileSync2(file, "utf8"));
   if (config.error)
     return { options: {}, errors: [config.error] };
-  const parsed = ts9.parseJsonConfigFileContent(config.config, ts9.sys, dirname3(configPath));
+  const parsed = ts10.parseJsonConfigFileContent(config.config, ts10.sys, dirname3(configPath));
   return { options: parsed.options, errors: parsed.errors };
 }
 function isProductionSource(rootDir, sourceFile, excludes, outDir) {
@@ -20888,42 +21457,42 @@ function globMatches(value, pattern) {
   return new RegExp(`^${escaped}$`).test(value);
 }
 function bindingNames(name) {
-  if (ts9.isIdentifier(name))
+  if (ts10.isIdentifier(name))
     return [name];
-  return name.elements.flatMap((element) => ts9.isBindingElement(element) ? bindingNames(element.name) : []);
+  return name.elements.flatMap((element) => ts10.isBindingElement(element) ? bindingNames(element.name) : []);
 }
 function isLiteralExpression(node) {
   if (!node)
     return false;
   return [
-    ts9.SyntaxKind.StringLiteral,
-    ts9.SyntaxKind.NumericLiteral,
-    ts9.SyntaxKind.TrueKeyword,
-    ts9.SyntaxKind.FalseKeyword
+    ts10.SyntaxKind.StringLiteral,
+    ts10.SyntaxKind.NumericLiteral,
+    ts10.SyntaxKind.TrueKeyword,
+    ts10.SyntaxKind.FalseKeyword
   ].includes(node.kind);
 }
 function isLiteralSyntax(node) {
-  return ts9.isStringLiteral(node) || ts9.isNumericLiteral(node) || node.kind === ts9.SyntaxKind.TrueKeyword || node.kind === ts9.SyntaxKind.FalseKeyword;
+  return ts10.isStringLiteral(node) || ts10.isNumericLiteral(node) || node.kind === ts10.SyntaxKind.TrueKeyword || node.kind === ts10.SyntaxKind.FalseKeyword;
 }
 function isLiteralType(type) {
-  return (type.flags & (ts9.TypeFlags.StringLiteral | ts9.TypeFlags.NumberLiteral | ts9.TypeFlags.BooleanLiteral | ts9.TypeFlags.BigIntLiteral)) !== 0;
+  return (type.flags & (ts10.TypeFlags.StringLiteral | ts10.TypeFlags.NumberLiteral | ts10.TypeFlags.BooleanLiteral | ts10.TypeFlags.BigIntLiteral)) !== 0;
 }
 function isAnyType(type) {
-  return (type.flags & ts9.TypeFlags.Any) !== 0;
+  return (type.flags & ts10.TypeFlags.Any) !== 0;
 }
 function isLetDeclaration(declaration) {
-  return ts9.isVariableDeclarationList(declaration.parent) && (declaration.parent.flags & ts9.NodeFlags.Let) !== 0;
+  return ts10.isVariableDeclarationList(declaration.parent) && (declaration.parent.flags & ts10.NodeFlags.Let) !== 0;
 }
 function isConstDeclaration(declaration) {
-  return ts9.isVariableDeclarationList(declaration.parent) && (declaration.parent.flags & ts9.NodeFlags.Const) !== 0;
+  return ts10.isVariableDeclarationList(declaration.parent) && (declaration.parent.flags & ts10.NodeFlags.Const) !== 0;
 }
 function descendants(root) {
   const result = [];
   const visit = (node) => {
     result.push(node);
-    ts9.forEachChild(node, visit);
+    ts10.forEachChild(node, visit);
   };
-  ts9.forEachChild(root, visit);
+  ts10.forEachChild(root, visit);
   return result;
 }
 function descendantsOfKind2(root, predicate) {
@@ -20931,9 +21500,9 @@ function descendantsOfKind2(root, predicate) {
   const visit = (node) => {
     if (predicate(node))
       result.push(node);
-    ts9.forEachChild(node, visit);
+    ts10.forEachChild(node, visit);
   };
-  ts9.forEachChild(root, visit);
+  ts10.forEachChild(root, visit);
   return result;
 }
 function makeDiagnostic(code, message, fileOrSourceFile, node, strict, rootDir) {
@@ -20941,7 +21510,7 @@ function makeDiagnostic(code, message, fileOrSourceFile, node, strict, rootDir)
   const file = typeof fileOrSourceFile === "string" ? fileOrSourceFile : rootDir ? normalizeRelative(rootDir, fileOrSourceFile.fileName) : fileOrSourceFile.fileName;
   const meta = TYPE_SAFETY_DIAGNOSTIC_CODES[code];
   return {
-    severity: strict ? "error" : "warn",
+    severity: strict || code === "source-any" || code === "generated-any" ? "error" : "warn",
     code,
     message,
     file,
@@ -20954,7 +21523,7 @@ function normalizeRelative(rootDir, filePath) {
   return relative3(rootDir, filePath).split(sep3).join("/").replace(/^\.\//, "");
 }
 function isAnyKeyword(node) {
-  return node.kind === ts9.SyntaxKind.AnyKeyword;
+  return node.kind === ts10.SyntaxKind.AnyKeyword;
 }
 
 // src/compile.ts
@@ -21115,11 +21684,12 @@ async function compileProject(options) {
     }, options.strict ?? false));
   }
   const hasErrors = diagnostics.some((diagnostic) => diagnostic.severity === "error");
+  const hasTypeErrors = diagnostics.some(({ severity, code }) => severity === "error" && (code.startsWith("source-") || code === "generated-any"));
   const generatedOptions = {
     ...options,
     ...options.cache ? { artifactHashes: options.cache.generatedHashes } : {}
   };
-  const written = !hasErrors || options.writeOnError === true ? await writeRenderedApplication(rendered, generatedOptions) : [];
+  const written = !hasErrors || options.writeOnError === true && !hasTypeErrors ? await writeRenderedApplication(rendered, generatedOptions) : [];
   if (!hasErrors) {
     for (const [filename, content] of Object.entries(graphql.files)) {
       const path = join4(options.outDir, filename);
@@ -21216,8 +21786,8 @@ async function checkProject(options) {
 }
 function resolveTypeSafety(options) {
   return {
-    noAnyInGenerated: options.typeSafety?.noAnyInGenerated ?? options.strict ?? false,
-    scanProductionSource: options.typeSafety?.scanProductionSource ?? options.strict ?? false,
+    noAnyInGenerated: true,
+    scanProductionSource: true,
     ...options.typeSafety?.exclude ? { exclude: options.typeSafety.exclude } : {}
   };
 }
@@ -21472,7 +22042,7 @@ function formatDeliveryPlan(result) {
 import { mkdir as mkdir3, mkdtemp, readFile as readFile5, realpath as realpath3, rename as rename3, rm as rm2 } from "node:fs/promises";
 import { readFileSync as readFileSync3 } from "node:fs";
 import { dirname as dirname7, join as join9, relative as relative7, resolve as resolve12, sep as sep7 } from "node:path";
-import * as ts14 from "@typescript/typescript6";
+import * as ts15 from "@typescript/typescript6";
 
 // src/delivery-build-schema.ts
 init_delivery_build_schema();
@@ -21514,22 +22084,22 @@ init_delivery_files2();
 import { isBuiltin } from "node:module";
 import { readFile as readFile4 } from "node:fs/promises";
 import { join as join7, resolve as resolve9 } from "node:path";
-import * as ts13 from "@typescript/typescript6";
+import * as ts14 from "@typescript/typescript6";
 
 // src/delivery-imports.ts
-import * as ts12 from "@typescript/typescript6";
+import * as ts13 from "@typescript/typescript6";
 function staticDeliveryImports(path, contents) {
   if (!/\.[cm]?[jt]sx?$/.test(path))
     return contents;
-  const source = ts12.createSourceFile(path, new TextDecoder().decode(contents), ts12.ScriptTarget.Latest, true);
+  const source = ts13.createSourceFile(path, new TextDecoder().decode(contents), ts13.ScriptTarget.Latest, true);
   const computed = [];
   function scan(node) {
-    if (ts12.isCallExpression(node) && (node.expression.kind === ts12.SyntaxKind.ImportKeyword || ts12.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 || !ts12.isStringLiteral(argument) && !ts12.isNoSubstitutionTemplateLiteral(argument))
+      if (!argument || !ts13.isStringLiteral(argument) && !ts13.isNoSubstitutionTemplateLiteral(argument))
         computed.push(node);
     }
-    ts12.forEachChild(node, scan);
+    ts13.forEachChild(node, scan);
   }
   scan(source);
   if (computed.length === 0)
@@ -21537,36 +22107,36 @@ function staticDeliveryImports(path, contents) {
   const reject = () => {
     throw new Error("Computed module loading is not supported in independent delivery bundles.");
   };
-  if (!ts12.isExternalModule(source))
+  if (!ts13.isExternalModule(source))
     return reject();
-  const host = ts12.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 = ts12.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 = ts12.isIdentifier(node) ? ts12.isShorthandPropertyAssignment(node.parent) ? checker.getShorthandAssignmentValueSymbol(node.parent) : ts12.isExportSpecifier(node.parent) ? checker.getExportSpecifierLocalTargetSymbol(node.parent) : checker.getSymbolAtLocation(node) : undefined;
-      if (ts12.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 (!ts12.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 || !ts12.isStringLiteral(value) && !ts12.isNoSubstitutionTemplateLiteral(value))
+        if (!value || !ts13.isStringLiteral(value) && !ts13.isNoSubstitutionTemplateLiteral(value))
           return reject();
         references++;
-        replacements.set(use, ts12.factory.createCallExpression(call.expression, undefined, [value]));
+        replacements.set(use, ts13.factory.createCallExpression(call.expression, undefined, [value]));
       }
-      ts12.forEachChild(node, visit);
+      ts13.forEachChild(node, visit);
     };
     const statement = call.parent;
     const block = statement.parent;
     const declaration = block.parent;
-    if (call.expression.kind !== ts12.SyntaxKind.ImportKeyword || call.arguments.length !== 1 || !ts12.isReturnStatement(statement) || !ts12.isBlock(block) || block.statements.length !== 1 || !ts12.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 || !ts12.isIdentifier(parameter.name) || parameter.initializer || parameter.dotDotDotToken || !argument || !ts12.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)
@@ -21578,22 +22148,22 @@ function staticDeliveryImports(path, contents) {
       return reject();
     removed.add(declaration);
   }
-  const transformed = ts12.transform(source, [(context) => {
+  const transformed = ts13.transform(source, [(context) => {
     const visit = (node) => {
-      if (ts12.isFunctionDeclaration(node) && removed.has(node))
+      if (ts13.isFunctionDeclaration(node) && removed.has(node))
         return;
-      const replacement = ts12.isCallExpression(node) ? replacements.get(node) : undefined;
+      const replacement = ts13.isCallExpression(node) ? replacements.get(node) : undefined;
       if (replacement)
         return replacement;
-      return ts12.visitEachChild(node, visit, context);
+      return ts13.visitEachChild(node, visit, context);
     };
-    return (node) => ts12.visitNode(node, visit, ts12.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(ts12.createPrinter().printFile(transformedSource));
+    return new TextEncoder().encode(ts13.createPrinter().printFile(transformedSource));
   } finally {
     transformed.dispose();
   }
@@ -21741,16 +22311,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 = ts13.isImportDeclaration(node) || ts13.isExportDeclaration(node) ? node.moduleSpecifier : ts13.isCallExpression(node) && (node.expression.kind === ts13.SyntaxKind.ImportKeyword || ts13.isIdentifier(node.expression) && /^(?:__)?require$/.test(node.expression.text) || ts13.isPropertyAccessExpression(node.expression) && node.expression.name.text === "require" && ts13.isMetaProperty(node.expression.expression) && node.expression.expression.keywordToken === ts13.SyntaxKind.ImportKeyword) ? node.arguments[0] : undefined;
-        if (specifier && ts13.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);
         }
-        ts13.forEachChild(node, check);
+        ts14.forEachChild(node, check);
       };
-      const source = ts13.createSourceFile(path, new TextDecoder().decode(bytes), ts13.ScriptTarget.Latest, true);
+      const source = ts14.createSourceFile(path, new TextDecoder().decode(bytes), ts14.ScriptTarget.Latest, true);
       check(source);
     }
     files.set(`bundle/${path}`, bytes);
@@ -21769,16 +22339,16 @@ function renderDeliveryRuntimeIdentity() {
   return `
 function deliveryRuntimeIdentity(kind: "http" | "worker") {
   const env = deliveryProcess.env;
-  if (env.SUPACLOUD_ACTIVATION_ID === undefined) return null;
+  if (env["SUPACLOUD_ACTIVATION_ID"] === undefined) return null;
   const identity = {
     schema: "supacloud.application-runtime.v1",
-    project_ref: env.SUPACLOUD_PROJECT_REF,
-    application_id: env.SUPACLOUD_APPLICATION_ID,
-    environment_id: env.SUPACLOUD_ENVIRONMENT_ID,
-    release_id: env.SUPACLOUD_RELEASE_ID,
-    activation_id: env.SUPACLOUD_ACTIVATION_ID,
-    target: env.SUPACLOUD_TARGET,
-    object_id: env.SUPACLOUD_OBJECT_ID,
+    project_ref: env["SUPACLOUD_PROJECT_REF"],
+    application_id: env["SUPACLOUD_APPLICATION_ID"],
+    environment_id: env["SUPACLOUD_ENVIRONMENT_ID"],
+    release_id: env["SUPACLOUD_RELEASE_ID"],
+    activation_id: env["SUPACLOUD_ACTIVATION_ID"],
+    target: env["SUPACLOUD_TARGET"],
+    object_id: env["SUPACLOUD_OBJECT_ID"],
     kind, pid: deliveryProcess.pid,
   };
   const matches = (value: string | undefined, pattern: RegExp) => typeof value === "string" && pattern.test(value);
@@ -21811,8 +22381,8 @@ interface DeliveryHttpHost {
 
 async function startDeliveryHttp(signal: AbortSignal, shutdownTimeout: number, startDeadline: () => void) {
   const identity = deliveryRuntimeIdentity("http");
-  const port = Number(deliveryProcess.env.PORT ?? "3000");
-  const hostname = deliveryProcess.env.HOST ?? "127.0.0.1";
+  const port = Number(deliveryProcess.env["PORT"] ?? "3000");
+  const hostname = deliveryProcess.env["HOST"] ?? "127.0.0.1";
   if (!Number.isInteger(port) || port < 0 || port > 65535 || hostname.length === 0) {
     throw new Error("Invalid delivery HTTP listener configuration.");
   }
@@ -21880,7 +22450,7 @@ async function startDeliveryHttp(signal: AbortSignal, shutdownTimeout: number, s
 
 {
   const lifecycle = new AbortController();
-  const shutdownTimeout = Number(deliveryProcess.env.SHUTDOWN_TIMEOUT_MS ?? "10000");
+  const shutdownTimeout = Number(deliveryProcess.env["SHUTDOWN_TIMEOUT_MS"] ?? "10000");
   let running: Awaited<ReturnType<typeof startDeliveryHttp>>;
   let deadline: ReturnType<typeof setTimeout> | undefined;
   const finish = (failed: boolean) => {
@@ -21948,7 +22518,7 @@ interface DeliveryWorkerHost {
 
 {
   const lifecycle = new AbortController();
-  const shutdownTimeout = Number(deliveryProcess.env.SHUTDOWN_TIMEOUT_MS ?? "10000");
+  const shutdownTimeout = Number(deliveryProcess.env["SHUTDOWN_TIMEOUT_MS"] ?? "10000");
   let host: DeliveryWorkerHost | undefined;
   let running = false;
   let runtimeFailed = false;
@@ -22016,7 +22586,7 @@ interface DeliveryWorkerHost {
     const candidate = await createHost(createCompiledModules(), { signal: lifecycle.signal });
     if (!candidate || typeof candidate.close !== "function") throw new Error("Invalid delivery worker host.");
     host = candidate;
-    const execution = deliveryProcess.env.SUPACLOUD_WORKER_EXECUTION;
+    const execution = deliveryProcess.env["SUPACLOUD_WORKER_EXECUTION"];
     if (execution) {
       const expected: unknown = JSON.parse(Buffer.from(execution, "base64").toString("utf8"));
       if (!deliveryPolicyEqual(host.execution, expected) || typeof host.health !== "function" || !host.failure) {
@@ -22120,7 +22690,7 @@ async function buildDeliveryProject(options, delivery) {
     const settings = parseDeliveryOptions(delivery);
     if (typeof Bun === "undefined")
       throw new Error("Independent delivery builds require Bun.");
-    const configPath = ts14.findConfigFile(resolve12(options.rootDir), ts14.sys.fileExists);
+    const configPath = ts15.findConfigFile(resolve12(options.rootDir), ts15.sys.fileExists);
     if (!configPath)
       throw new Error("Independent delivery builds require a project tsconfig.json.");
     const lexicalProject = dirname7(configPath);
@@ -22136,8 +22706,8 @@ async function buildDeliveryProject(options, delivery) {
     if (inside(generatedRoot, sourceRoot))
       throw new Error("Output must not contain the application source root.");
     const configInputs = new Map;
-    const parsedConfig = ts14.getParsedCommandLineOfConfigFile(await realpath3(configPath), {}, {
-      ...ts14.sys,
+    const parsedConfig = ts15.getParsedCommandLineOfConfigFile(await realpath3(configPath), {}, {
+      ...ts15.sys,
       readFile(path) {
         const contents = readFileSync3(path, "utf8");
         configInputs.set(resolve12(path), digest(contents));
@@ -22257,7 +22827,7 @@ async function buildDeliveryProject(options, delivery) {
       for (const [name, contents] of Object.entries(generated))
         await writeArtifact(stage, `generated/${name}`, contents);
       {
-        const program = ts14.createProgram({
+        const program = ts15.createProgram({
           rootNames: [
             ...parsedConfig.fileNames.filter((path) => !inside(generatedRoot, path)),
             ...Object.keys(generated).map((name) => join9(stage, "generated", name))
@@ -22265,12 +22835,12 @@ async function buildDeliveryProject(options, delivery) {
           options: { ...parsedConfig.options, rootDir: project },
           ...parsedConfig.projectReferences ? { projectReferences: parsedConfig.projectReferences } : {}
         });
-        const diagnostics = ts14.getPreEmitDiagnostics(program);
-        if (diagnostics.some((item) => item.category === ts14.DiagnosticCategory.Error)) {
-          return failed(diagnostics.filter((item) => item.category === ts14.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: ts14.flattenDiagnosticMessageText(item.messageText, `
+            message: ts15.flattenDiagnosticMessageText(item.messageText, `
 `),
             ...item.file ? { file: item.file.fileName } : {}
           })));
@@ -22665,19 +23235,7 @@ function createIncrementalCompiler() {
       const snapshot = !options.graphql && changedPaths && previousSnapshot && previousSnapshot.optionsKey === optionsKey ? await updateSnapshot(previousSnapshot, options, changedPaths) : await createSnapshot(options);
       const changedFiles = changedPaths && previousSnapshot ? diffFiles(previousSnapshot.files, snapshot.files) : diffFiles(previousSnapshot?.files, snapshot.files);
       const activeCache = options.cache ?? cache;
-      const cacheHit = Boolean(previousSnapshot && previousSnapshot.optionsKey === snapshot.optionsKey && previousCache === activeCache && changedFiles.length === 0) && !(options.typeSafety?.scanProductionSource ?? options.strict ?? false);
-      if (cacheHit && previousResult) {
-        return {
-          ...previousResult,
-          stats: {
-            cacheHit: true,
-            changedFiles: [],
-            affectedModules: [],
-            reusedModules: previousResult.graph.modules.map((m) => m.name),
-            reanalyzedModules: []
-          }
-        };
-      }
+      const cacheHit = Boolean(previousSnapshot && previousSnapshot.optionsKey === snapshot.optionsKey && previousCache === activeCache && changedFiles.length === 0);
       if (!activeCache.dependencyGraph && previousResult) {
         activeCache.dependencyGraph = new ModuleDependencyGraph(previousResult.graph.modules);
       }
@@ -22693,7 +23251,7 @@ function createIncrementalCompiler() {
         activeCache.dependencyGraph = new ModuleDependencyGraph(result.graph.modules);
       }
       const stats = {
-        cacheHit: false,
+        cacheHit: cacheHit && !result.diagnostics.some(({ severity }) => severity === "error"),
         changedFiles,
         affectedModules,
         reusedModules,
@@ -23091,7 +23649,7 @@ function watchProject(options) {
 // 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 resolve17 } from "node:path";
-import * as ts16 from "@typescript/typescript6";
+import * as ts17 from "@typescript/typescript6";
 
 // src/migration-policy.ts
 import { readFile as readFile8 } from "node:fs/promises";
@@ -23099,10 +23657,10 @@ import { readFileSync as readFileSync4 } from "node:fs";
 import { resolve as resolve16 } from "node:path";
 
 // src/migration-app-version.ts
-var MIGRATION_APP_VERSION = "0.24.1";
+var MIGRATION_APP_VERSION = "0.25.0";
 
 // src/migration-elysia-version.ts
-var MIGRATION_ELYSIA_VERSION = "0.29.0";
+var MIGRATION_ELYSIA_VERSION = "0.29.1";
 
 // src/migration-policy.ts
 var cachedCompilerVersion;
@@ -23143,29 +23701,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: ts16.ScriptTarget.ES2022,
-  module: ts16.ModuleKind.ESNext,
-  moduleResolution: ts16.ModuleResolutionKind.Bundler,
+  target: ts17.ScriptTarget.ES2022,
+  module: ts17.ModuleKind.ESNext,
+  moduleResolution: ts17.ModuleResolutionKind.Bundler,
   noEmit: true,
   skipLibCheck: true
 };
 function migrationCompilerOptions(rootDir) {
   if (!rootDir)
     return MIGRATION_COMPILER_OPTIONS;
-  const configPath = ts16.findConfigFile(rootDir, ts16.sys.fileExists);
+  const configPath = ts17.findConfigFile(rootDir, ts17.sys.fileExists);
   if (!configPath)
     return MIGRATION_COMPILER_OPTIONS;
   const configHost = {
-    ...ts16.sys,
+    ...ts17.sys,
     onUnRecoverableConfigFileDiagnostic: (_diagnostic) => {}
   };
-  const parsed = ts16.getParsedCommandLineOfConfigFile(configPath, {}, configHost);
+  const parsed = ts17.getParsedCommandLineOfConfigFile(configPath, {}, configHost);
   if (!parsed || parsed.errors.length > 0)
     return MIGRATION_COMPILER_OPTIONS;
   return { ...parsed.options, noEmit: true, skipLibCheck: true };
 }
 function propertyName2(property) {
-  if (ts16.isIdentifier(property) || ts16.isStringLiteral(property) || ts16.isNumericLiteral(property))
+  if (ts17.isIdentifier(property) || ts17.isStringLiteral(property) || ts17.isNumericLiteral(property))
     return property.text;
   return;
 }
@@ -23175,7 +23733,7 @@ function lineOf2(sourceFile, node) {
 function resolveSymbol(symbol, checker) {
   if (!symbol)
     return;
-  for (let guard = 0;guard < 4 && (symbol.flags & ts16.SymbolFlags.Alias) !== 0; guard += 1) {
+  for (let guard = 0;guard < 4 && (symbol.flags & ts17.SymbolFlags.Alias) !== 0; guard += 1) {
     const aliased = checker.getAliasedSymbol(symbol);
     if (aliased === symbol)
       break;
@@ -23184,12 +23742,12 @@ function resolveSymbol(symbol, checker) {
   return symbol;
 }
 function symbolForExpression(expression, checker) {
-  const location = ts16.isIdentifier(expression) ? expression : ts16.isPropertyAccessExpression(expression) ? expression.name : ts16.isElementAccessExpression(expression) && expression.argumentExpression && ts16.isStringLiteral(expression.argumentExpression) ? expression : undefined;
+  const location = ts17.isIdentifier(expression) ? expression : ts17.isPropertyAccessExpression(expression) ? expression.name : ts17.isElementAccessExpression(expression) && expression.argumentExpression && ts17.isStringLiteral(expression.argumentExpression) ? expression : undefined;
   return location ? resolveSymbol(checker.getSymbolAtLocation(location), checker) : undefined;
 }
 function unwrapExpression(expression) {
   let current = expression;
-  while (ts16.isAsExpression(current) || ts16.isSatisfiesExpression(current) || ts16.isParenthesizedExpression(current) || ts16.isTypeAssertionExpression(current)) {
+  while (ts17.isAsExpression(current) || ts17.isSatisfiesExpression(current) || ts17.isParenthesizedExpression(current) || ts17.isTypeAssertionExpression(current)) {
     current = current.expression;
   }
   return current;
@@ -23204,7 +23762,7 @@ function isRouteDecoratorCall(node, checker) {
   if (node.arguments.length < 2)
     return false;
   const name = node.expression.getText(node.getSourceFile());
-  if (ts16.isIdentifier(node.expression) && ROUTE_DECORATORS2.has(node.expression.text))
+  if (ts17.isIdentifier(node.expression) && ROUTE_DECORATORS2.has(node.expression.text))
     return true;
   if (ROUTE_DECORATORS2.has(name))
     return true;
@@ -23218,14 +23776,14 @@ function resolveStaticObjectLiteral2(input, checker, seen = new Set) {
   if (seen.has(expression))
     return;
   seen.add(expression);
-  if (ts16.isObjectLiteralExpression(expression))
+  if (ts17.isObjectLiteralExpression(expression))
     return expression;
-  if (ts16.isCallExpression(expression) && isDefineRouteContractCall(expression, checker)) {
+  if (ts17.isCallExpression(expression) && isDefineRouteContractCall(expression, checker)) {
     return resolveStaticObjectLiteral2(expression.arguments[0], checker, seen);
   }
   const symbol = symbolForExpression(expression, checker);
   for (const declaration of symbol?.declarations ?? []) {
-    if (ts16.isVariableDeclaration(declaration) && declaration.initializer) {
+    if (ts17.isVariableDeclaration(declaration) && declaration.initializer) {
       const resolved = resolveStaticObjectLiteral2(declaration.initializer, checker, seen);
       if (resolved)
         return resolved;
@@ -23239,7 +23797,7 @@ function displayFile(rootDir, fileName) {
 }
 function createMigrationProgram(fileNames, sourceOverrides, rootDir) {
   const compilerOptions = migrationCompilerOptions(rootDir);
-  const host = ts16.createCompilerHost(compilerOptions);
+  const host = ts17.createCompilerHost(compilerOptions);
   const getSourceFile = host.getSourceFile.bind(host);
   const fileExists = host.fileExists.bind(host);
   const readFile = host.readFile.bind(host);
@@ -23248,16 +23806,16 @@ function createMigrationProgram(fileNames, sourceOverrides, rootDir) {
   host.readFile = (fileName) => sourceOverrides.get(resolve17(fileName)) ?? readFile(fileName);
   host.getSourceFile = (fileName, languageVersion, onError, shouldCreateNewSourceFile) => {
     const source = sourceOverrides.get(resolve17(fileName));
-    return source === undefined ? getSourceFile(fileName, languageVersion, onError, shouldCreateNewSourceFile) : ts16.createSourceFile(fileName, source, languageVersion, true);
+    return source === undefined ? getSourceFile(fileName, languageVersion, onError, shouldCreateNewSourceFile) : ts17.createSourceFile(fileName, source, languageVersion, true);
   };
   host.getCurrentDirectory = () => rootDir ?? currentDirectory();
-  return ts16.createProgram(fileNames, compilerOptions, host);
+  return ts17.createProgram(fileNames, compilerOptions, host);
 }
 function routeResponseProperties(object) {
-  const responseProperties = object.properties.filter((property) => ts16.isPropertyAssignment(property) && propertyName2(property.name) === "response");
+  const responseProperties = object.properties.filter((property) => ts17.isPropertyAssignment(property) && propertyName2(property.name) === "response");
   return {
     response: responseProperties[0],
-    hasResponses: object.properties.some((property) => (ts16.isPropertyAssignment(property) || ts16.isShorthandPropertyAssignment(property)) && propertyName2(property.name) === "responses"),
+    hasResponses: object.properties.some((property) => (ts17.isPropertyAssignment(property) || ts17.isShorthandPropertyAssignment(property)) && propertyName2(property.name) === "responses"),
     duplicateResponse: responseProperties.length > 1
   };
 }
@@ -23277,7 +23835,7 @@ function planRouteResponseMigration(sourceFiles, checker, rootDir, includedFiles
     if (!includedFiles.has(sourcePath))
       continue;
     const visit = (node) => {
-      if (ts16.isCallExpression(node) && isRouteDecoratorCall(node, checker)) {
+      if (ts17.isCallExpression(node) && isRouteDecoratorCall(node, checker)) {
         const options = node.arguments[1];
         const object = options && resolveStaticObjectLiteral2(options, checker);
         if (object) {
@@ -23297,7 +23855,7 @@ function planRouteResponseMigration(sourceFiles, checker, rootDir, includedFiles
           }
         }
       }
-      ts16.forEachChild(node, visit);
+      ts17.forEachChild(node, visit);
     };
     visit(sourceFile);
   }
@@ -23464,7 +24022,7 @@ async function migrateProject(options) {
     }
   }
   const include = options.include ?? ["**/*.ts", "**/*.tsx", "**/*.mts", "**/*.cts"];
-  const files = ts16.sys.readDirectory(rootDir, [".ts", ".tsx", ".mts", ".cts"], ["node_modules", "dist", "generated"], include).sort();
+  const files = ts17.sys.readDirectory(rootDir, [".ts", ".tsx", ".mts", ".cts"], ["node_modules", "dist", "generated"], include).sort();
   const results = [];
   const issues = [];
   const pendingWrites = new Map;
@@ -23607,30 +24165,30 @@ function resolveSchema(value, document, seen = new Set) {
   const schema = recordValue(value);
   if (!schema)
     return;
-  const ref = stringValue(schema.$ref);
+  const ref = stringValue(schema["$ref"]);
   if (!ref || !ref.startsWith("#/components/schemas/"))
     return schema;
   if (seen.has(ref))
     return schema;
   const name = decodeJsonPointerPart(ref.slice("#/components/schemas/".length));
-  const components = recordValue(document.components);
-  const schemas = recordValue(components?.schemas);
+  const components = recordValue(document["components"]);
+  const schemas = recordValue(components?.["schemas"]);
   const target = schemas?.[name];
   if (target === undefined)
     return schema;
   return resolveSchema(target, document, new Set([...seen, ref]));
 }
 function schemaEnum(value) {
-  return Array.isArray(value?.enum) ? value.enum : undefined;
+  return Array.isArray(value?.["enum"]) ? value["enum"] : undefined;
 }
 function schemaProperties(value) {
-  return recordValue(value?.properties);
+  return recordValue(value?.["properties"]);
 }
 function schemaRequired(value) {
-  return new Set(arrayValue(value?.required).filter((item) => typeof item === "string"));
+  return new Set(arrayValue(value?.["required"]).filter((item) => typeof item === "string"));
 }
 function schemaType(value) {
-  return value?.type;
+  return value?.["type"];
 }
 function addChange(changes, change) {
   if (changes.some((item) => item.kind === change.kind && item.code === change.code && item.path === change.path && item.message === change.message))
@@ -23674,7 +24232,7 @@ function compareSchema(baseValue, currentValue, baseDocument, currentDocument, p
   if (baseProperties && currentProperties) {
     for (const name of sortedKeys2(baseProperties)) {
       if (currentProperties[name] === undefined) {
-        const inputRemovalIsBreaking = baseSchema.additionalProperties === false;
+        const inputRemovalIsBreaking = baseSchema["additionalProperties"] === false;
         if (direction === "output" || inputRemovalIsBreaking) {
           addChange(changes, {
             kind: "breaking",
@@ -23701,7 +24259,7 @@ function compareSchema(baseValue, currentValue, baseDocument, currentDocument, p
         });
       }
     }
-    if (baseSchema.additionalProperties !== false && currentSchema.additionalProperties === false) {
+    if (baseSchema["additionalProperties"] !== false && currentSchema["additionalProperties"] === false) {
       addChange(changes, {
         kind: "breaking",
         code: "request-additional-properties-rejected",
@@ -23724,13 +24282,13 @@ function compareSchema(baseValue, currentValue, baseDocument, currentDocument, p
 }
 function parameterKey(value) {
   const parameter = recordValue(value);
-  const name = stringValue(parameter?.name);
-  const location = stringValue(parameter?.in);
+  const name = stringValue(parameter?.["name"]);
+  const location = stringValue(parameter?.["in"]);
   return name && location ? `${location}:${name}` : undefined;
 }
 function operationParameters(pathItem, operation) {
   const result = new Map;
-  for (const source of [pathItem.parameters, operation.parameters]) {
+  for (const source of [pathItem["parameters"], operation["parameters"]]) {
     for (const item of arrayValue(source)) {
       const parameter = recordValue(item);
       const key = parameterKey(parameter);
@@ -23741,7 +24299,7 @@ function operationParameters(pathItem, operation) {
   return result;
 }
 function parameterSchema(value) {
-  return value.schema;
+  return value["schema"];
 }
 function compareParameters(basePathItem, currentPathItem, baseOperation, currentOperation, baseDocument, currentDocument, path, changes) {
   const baseParameters = operationParameters(basePathItem, baseOperation);
@@ -23758,7 +24316,7 @@ function compareParameters(basePathItem, currentPathItem, baseOperation, current
       });
       continue;
     }
-    if (currentParameter.required === true && baseParameter.required !== true) {
+    if (currentParameter["required"] === true && baseParameter["required"] !== true) {
       addChange(changes, {
         kind: "breaking",
         code: "parameter-required",
@@ -23777,16 +24335,16 @@ function compareParameters(basePathItem, currentPathItem, baseOperation, current
     if (!parameter)
       continue;
     addChange(changes, {
-      kind: parameter.required === true ? "breaking" : "non-breaking",
-      code: parameter.required === true ? "parameter-required" : "parameter-added",
+      kind: parameter["required"] === true ? "breaking" : "non-breaking",
+      code: parameter["required"] === true ? "parameter-required" : "parameter-added",
       path: `${path}.parameters.${key}`,
-      message: parameter.required === true ? "A new required parameter was added." : "An optional parameter was added."
+      message: parameter["required"] === true ? "A new required parameter was added." : "An optional parameter was added."
     });
   }
 }
 function compareRequestBody(baseOperation, currentOperation, baseDocument, currentDocument, path, changes) {
-  const baseBody = recordValue(baseOperation.requestBody);
-  const currentBody = recordValue(currentOperation.requestBody);
+  const baseBody = recordValue(baseOperation["requestBody"]);
+  const currentBody = recordValue(currentOperation["requestBody"]);
   if (!baseBody || !currentBody) {
     if (baseBody && !currentBody) {
       addChange(changes, {
@@ -23795,7 +24353,7 @@ function compareRequestBody(baseOperation, currentOperation, baseDocument, curre
         path: `${path}.requestBody`,
         message: "A request body from the previous contract was removed."
       });
-    } else if (!baseBody && currentBody?.required === true) {
+    } else if (!baseBody && currentBody?.["required"] === true) {
       addChange(changes, {
         kind: "breaking",
         code: "request-body-required",
@@ -23812,7 +24370,7 @@ function compareRequestBody(baseOperation, currentOperation, baseDocument, curre
     }
     return;
   }
-  if (currentBody.required === true && baseBody.required !== true) {
+  if (currentBody["required"] === true && baseBody["required"] !== true) {
     addChange(changes, {
       kind: "breaking",
       code: "request-body-required",
@@ -23820,8 +24378,8 @@ function compareRequestBody(baseOperation, currentOperation, baseDocument, curre
       message: "An optional request body became required."
     });
   }
-  const baseContent = recordValue(baseBody.content);
-  const currentContent = recordValue(currentBody.content);
+  const baseContent = recordValue(baseBody["content"]);
+  const currentContent = recordValue(currentBody["content"]);
   for (const mediaType of sortedKeys2(baseContent)) {
     const baseMedia = recordValue(baseContent?.[mediaType]);
     const currentMedia = recordValue(currentContent?.[mediaType]);
@@ -23834,14 +24392,14 @@ function compareRequestBody(baseOperation, currentOperation, baseDocument, curre
       });
       continue;
     }
-    if (baseMedia.schema !== undefined && currentMedia.schema !== undefined) {
-      compareSchema(baseMedia.schema, currentMedia.schema, baseDocument, currentDocument, `${path}.requestBody.content.${mediaType}.schema`, "input", changes);
+    if (baseMedia["schema"] !== undefined && currentMedia["schema"] !== undefined) {
+      compareSchema(baseMedia["schema"], currentMedia["schema"], baseDocument, currentDocument, `${path}.requestBody.content.${mediaType}.schema`, "input", changes);
     }
   }
 }
 function compareResponses(baseOperation, currentOperation, baseDocument, currentDocument, path, changes) {
-  const baseResponses = recordValue(baseOperation.responses);
-  const currentResponses = recordValue(currentOperation.responses);
+  const baseResponses = recordValue(baseOperation["responses"]);
+  const currentResponses = recordValue(currentOperation["responses"]);
   for (const status of sortedKeys2(baseResponses)) {
     const baseResponse = recordValue(baseResponses?.[status]);
     const currentResponse = recordValue(currentResponses?.[status]);
@@ -23854,8 +24412,8 @@ function compareResponses(baseOperation, currentOperation, baseDocument, current
       });
       continue;
     }
-    const baseContent = recordValue(baseResponse.content);
-    const currentContent = recordValue(currentResponse.content);
+    const baseContent = recordValue(baseResponse["content"]);
+    const currentContent = recordValue(currentResponse["content"]);
     for (const mediaType of sortedKeys2(baseContent)) {
       const baseMedia = recordValue(baseContent?.[mediaType]);
       const currentMedia = recordValue(currentContent?.[mediaType]);
@@ -23868,8 +24426,8 @@ function compareResponses(baseOperation, currentOperation, baseDocument, current
         });
         continue;
       }
-      if (baseMedia.schema !== undefined && currentMedia.schema !== undefined) {
-        compareSchema(baseMedia.schema, currentMedia.schema, baseDocument, currentDocument, `${path}.responses.${status}.content.${mediaType}.schema`, "output", changes);
+      if (baseMedia["schema"] !== undefined && currentMedia["schema"] !== undefined) {
+        compareSchema(baseMedia["schema"], currentMedia["schema"], baseDocument, currentDocument, `${path}.responses.${status}.content.${mediaType}.schema`, "output", changes);
       }
     }
   }
@@ -23888,8 +24446,8 @@ function compareOperation(basePathItem, currentPathItem, baseOperation, currentO
   compareParameters(basePathItem, currentPathItem, baseOperation, currentOperation, baseDocument, currentDocument, path, changes);
   compareRequestBody(baseOperation, currentOperation, baseDocument, currentDocument, path, changes);
   compareResponses(baseOperation, currentOperation, baseDocument, currentDocument, path, changes);
-  const baseSecurity = baseOperation.security;
-  const currentSecurity = currentOperation.security;
+  const baseSecurity = baseOperation["security"];
+  const currentSecurity = currentOperation["security"];
   if (Array.isArray(currentSecurity) && currentSecurity.length > 0 && (!Array.isArray(baseSecurity) || baseSecurity.length === 0)) {
     addChange(changes, {
       kind: "breaking",
@@ -23900,8 +24458,8 @@ function compareOperation(basePathItem, currentPathItem, baseOperation, currentO
   }
 }
 function compareComponents(baseDocument, currentDocument, changes) {
-  const baseComponents = recordValue(baseDocument.components);
-  const currentComponents = recordValue(currentDocument.components);
+  const baseComponents = recordValue(baseDocument["components"]);
+  const currentComponents = recordValue(currentDocument["components"]);
   for (const group of COMPONENT_GROUPS) {
     const baseGroup = recordValue(baseComponents?.[group]);
     const currentGroup = recordValue(currentComponents?.[group]);
@@ -23928,10 +24486,10 @@ function compareComponents(baseDocument, currentDocument, changes) {
   }
 }
 function parseOpenApiDocument(value) {
-  if (!isRecord(value) || typeof value.openapi !== "string" || !/^3\.[0-9]+(?:\.[0-9]+)?$/.test(value.openapi) || !isRecord(value.info) || !isRecord(value.paths)) {
+  if (!isRecord(value) || typeof value["openapi"] !== "string" || !/^3\.[0-9]+(?:\.[0-9]+)?$/.test(value["openapi"]) || !isRecord(value["info"]) || !isRecord(value["paths"])) {
     throw new OpenApiDocumentError;
   }
-  return { ...value, openapi: value.openapi, info: value.info, paths: value.paths };
+  return { ...value, openapi: value["openapi"], info: value["info"], paths: value["paths"] };
 }
 function serializeOpenApiJson(document, space = 2) {
   const parsed = parseOpenApiDocument(document);
@@ -23980,7 +24538,7 @@ async function loadGeneratedOpenApiDocument(modulePath) {
     const loaded = await import(moduleUrl.href);
     if (!isRecord(loaded))
       throw new OpenApiDocumentError;
-    return parseOpenApiDocument(loaded.OPENAPI_DOCUMENT);
+    return parseOpenApiDocument(loaded["OPENAPI_DOCUMENT"]);
   } catch (error) {
     if (error instanceof OpenApiDocumentError)
       throw error;
@@ -24071,7 +24629,7 @@ function isRecord2(value) {
 function arrayLength(value) {
   return Array.isArray(value) ? value.length : undefined;
 }
-async function sha2562(path) {
+async function sha2563(path) {
   return createHash11("sha256").update(await readFile11(path)).digest("hex");
 }
 function overallStatus(findings) {
@@ -24140,16 +24698,19 @@ async function assessMigration(options) {
   };
   try {
     const parsed = JSON.parse(await readFile11(contractsManifestPath, "utf8"));
-    if (!isRecord2(parsed) || parsed.version !== 1)
+    if (!isRecord2(parsed) || parsed["version"] !== 1)
       throw new Error("invalid manifest");
+    const commands = arrayLength(parsed["commands"]);
+    const routes = arrayLength(parsed["routes"]);
+    const permissions = arrayLength(parsed["permissions"]);
     contractsManifest = {
       path: contractsManifestPath,
       present: true,
-      sha256: await sha2562(contractsManifestPath),
+      sha256: await sha2563(contractsManifestPath),
       version: 1,
-      ...arrayLength(parsed.commands) === undefined ? {} : { commands: arrayLength(parsed.commands) },
-      ...arrayLength(parsed.routes) === undefined ? {} : { routes: arrayLength(parsed.routes) },
-      ...arrayLength(parsed.permissions) === undefined ? {} : { permissions: arrayLength(parsed.permissions) }
+      ...commands === undefined ? {} : { commands },
+      ...routes === undefined ? {} : { routes },
+      ...permissions === undefined ? {} : { permissions }
     };
   } catch {
     findings.push({
@@ -24168,9 +24729,9 @@ async function assessMigration(options) {
       const diff = diffOpenApiDocuments(await readOpenApiJson(baselinePath), await readOpenApiJson(currentPath));
       openApi = {
         baselinePath,
-        baselineSha256: await sha2562(baselinePath),
+        baselineSha256: await sha2563(baselinePath),
         currentPath,
-        currentSha256: await sha2562(currentPath),
+        currentSha256: await sha2563(currentPath),
         diff
       };
       if (!diff.ok) {
@@ -24402,10 +24963,10 @@ function resolveSupacloudConfig(config = {}, cwd = process.cwd()) {
     ...resolved.detectOrphanModules === undefined ? {} : { detectOrphanModules: resolved.detectOrphanModules },
     effect: resolved.effect === undefined ? { ...DEFAULT_SUPACLOUD_CONFIG.effect } : { ...DEFAULT_SUPACLOUD_CONFIG.effect, ...resolved.effect },
     treeShakeUnusedProviders: resolved.treeShakeUnusedProviders ?? DEFAULT_SUPACLOUD_CONFIG.treeShakeUnusedProviders,
-    graphql: resolved.graphql ? {
+    ...resolved.graphql === undefined || resolved.graphql === false ? {} : { graphql: {
       ...resolved.graphql,
       schema: resolve20(cwd, resolved.graphql.schema)
-    } : undefined
+    } }
   };
 }
 async function loadSupacloudConfig(cwd = process.cwd()) {
@@ -24567,15 +25128,20 @@ function checkGraphqlCompatibility(schema, documents, policy = {}) {
     try {
       parsed = parse6(document.source);
     } catch (error) {
-      diagnostics.push({ severity: "error", code: "graphql-document-invalid", message: error instanceof Error ? error.message : String(error), file: document.path });
+      diagnostics.push({
+        severity: "error",
+        code: "graphql-document-invalid",
+        message: error instanceof Error ? error.message : String(error),
+        ...document.path === undefined ? {} : { file: document.path }
+      });
       continue;
     }
     diagnostics.push(...validate2(schema, parsed).map((error) => ({
       severity: "error",
       code: "graphql-validation",
       message: error.message,
-      file: document.path,
-      line: error.locations?.[0]?.line
+      ...document.path === undefined ? {} : { file: document.path },
+      ...error.locations?.[0]?.line === undefined ? {} : { line: error.locations[0].line }
     })));
     const fragmentDefinitions = new Map(parsed.definitions.filter((definition) => definition.kind === Kind2.FRAGMENT_DEFINITION).map((definition) => [definition.name.value, definition]));
     for (const definition of parsed.definitions) {
@@ -24583,7 +25149,10 @@ function checkGraphqlCompatibility(schema, documents, policy = {}) {
         continue;
       const result = operationReport(schema, definition, fragmentDefinitions, policy);
       operations.push(result.report);
-      diagnostics.push(...result.diagnostics.map((item) => ({ ...item, file: document.path })));
+      diagnostics.push(...result.diagnostics.map((item) => ({
+        ...item,
+        ...document.path === undefined ? {} : { file: document.path }
+      })));
     }
   }
   return { ok: diagnostics.every((item) => item.severity !== "error"), features: graphqlFeatureMatrix(schema), operations, diagnostics };