@loozo/angular-router 0.0.3 → 0.0.4

package/node/src/generation/filesystem.js

@@ -7,29 +7,104 @@ import { specifier } from "./emit.js";
 export function transparent(root, directory) {
     return directory !== root && basename(directory).startsWith("-");
 }
-function localPath(root, directory) {
-    if (directory === root || basename(directory).startsWith("+")) {
+// Directive comments bind to a following line or the module start, so edits must not move them.
+const directive = /@ts-(?:expect-error|ignore|check|nocheck)\b|@jsx(?:frag|importsource|runtime)?\b|\/\/\/\s*<(?:reference|amd-dependency|amd-module)\b|(?:eslint|oxlint)-disable-next-line\b/i;
+function contribution(root, directory) {
+    if (directory === root || transparent(root, directory) || basename(directory).startsWith("+")) {
         return "";
     }
     return basename(directory);
 }
-function unusedBinding(source, preferred) {
-    const identifiers = new Set();
+// Names that bindings, declarations and references use; property names are not bindings.
+function identifiers(source) {
+    const names = new Set();
     function visit(node) {
-        if (ts.isIdentifier(node)) {
-            identifiers.add(node.text);
+        const propertyName = (ts.isPropertyAssignment(node.parent) || ts.isPropertyAccessExpression(node.parent)) &&
+            node.parent.name === node;
+        if (ts.isIdentifier(node) && !propertyName) {
+            names.add(node.text);
         }
         ts.forEachChild(node, visit);
     }
-    visit(source);
+    ts.forEachChild(source, visit);
+    return names;
+}
+function unusedBinding(source, preferred) {
+    const used = identifiers(source);
     let name = preferred;
     let index = 0;
-    while (identifiers.has(name)) {
+    while (used.has(name)) {
         index += 1;
         name = `${preferred}${index}`;
     }
     return name;
 }
+function parentBinding(source) {
+    if (identifiers(source).has("parent")) {
+        return unusedBinding(source, "filesystemParent");
+    }
+    return "parent";
+}
+// Reuse a stringParam import from the router, else import it as `stringParam` when that
+// identifier is free.
+function stringParamBinding(source, imports) {
+    for (const statement of source.statements) {
+        if (!ts.isImportDeclaration(statement) ||
+            statement.importClause?.isTypeOnly ||
+            !ts.isStringLiteral(statement.moduleSpecifier) ||
+            statement.moduleSpecifier.text !== "@loozo/angular-router") {
+            continue;
+        }
+        const bindings = statement.importClause?.namedBindings;
+        if (!bindings || !ts.isNamedImports(bindings)) {
+            continue;
+        }
+        for (const binding of bindings.elements) {
+            if (!binding.isTypeOnly && (binding.propertyName ?? binding.name).text === "stringParam") {
+                return binding.name.text;
+            }
+        }
+    }
+    if (identifiers(source).has("stringParam")) {
+        const name = unusedBinding(source, "filesystemStringParam");
+        imports.push(`import { stringParam as ${name} } from "@loozo/angular-router";`);
+        return name;
+    }
+    imports.push('import { stringParam } from "@loozo/angular-router";');
+    return "stringParam";
+}
+// After the last import, keeping ordinary same-line comments with the import they annotate. A
+// directive or multiline comment there can bind to the next line, so insert before it instead.
+function importPosition(source) {
+    let last;
+    for (const statement of source.statements) {
+        if (ts.isImportDeclaration(statement)) {
+            last = statement;
+        }
+    }
+    // Every admitted declaration imports defineRoute.
+    let position = last.end;
+    for (const range of ts.getTrailingCommentRanges(source.text, last.end) ?? []) {
+        const comment = source.text.slice(range.pos, range.end);
+        if (directive.test(comment) || /[\r\n]/.test(comment)) {
+            return last.end;
+        }
+        position = range.end;
+    }
+    return position;
+}
+// Point the parent property at a binding, as shorthand when it is named `parent` and nothing
+// but whitespace separates the key from its value.
+function parentValue(property, value, name, source) {
+    if (ts.isShorthandPropertyAssignment(property)) {
+        return { start: value.getStart(source), end: value.end, text: `parent: ${name}` };
+    }
+    const separator = source.text.slice(property.name.end, value.getStart(source));
+    if (name === "parent" && /^\s*:\s*$/.test(separator)) {
+        return { start: property.getStart(source), end: property.end, text: name };
+    }
+    return { start: value.getStart(source), end: value.end, text: name };
+}
 function removeSyntax(node, source) {
     const start = node.getStart(source);
     const scanner = ts.createScanner(ts.ScriptTarget.Latest, false, ts.LanguageVariant.Standard, source.text);
@@ -46,8 +121,7 @@ function removeSyntax(node, source) {
         }
         // Include adjacent retained trivia: it too can become module-leading after
         // deletion. Stop at the next actual token, without copying trailing bytes.
-        if (comment &&
-            /@ts-(?:expect-error|ignore|check|nocheck)\b|@jsx(?:frag|importsource|runtime)?\b|\/\/\/\s*<(?:reference|amd-dependency|amd-module)\b|(?:eslint|oxlint)-disable-next-line\b/i.test(scanner.getTokenText())) {
+        if (comment && directive.test(scanner.getTokenText())) {
             fail(node, "Cannot remove directive-bound filesystem parent syntax; repair it explicitly");
         }
         if (scanner.getTokenPos() >= start && scanner.getTokenPos() < node.end && trivia) {
@@ -123,6 +197,47 @@ function otherUses(source, imported, parent, checker) {
     visit(source);
     return used;
 }
+// The builder owns the path, so the fix is in the params or the directories, never the path.
+// `opaque` says why the builder can't read the params' keys.
+function ambiguousParams(node, path, removed, added, opaque) {
+    const changes = [];
+    if (removed.length > 0) {
+        changes.push(`removed params: ${removed.join(", ")}`);
+    }
+    if (added.length > 0) {
+        changes.push(`added params: ${added.join(", ")}`);
+    }
+    let repair = "Edit this file's params to match";
+    if (!parsePath(path).some((segment) => segment.kind !== "static")) {
+        repair = "Remove this file's params";
+    }
+    else if (opaque) {
+        repair = `This file's params ${opaque}; write each one as a plain \`name: codec\` property to match`;
+    }
+    fail(node, `Ambiguous filesystem params: the directories give path "${path}" (${changes.join("; ")}). ` +
+        `${repair}, or move or rename the directory`);
+}
+// The keys of a direct inline params object, or why the builder can't read them.
+function paramKeys(params) {
+    if (!ts.isObjectLiteralExpression(params)) {
+        return "are not an inline object";
+    }
+    const keys = new Set();
+    for (const property of params.properties) {
+        if (!ts.isPropertyAssignment(property) && !ts.isShorthandPropertyAssignment(property)) {
+            return "use a spread or accessor";
+        }
+        const name = property.name;
+        if (!ts.isIdentifier(name) && !ts.isStringLiteral(name)) {
+            return "use a computed or numeric key";
+        }
+        if (keys.has(name.text)) {
+            return `repeat the key ${name.text}`;
+        }
+        keys.add(name.text);
+    }
+    return keys;
+}
 function patchDeclaration(declaration, path, parentFile, options, host, checker) {
     const source = declaration.source;
     const assignment = source.statements.find(ts.isExportAssignment);
@@ -149,34 +264,85 @@ function patchDeclaration(declaration, path, parentFile, options, host, checker)
                 desiredNames.add(segment.name);
             }
         }
-        const sameNames = names.size === desiredNames.size && [...names].every((name) => desiredNames.has(name));
-        if (!sameNames) {
+        const removed = [];
+        const added = [];
+        for (const name of names) {
+            if (!desiredNames.has(name)) {
+                removed.push(name);
+            }
+        }
+        for (const name of desiredNames) {
+            if (!names.has(name)) {
+                added.push(name);
+            }
+        }
+        if (removed.length > 0 || added.length > 0) {
             const params = declaration.config.get("params");
-            if (names.size === 1 && desiredNames.size === 1 && params) {
-                const entries = properties(params, "Filesystem local params");
-                const oldName = [...names][0];
-                const newName = [...desiredNames][0];
-                if (entries.size !== 1 || !entries.has(oldName)) {
-                    fail(params, "Ambiguous filesystem codec change; update local params explicitly");
-                }
-                const inline = params;
-                const property = inline.properties[0];
-                if (!ts.isPropertyAssignment(property)) {
-                    fail(property, "Filesystem param rename requires a direct property with its codec expression");
+            let keys = new Set();
+            if (params) {
+                const readable = paramKeys(params);
+                if (typeof readable === "string") {
+                    ambiguousParams(params, path, removed, added, readable);
                 }
-                patches.push({
-                    start: property.name.getStart(source),
-                    end: property.name.end,
-                    text: JSON.stringify(newName),
-                });
+                keys = readable;
             }
-            else if (names.size === 0 && desiredNames.size === 1 && !params) {
-                const name = unusedBinding(source, "filesystemStringParam");
-                imports.push(`import { stringParam as ${name} } from "@loozo/angular-router";${newline}`);
-                additions.push(`params: { ${JSON.stringify([...desiredNames][0])}: ${name} }`);
+            // Params the author already made match the directories need only the path rewritten. A
+            // path without params matches only a declaration without `params`, as at runtime.
+            let reconciled = keys.size === desiredNames.size;
+            if (desiredNames.size === 0 && params) {
+                reconciled = false;
             }
-            else {
-                fail(literal, "Ambiguous filesystem codec change; update path and local params explicitly before synchronization");
+            for (const name of desiredNames) {
+                if (!keys.has(name)) {
+                    reconciled = false;
+                }
+            }
+            if (!reconciled) {
+                if (removed.length === 1 && added.length === 1 && params) {
+                    const entries = properties(params, "Filesystem local params");
+                    const [oldName] = removed;
+                    const [newName] = added;
+                    if (entries.size !== names.size || !entries.has(oldName)) {
+                        ambiguousParams(params, path, removed, added);
+                    }
+                    const property = entries.get(oldName).parent;
+                    if (!ts.isPropertyAssignment(property)) {
+                        ambiguousParams(property, path, removed, added, "use a shorthand property");
+                    }
+                    patches.push({
+                        start: property.name.getStart(source),
+                        end: property.name.end,
+                        text: JSON.stringify(newName),
+                    });
+                }
+                else if (removed.length === 0 && params) {
+                    // Pure additions keep every authored codec and give each new param the seed's codec.
+                    for (const name of names) {
+                        if (!keys.has(name)) {
+                            ambiguousParams(params, path, removed, added);
+                        }
+                    }
+                    if (keys.size !== names.size) {
+                        ambiguousParams(params, path, removed, added);
+                    }
+                    const name = stringParamBinding(source, imports);
+                    const appended = [];
+                    for (const param of added) {
+                        appended.push(`${JSON.stringify(param)}: ${name}`);
+                    }
+                    patches.push(addProperty(params, appended.join(", ")));
+                }
+                else if (names.size === 0 && !params) {
+                    const name = stringParamBinding(source, imports);
+                    const entries = [];
+                    for (const param of added) {
+                        entries.push(`${JSON.stringify(param)}: ${name}`);
+                    }
+                    additions.push(`params: { ${entries.join(", ")} }`);
+                }
+                else {
+                    ambiguousParams(literal, path, removed, added);
+                }
             }
         }
         patches.push({ start: literal.getStart(source), end: literal.end, text: JSON.stringify(path) });
@@ -195,6 +361,13 @@ function patchDeclaration(declaration, path, parentFile, options, host, checker)
                     end: module.end,
                     text: JSON.stringify(specifier(declaration.file, parentFile)),
                 });
+                // A specifier that still resolves names a different parent, and so does its binding. An
+                // unresolvable one went stale because a file moved or was deleted; its name may still fit.
+                const binding = imported.importClause.name;
+                if (resolved && binding.text !== "parent" && !identifiers(source).has("parent")) {
+                    patches.push({ start: binding.getStart(source), end: binding.end, text: "parent" });
+                    patches.push(parentValue(parent.parent, parent, "parent", source));
+                }
             }
             else {
                 if (!resolved && (usedElsewhere || imported.importClause?.namedBindings)) {
@@ -210,35 +383,35 @@ function patchDeclaration(declaration, path, parentFile, options, host, checker)
                     patches.push(...removeProperty(property, source));
                 }
                 else {
-                    parentName = unusedBinding(source, "filesystemParent");
-                    let text = parentName;
-                    if (ts.isShorthandPropertyAssignment(property)) {
-                        text = `parent: ${parentName}`;
-                    }
-                    patches.push({ start: parent.getStart(source), end: parent.end, text });
+                    parentName = parentBinding(source);
+                    patches.push(parentValue(property, parent, parentName, source));
                 }
             }
         }
     }
     else if (parentFile) {
-        parentName = unusedBinding(source, "filesystemParent");
-        additions.push(`parent: ${parentName}`);
+        parentName = parentBinding(source);
+        if (parentName === "parent") {
+            additions.push("parent");
+        }
+        else {
+            additions.push(`parent: ${parentName}`);
+        }
     }
     if (parentFile && parentName) {
         // A new binding leaves a still-valid old import and its unrelated uses alone.
-        imports.push(`import ${parentName} from ${JSON.stringify(specifier(declaration.file, parentFile))};${newline}`);
+        imports.push(`import ${parentName} from ${JSON.stringify(specifier(declaration.file, parentFile))};`);
     }
     if (additions.length > 0) {
         patches.push(addProperty(object, additions.join(", ")));
     }
     if (imports.length > 0) {
-        // Static imports are hoisted. Appending at the complete module boundary
-        // preserves every existing statement/comment attachment without parsing it.
-        patches.push({
-            start: source.text.length,
-            end: source.text.length,
-            text: newline + imports.join(""),
-        });
+        const position = importPosition(source);
+        let text = "";
+        for (const statement of imports) {
+            text += newline + statement;
+        }
+        patches.push({ start: position, end: position, text });
     }
     patches.sort((a, b) => b.start - a.start);
     let bytes = source.text;
@@ -254,6 +427,8 @@ function patchDeclaration(declaration, path, parentFile, options, host, checker)
 }
 export async function synchronize(root, declarations, pages, options, { filename = "route.ts" }, checker) {
     const byDirectory = new Map();
+    // Only directories with a page or a declaration become records. Others contribute their
+    // path segment to the records below them.
     const participating = new Set();
     for (const declaration of declarations) {
         const directory = dirname(declaration.file);
@@ -277,15 +452,6 @@ export async function synchronize(root, declarations, pages, options, { filename
         }
         participating.add(directory);
     }
-    for (const directory of participating) {
-        let ancestor = directory;
-        while (ancestor !== root) {
-            ancestor = dirname(ancestor);
-            if (!transparent(root, ancestor)) {
-                participating.add(ancestor);
-            }
-        }
-    }
     const files = new Map();
     for (const directory of [...participating].sort()) {
         let file = byDirectory.get(directory)?.file;
@@ -305,16 +471,30 @@ export async function synchronize(root, declarations, pages, options, { filename
     };
     const authored = new Map();
     for (const [directory, file] of files) {
+        const contributions = [contribution(root, directory)];
+        let ancestor = directory;
         let parentFile;
-        if (directory !== root) {
-            let parent = dirname(directory);
-            while (transparent(root, parent)) {
-                parent = dirname(parent);
+        while (ancestor !== root && !parentFile) {
+            ancestor = dirname(ancestor);
+            parentFile = files.get(ancestor);
+            if (!parentFile) {
+                contributions.unshift(contribution(root, ancestor));
             }
-            parentFile = files.get(parent);
         }
-        const path = localPath(root, directory);
-        const segments = parsePath(path);
+        const parts = [];
+        for (const part of contributions) {
+            if (part !== "") {
+                parts.push(part);
+            }
+        }
+        const path = parts.join("/");
+        let segments;
+        try {
+            segments = parsePath(path);
+        }
+        catch (error) {
+            throw new Error(`Invalid filesystem path "${path}" for ${file}: ${error.message}`);
+        }
         const declaration = byDirectory.get(directory);
         if (declaration) {
             const bytes = patchDeclaration(declaration, path, parentFile, options, host, checker);
@@ -330,14 +510,26 @@ export async function synchronize(root, declarations, pages, options, { filename
             imports.push(`import parent from ${JSON.stringify(specifier(file, parentFile))};`);
             config.push("parent");
         }
+        const params = new Set();
         for (const segment of segments) {
             if (segment.kind !== "static") {
-                imported.push("stringParam");
-                config.push(`params: { ${JSON.stringify(segment.name)}: stringParam }`);
+                params.add(segment.name);
+            }
+        }
+        if (params.size > 0) {
+            const entries = [];
+            for (const name of params) {
+                entries.push(`${JSON.stringify(name)}: stringParam`);
             }
+            imported.push("stringParam");
+            config.push(`params: { ${entries.join(", ")} }`);
+        }
+        let object = "{}";
+        if (config.length > 0) {
+            object = `{ ${config.join(", ")} }`;
         }
         imports.unshift(`import { ${imported.join(", ")} } from "@loozo/angular-router";`);
-        authored.set(file, `${imports.join("\n")}\n\nexport default defineRoute(${JSON.stringify(path)}, { ${config.join(", ")} });\n`);
+        authored.set(file, `${imports.join("\n")}\n\nexport default defineRoute(${JSON.stringify(path)}, ${object});\n`);
     }
     return authored;
 }

package/node/src/generation/generate.d.ts

@@ -6,7 +6,7 @@ export interface GenerationOptions {
     scanDirectories: string[];
     outDirectory: string;
     check?: boolean;
-    autoDefineRoutes?: AutoDefineRoutes;
+    autoDefineRoutes?: AutoDefineRoutes | false;
 }
 export interface GenerationState {
     discovery: CompilerState;

package/node/src/generation/generate.js

@@ -4,7 +4,12 @@ import { createValidationProgram, selections, validateRoutes } from "./validate.
 import { emit } from "./emit.js";
 import { auditPath, metadata, planOutputs, publish, walk } from "./files.js";
 export async function generate(workspace, options, stopped, state) {
-    const sources = await discover(workspace, options.tsconfig, options.scanDirectories, options.outDirectory, options.autoDefineRoutes, undefined, undefined, undefined, state?.discovery);
+    const { autoDefineRoutes = {} } = options;
+    let auto;
+    if (autoDefineRoutes !== false) {
+        auto = autoDefineRoutes;
+    }
+    const sources = await discover(workspace, options.tsconfig, options.scanDirectories, options.outDirectory, auto, undefined, undefined, undefined, state?.discovery);
     const selected = selections(sources);
     const desired = emit(sources, selected);
     const globalFiles = [

package/node/src/generation/sources.js

@@ -167,6 +167,7 @@ const keys = new Set([
     "canActivate",
     "canActivateChild",
     "canMatch",
+    "onInvalidParams",
     "canDeactivate",
     "providers",
     "title",
@@ -354,6 +355,9 @@ export async function discover(workspace, config, scans, out, auto, authored = n
         if (!auto && !ignored && needsParams !== config.has("params")) {
             fail(configNode, "Local params must be present exactly when the path declares placeholders");
         }
+        if (!auto && !ignored && !needsParams && config.has("onInvalidParams")) {
+            fail(configNode, "onInvalidParams requires local path placeholders");
+        }
         const data = config.get("data");
         if (data && ts.isObjectLiteralExpression(data)) {
             for (const property of data.properties) {
@@ -470,8 +474,9 @@ export async function discover(workspace, config, scans, out, auto, authored = n
             if (declaration.page ||
                 declaration.children.length ||
                 declaration.config.has("canActivate") ||
-                declaration.config.has("canMatch")) {
-                fail(redirect, "Redirect cannot have a component, children, canActivate or canMatch");
+                declaration.config.has("canMatch") ||
+                declaration.config.has("onInvalidParams")) {
+                fail(redirect, "Redirect cannot have a component, children, canActivate, canMatch or onInvalidParams");
             }
             declaration.retained = false;
         }

package/node/src/generation/validate.js

@@ -375,7 +375,7 @@ export async function validateRoutes(sources, generated, validation, canonical)
                 fail(redirect, `Incompatible logical redirect params: ${sourceKey} -> ${targetKey.name}`);
             }
         }
-        const sourceSearch = typeWitness(declaration, "__search");
+        // Every search key is optional when writing a URL, so only replacement values need checking.
         const targetSearch = typeWitness(declaration.target, "__search");
         const search = fields.get("search");
         const fragment = fields.get("fragment");
@@ -420,22 +420,6 @@ export async function validateRoutes(sources, generated, validation, canonical)
                 fail(value, "Redirect replacement fragment is not declared by its destination");
             }
         }
-        const required = targetSearch
-            .getProperties()
-            .filter((property) => !(property.flags & ts.SymbolFlags.Optional));
-        if (mode.text === "drop" && required.length > 0) {
-            fail(search, `Cannot drop required destination search: ${required.map((property) => property.name).join(", ")}`);
-        }
-        if (mode.text === "preserve") {
-            for (const key of required) {
-                const sourceKey = sourceSearch.getProperty(key.name);
-                if (!sourceKey ||
-                    sourceKey.flags & ts.SymbolFlags.Optional ||
-                    !checker.isTypeAssignableTo(checker.getTypeOfSymbolAtLocation(sourceKey, search), checker.getTypeOfSymbolAtLocation(key, search))) {
-                    fail(search, `Source cannot guarantee required destination search: ${key.name}`);
-                }
-            }
-        }
         if (mode.text === "replace") {
             const values = policy.get("values");
             if (!values) {
@@ -444,15 +428,22 @@ export async function validateRoutes(sources, generated, validation, canonical)
             const type = checker.getTypeAtLocation(values);
             for (const key of type.getProperties()) {
                 const targetKey = targetSearch.getProperty(key.name);
-                if (!targetKey ||
-                    !checker.isTypeAssignableTo(checker.getTypeOfSymbolAtLocation(key, values), checker.getTypeOfSymbolAtLocation(targetKey, values))) {
+                if (!targetKey) {
                     fail(values, `Unknown/incompatible redirect replacement key: ${key.name}`);
                 }
-            }
-            for (const key of required) {
-                const supplied = type.getProperty(key.name);
-                if (!supplied || supplied.flags & ts.SymbolFlags.Optional) {
-                    fail(values, `Missing required redirect replacement: ${key.name}`);
+                // Replacements use the write type, `Value | undefined`: undefined omits the key, even
+                // one that reads a fallback, so only the other constituents must be codec values.
+                const supplied = checker.getTypeOfSymbolAtLocation(key, values);
+                const target = checker.getTypeOfSymbolAtLocation(targetKey, values);
+                let constituents = [supplied];
+                if (supplied.isUnion()) {
+                    constituents = supplied.types;
+                }
+                for (const constituent of constituents) {
+                    if (!(constituent.flags & ts.TypeFlags.Undefined) &&
+                        !checker.isTypeAssignableTo(constituent, target)) {
+                        fail(values, `Unknown/incompatible redirect replacement key: ${key.name}`);
+                    }
                 }
             }
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loozo/angular-router",
-  "version": "0.0.3",
+  "version": "0.0.4",
   "description": "Typed route declarations, URLs, navigation and route handles for Angular's native router.",
   "bugs": "https://github.com/theo-matzavinos/loozo/issues",
   "license": "MIT",

package/schemas/application.json

@@ -1,6 +1,6 @@
 {
   "$schema": "http://json-schema.org/draft-07/schema",
-  "$comment": "Generated by scripts/application-schema.mjs from the @angular/build 22.2.2 application schema plus the router options. Do not edit. The @angular/build schema portions are distributed under this license:\n\nThe MIT License\n\nCopyright (c) 2010-2026 Google LLC. https://angular.dev/license\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in\nall copies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\nTHE SOFTWARE.",
+  "$comment": "Generated by scripts/builder-schemas.mjs from the @angular/build 22.2.2 application schema plus the router options. Do not edit. The @angular/build schema portions are distributed under this license:\n\nThe MIT License\n\nCopyright (c) 2010-2026 Google LLC. https://angular.dev/license\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in\nall copies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\nTHE SOFTWARE.",
   "title": "Application schema for Build Facade.",
   "description": "Application builder target options",
   "type": "object",
@@ -19,28 +19,37 @@
       }
     },
     "autoDefineRoutes": {
-      "$comment": "Conditional validation prevents Angular addUndefinedDefaults from creating an omitted opt-in object.",
-      "if": true,
-      "then": {
-        "type": "object",
-        "additionalProperties": false,
-        "properties": {
-          "filename": {
-            "type": "string",
-            "pattern": "^[A-Za-z0-9_$][A-Za-z0-9_$.-]*\\.ts$",
-            "not": {
-              "anyOf": [
-                {
-                  "pattern": "\\.d\\.ts$"
-                },
-                {
-                  "enum": ["route.generated.ts", "routes.generated.ts", "destinations.generated.ts"]
-                }
-              ]
+      "$comment": "Omitted enables filesystem route definitions with route.ts; false selects explicit authoring.",
+      "anyOf": [
+        {
+          "type": "boolean",
+          "const": false
+        },
+        {
+          "type": "object",
+          "additionalProperties": false,
+          "properties": {
+            "filename": {
+              "type": "string",
+              "pattern": "^[A-Za-z0-9_$][A-Za-z0-9_$.-]*\\.ts$",
+              "not": {
+                "anyOf": [
+                  {
+                    "pattern": "\\.d\\.ts$"
+                  },
+                  {
+                    "enum": [
+                      "route.generated.ts",
+                      "routes.generated.ts",
+                      "destinations.generated.ts"
+                    ]
+                  }
+                ]
+              }
             }
           }
         }
-      }
+      ]
     },
     "outDirectory": {
       "type": "string",