@t09tanaka/stoneage 0.1.0

package/dist/migration.js

@@ -0,0 +1,983 @@
+import { access, mkdir, readdir, readFile, writeFile } from "node:fs/promises";
+import { extname, join, relative, sep } from "node:path";
+export async function auditSvelteKitPublicSurface(options) {
+    const paramMatchers = await readParamMatchers(options.paramsDir);
+    const files = (await walkFiles(options.routesDir)).filter(isSvelteKitPublicSurfaceFile);
+    const pageGroups = new Map();
+    const endpoints = [];
+    const inventoryFiles = [];
+    for (const absoluteFile of files) {
+        const relativeFile = toPosix(relative(options.routesDir, absoluteFile));
+        const source = await readFile(absoluteFile, "utf8");
+        const route = routeInfoForRelativeFile(relativeFile);
+        if (!route) {
+            continue;
+        }
+        const inventorySource = routeFileInventorySource(route, relativeFile, source);
+        inventoryFiles.push(inventorySource);
+        if (inventorySource.kind === "layout" ||
+            inventorySource.kind === "layoutServer" ||
+            inventorySource.kind === "layoutUniversal") {
+            continue;
+        }
+        if (isEndpointFile(relativeFile)) {
+            endpoints.push({
+                routePath: route.routePath,
+                stoneagePattern: route.stoneagePattern,
+                file: relativeFile,
+                params: route.params,
+                kind: endpointKind(route.routePath, source),
+                methods: endpointMethods(source),
+                usesJson: /\bjson\s*\(/.test(source),
+                usesResponse: /\bnew\s+Response\s*\(/.test(source),
+                usesEntries: exportsName(source, "entries"),
+                exportsPrerender: exportsName(source, "prerender"),
+                usesRedirect: /\bredirect\s*\(/.test(source),
+                usesError404: /\berror\s*\(\s*404\b/.test(source),
+            });
+            continue;
+        }
+        const group = pageGroups.get(route.routePath) ??
+            {
+                routePath: route.routePath,
+                stoneagePattern: route.stoneagePattern,
+                params: route.params,
+                files: [],
+            };
+        group.files.push({ relativeFile, source });
+        pageGroups.set(route.routePath, group);
+    }
+    const pages = Array.from(pageGroups.values())
+        .map((group) => pageAuditFromGroup(group))
+        .sort(compareByRoutePath);
+    const sortedEndpoints = endpoints.sort(compareByRoutePath);
+    const warnings = createAuditWarnings(pages, sortedEndpoints, paramMatchers).sort(compareWarnings);
+    const endpointKinds = summarizeEndpointKinds(sortedEndpoints);
+    const migrationInventory = createMigrationInventory(inventoryFiles);
+    const migrationPlan = options.migrationPlan
+        ? createMigrationPlan(pages, sortedEndpoints, paramMatchers, warnings, migrationInventory.layouts)
+        : undefined;
+    return {
+        version: 1,
+        routesDir: options.routesDir,
+        ...(options.paramsDir ? { paramsDir: options.paramsDir } : {}),
+        pages,
+        endpoints: sortedEndpoints,
+        params: Array.from(paramMatchers.values()).sort((left, right) => left.name.localeCompare(right.name)),
+        warnings,
+        migrationInventory,
+        ...(migrationPlan ? { migrationPlan } : {}),
+        summary: {
+            pages: pages.length,
+            endpoints: sortedEndpoints.length,
+            dynamicRoutes: [...pages, ...sortedEndpoints].filter((route) => route.params.length > 0).length,
+            endpointKinds,
+            warnings: warnings.length,
+        },
+    };
+}
+export function createSvelteKitMigrationStubs(plan) {
+    const matcherIdentifiers = uniqueIdentifierMap(plan.paramMatchers.map((matcher) => matcher.name), "Matcher");
+    return [
+        {
+            path: "data.ts",
+            contents: renderDataProducerStubs(),
+        },
+        {
+            path: "routes.ts",
+            contents: renderRouteStubs(plan.routeFamilies, matcherIdentifiers),
+        },
+        {
+            path: "artifacts.ts",
+            contents: renderArtifactStubs(plan.artifactFamilies, matcherIdentifiers),
+        },
+        {
+            path: "param-matchers.ts",
+            contents: renderParamMatcherStubs(plan.paramMatchers, matcherIdentifiers),
+        },
+        {
+            path: "build.ts",
+            contents: renderBuildEntrypointStub(),
+        },
+        {
+            path: "collision-tests.md",
+            contents: renderCollisionTestStubs(plan.collisionTests),
+        },
+    ];
+}
+export async function emitSvelteKitMigrationStubs(plan, outDir, options = {}) {
+    const stubs = createSvelteKitMigrationStubs(plan);
+    const stubTargets = stubs.map((stub) => ({
+        ...stub,
+        targetPath: join(outDir, stub.path),
+    }));
+    await mkdir(outDir, { recursive: true });
+    if (!options.overwrite) {
+        const conflictingPaths = await existingPaths(stubTargets.map((stub) => stub.targetPath));
+        if (conflictingPaths.length > 0) {
+            throw new Error([
+                "SvelteKit migration stub target file(s) already exist.",
+                "Pass { overwrite: true } to replace generated targets:",
+                ...conflictingPaths.map((path) => `- ${path}`),
+            ].join("\n"));
+        }
+    }
+    await Promise.all(stubTargets.map((stub) => writeFile(stub.targetPath, stub.contents, options.overwrite ? undefined : { flag: "wx" })));
+    return stubs;
+}
+async function existingPaths(paths) {
+    const results = await Promise.all(paths.map(async (path) => {
+        try {
+            await access(path);
+            return path;
+        }
+        catch (error) {
+            if (isErrorCode(error, "ENOENT")) {
+                return undefined;
+            }
+            throw error;
+        }
+    }));
+    return results.filter((path) => path !== undefined);
+}
+function isErrorCode(error, code) {
+    return (typeof error === "object" &&
+        error !== null &&
+        "code" in error &&
+        error.code === code);
+}
+async function readParamMatchers(paramsDir) {
+    const matchers = new Map();
+    if (!paramsDir) {
+        return matchers;
+    }
+    for (const file of await walkFiles(paramsDir, { missing: "empty" })) {
+        const extension = extname(file);
+        if (![".js", ".ts"].includes(extension) || file.endsWith(".d.ts")) {
+            continue;
+        }
+        const relativeFile = toPosix(relative(paramsDir, file));
+        const name = relativeFile.slice(0, -extension.length);
+        matchers.set(name, { name, file: relativeFile });
+    }
+    return matchers;
+}
+async function walkFiles(root, options = {}) {
+    let entries;
+    try {
+        entries = await readdir(root, { withFileTypes: true });
+    }
+    catch (error) {
+        if (options.missing === "empty" && isNodeError(error) && error.code === "ENOENT") {
+            return [];
+        }
+        throw error;
+    }
+    const files = await Promise.all(entries.map(async (entry) => {
+        const path = join(root, entry.name);
+        if (entry.isDirectory()) {
+            return walkFiles(path, options);
+        }
+        return entry.isFile() ? [path] : [];
+    }));
+    return files.flat().sort();
+}
+function isSvelteKitPublicSurfaceFile(path) {
+    const fileName = path.split(sep).at(-1) ?? path;
+    return svelteKitRouteFilePattern().test(fileName);
+}
+function routeInfoForRelativeFile(relativeFile) {
+    const sourceSegments = relativeFile.split("/");
+    const fileName = sourceSegments.at(-1);
+    if (!fileName) {
+        return undefined;
+    }
+    const routeSegments = sourceSegments.slice(0, -1).filter((segment) => !isRouteGroup(segment));
+    const isPageLike = fileName.startsWith("+page") || fileName.startsWith("+layout");
+    const routePath = formatRoutePath(routeSegments, isPageLike);
+    const parsed = parseRouteSegments(routeSegments, isPageLike);
+    return {
+        routePath,
+        stoneagePattern: parsed.stoneagePattern,
+        params: parsed.params,
+    };
+}
+function routeFileInventorySource(route, relativeFile, source) {
+    return {
+        routePath: route.routePath,
+        file: relativeFile,
+        kind: routeFileKind(relativeFile),
+        usesLoad: exportsName(source, "load"),
+        usesActions: exportsName(source, "actions"),
+        usesRedirect: /\bredirect\s*\(/.test(source),
+        usesError404: /\berror\s*\(\s*404\b/.test(source),
+        exportsPrerender: exportsName(source, "prerender"),
+        usesEntries: exportsName(source, "entries"),
+        ...(hasLayoutReset(relativeFile) ? { layoutReset: true } : {}),
+        imports: importSources(source),
+        components: componentNames(source),
+    };
+}
+function routeFileKind(relativeFile) {
+    if (isLayoutComponentFile(relativeFile)) {
+        return "layout";
+    }
+    if (relativeFile.endsWith("+layout.server.ts") || relativeFile.endsWith("+layout.server.js")) {
+        return "layoutServer";
+    }
+    if (relativeFile.endsWith("+layout.ts") || relativeFile.endsWith("+layout.js")) {
+        return "layoutUniversal";
+    }
+    if (isPageComponentFile(relativeFile)) {
+        return "page";
+    }
+    if (relativeFile.endsWith("+page.server.ts") || relativeFile.endsWith("+page.server.js")) {
+        return "pageServer";
+    }
+    if (relativeFile.endsWith("+page.ts") || relativeFile.endsWith("+page.js")) {
+        return "pageUniversal";
+    }
+    return "endpoint";
+}
+function svelteKitRouteFilePattern() {
+    return /^\+(?:layout(?:@[^.]*)?\.svelte|layout\.server\.[jt]s|layout\.[jt]s|page(?:@[^.]*)?\.svelte|page\.server\.[jt]s|page\.[jt]s|server\.[jt]s)$/;
+}
+function routeFileName(relativeFile) {
+    return relativeFile.split("/").at(-1) ?? relativeFile;
+}
+function isLayoutComponentFile(relativeFile) {
+    return /^\+layout(?:@[^.]*)?\.svelte$/.test(routeFileName(relativeFile));
+}
+function isPageComponentFile(relativeFile) {
+    return /^\+page(?:@[^.]*)?\.svelte$/.test(routeFileName(relativeFile));
+}
+function isEndpointFile(relativeFile) {
+    return routeFileName(relativeFile) === "+server.ts" || routeFileName(relativeFile) === "+server.js";
+}
+function hasLayoutReset(relativeFile) {
+    return /^\+(?:layout|page)@[^.]*\.svelte$/.test(routeFileName(relativeFile));
+}
+function isUniversalPageLoadFile(relativeFile) {
+    return relativeFile.endsWith("+page.ts") || relativeFile.endsWith("+page.js");
+}
+function exportsName(source, name) {
+    return new RegExp(`\\bexport\\s+(?:const|let|var|function|async\\s+function)\\s+${name}\\b`).test(source);
+}
+function importSources(source) {
+    const imports = Array.from(source.matchAll(/\bimport\s+(?:type\s+)?(?:[\s\S]*?\s+from\s+)?["']([^"']+)["']/g))
+        .map((match) => match[1] ?? "")
+        .filter(Boolean);
+    return uniqueImportSources(imports);
+}
+function componentNames(source) {
+    const importedComponents = Array.from(source.matchAll(/\bimport\s+([A-Z][A-Za-z0-9_$]*)\s+from\s+["'][^"']+\.svelte["']/g)).map((match) => match[1] ?? "");
+    const taggedComponents = Array.from(source.matchAll(/<([A-Z][A-Za-z0-9_$]*(?:\.[A-Z][A-Za-z0-9_$]*)?)(?:\s|\/|>)/g))
+        .map((match) => match[1] ?? "");
+    return uniqueStringsFromPlans([...importedComponents, ...taggedComponents].filter(Boolean));
+}
+function createMigrationInventory(files) {
+    const sortedFiles = [...files].sort(compareByFile);
+    return {
+        layouts: sortedFiles
+            .filter((file) => file.kind === "layout" || file.kind === "layoutServer" || file.kind === "layoutUniversal")
+            .map((file) => ({
+            routePath: file.routePath,
+            file: file.file,
+            kind: file.kind,
+            imports: file.imports,
+            components: file.components,
+            ...(file.layoutReset ? { layoutReset: true } : {}),
+        })),
+        routeFiles: sortedFiles.map(({ imports: _imports, components: _components, ...file }) => file),
+        componentHints: sortedFiles
+            .filter((file) => file.imports.length > 0 || file.components.length > 0)
+            .map((file) => ({
+            file: file.file,
+            imports: file.imports,
+            components: file.components,
+        })),
+        checklist: migrationChecklist(),
+    };
+}
+function migrationChecklist() {
+    return [
+        {
+            category: "Data normalization",
+            items: [
+                "Move SvelteKit load and action data access into explicit normalized data producers.",
+                "Separate public data artifacts from HTML-only view models.",
+            ],
+        },
+        {
+            category: "Routing and entries",
+            items: [
+                "Convert dynamic routes and entries() exports into typed StoneAge route families.",
+                "Keep parameter matcher behavior explicit and add collision coverage for ambiguous routes.",
+            ],
+        },
+        {
+            category: "Rendering and layouts",
+            items: [
+                "Rebuild layout composition and Svelte component usage as static HTML render functions.",
+                "Preserve redirect and error handling as explicit generation decisions.",
+            ],
+        },
+        {
+            category: "Artifacts and metadata",
+            items: [
+                "Map +server outputs, status, headers, and content types into explicit artifact families.",
+                "Define metadata, sitemap entries, and export paths alongside route generation.",
+            ],
+        },
+        {
+            category: "Validation and tests",
+            items: [
+                "Add checks for route collisions, metadata completeness, sitemap output, and HTML size budgets.",
+                "Keep the migration inventory as static scaffold guidance before adding runtime behavior.",
+            ],
+        },
+    ];
+}
+function formatRoutePath(segments, isPage) {
+    if (segments.length === 0) {
+        return "/";
+    }
+    const path = `/${segments.join("/")}`;
+    return isPage ? `${path}/` : path;
+}
+function parseRouteSegments(segments, isPage) {
+    const params = [];
+    const stoneageSegments = segments.map((segment) => segment.replace(/\[\[([^\]=]+)(?:=([^\]]+))?\]\]|\[\.\.\.([^\]]+)\]|\[([^\]=]+)(?:=([^\]]+))?\]/g, (_match, optionalName, optionalMatcher, restName, dynamicName, dynamicMatcher) => {
+        if (optionalName) {
+            params.push({
+                name: optionalName,
+                ...(optionalMatcher ? { matcher: optionalMatcher } : {}),
+                optional: true,
+            });
+            return `:${optionalName}`;
+        }
+        if (restName) {
+            params.push({ name: restName, rest: true });
+            return `:${restName}`;
+        }
+        const name = dynamicName ?? "";
+        params.push({
+            name,
+            ...(dynamicMatcher ? { matcher: dynamicMatcher } : {}),
+        });
+        return `:${name}`;
+    }));
+    return {
+        params,
+        stoneagePattern: stoneageSegments.length === 0 ? "/" : `/${stoneageSegments.join("/")}${isPage ? "/" : ""}`,
+    };
+}
+function pageAuditFromGroup(group) {
+    const source = group.files.map((file) => file.source).join("\n");
+    const files = group.files.map((file) => file.relativeFile).sort();
+    return {
+        routePath: group.routePath,
+        stoneagePattern: group.stoneagePattern,
+        files,
+        params: group.params,
+        hasPage: files.some(isPageComponentFile),
+        hasPageServer: files.some((file) => file.endsWith("+page.server.ts") || file.endsWith("+page.server.js")),
+        hasPageUniversal: files.some(isUniversalPageLoadFile),
+        usesUniversalLoad: group.files.some((file) => isUniversalPageLoadFile(file.relativeFile) && exportsName(file.source, "load")),
+        usesActions: group.files.some((file) => exportsName(file.source, "actions")),
+        usesEntries: group.files.some((file) => exportsName(file.source, "entries")),
+        exportsPrerender: group.files.some((file) => exportsName(file.source, "prerender")),
+        usesRedirect: /\bredirect\s*\(/.test(source),
+        usesError404: /\berror\s*\(\s*404\b/.test(source),
+    };
+}
+function endpointMethods(source) {
+    const methodOrder = ["GET", "HEAD", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"];
+    return methodOrder.filter((method) => exportsName(source, method));
+}
+function endpointKind(routePath, source) {
+    if (routePath.endsWith(".json") || /\bjson\s*\(/.test(source)) {
+        return "json";
+    }
+    if (routePath.endsWith(".csv") || /text\/csv|application\/csv/.test(source)) {
+        return "csv";
+    }
+    if (routePath.endsWith(".xml") || /application\/xml|text\/xml/.test(source)) {
+        return "xml";
+    }
+    if (routePath.endsWith(".txt") || /text\/plain/.test(source)) {
+        return "txt";
+    }
+    if (/application\/octet-stream/.test(source)) {
+        return "binary";
+    }
+    return "unknown";
+}
+function createAuditWarnings(pages, endpoints, matchers) {
+    const warnings = [];
+    const routes = [...pages, ...endpoints];
+    for (const route of routes) {
+        for (const param of route.params) {
+            if (param.rest) {
+                warnings.push({
+                    code: "route.rest_param",
+                    path: route.routePath,
+                    message: `${route.routePath} uses a rest parameter and should be split into explicit StoneAge route families or custom paths.`,
+                });
+            }
+            if (param.optional) {
+                warnings.push({
+                    code: "route.optional_param",
+                    path: route.routePath,
+                    message: `${route.routePath} uses an optional parameter and should be split into explicit StoneAge route families.`,
+                });
+            }
+            const matcherName = param.matcher;
+            if (!param.rest && matcherName && !matchers.has(matcherName)) {
+                warnings.push({
+                    code: "param.matcher_missing",
+                    path: route.routePath,
+                    message: `${route.routePath} uses parameter ${param.name} without a matching src/params/${matcherName}.ts file.`,
+                });
+            }
+        }
+    }
+    for (const route of routes) {
+        if (hasSiblingDynamicWithoutMatcher(route.routePath, routes.map((candidate) => candidate.routePath))) {
+            warnings.push({
+                code: "route.sibling_dynamic_without_matcher",
+                path: route.routePath,
+                message: `${route.routePath} has a sibling dynamic route without complete matcher coverage.`,
+            });
+        }
+    }
+    for (const page of pages) {
+        if (page.usesActions) {
+            warnings.push({
+                code: "route.page_actions",
+                path: page.routePath,
+                message: `${page.routePath} exports SvelteKit page actions, which need an explicit static data migration or removal from the generated site.`,
+            });
+        }
+        const duplicateFiles = duplicatePageOutputFiles(page.files);
+        if (duplicateFiles.length > 0) {
+            warnings.push({
+                code: "route.duplicate_group_output",
+                path: page.routePath,
+                message: `${page.routePath} is produced by multiple SvelteKit page files after route groups are removed: ${duplicateFiles.join(", ")}.`,
+            });
+        }
+    }
+    for (const endpoint of endpoints) {
+        const nonStaticMethods = endpoint.methods.filter((method) => method !== "GET" && method !== "HEAD");
+        if (nonStaticMethods.length > 0) {
+            warnings.push({
+                code: "endpoint.non_static_method",
+                path: endpoint.routePath,
+                message: `${endpoint.routePath} exports non-static endpoint method(s): ${nonStaticMethods.join(", ")}. Migrate those handlers manually instead of treating them as generated artifacts.`,
+            });
+        }
+    }
+    const endpointCanonicalPaths = new Set(endpoints.map((endpoint) => canonicalRoutePath(endpoint.routePath)));
+    for (const page of pages) {
+        if (endpointCanonicalPaths.has(canonicalRoutePath(page.routePath))) {
+            warnings.push({
+                code: "route.page_artifact_same_path",
+                path: page.routePath,
+                message: `${page.routePath} has both a page and +server endpoint in the same public route directory; migrate them as separate StoneAge page and artifact outputs with explicit file paths.`,
+            });
+        }
+    }
+    for (const route of routes) {
+        if (hasStaticDynamicShadow(route.routePath, routes.map((candidate) => candidate.routePath))) {
+            warnings.push({
+                code: "route.static_dynamic_shadow",
+                path: route.routePath,
+                message: `${route.routePath} has a static sibling path that could also be emitted by this bare dynamic route. Add matcher constraints or route-entry collision tests.`,
+            });
+        }
+    }
+    return dedupeWarnings(warnings);
+}
+function createMigrationPlan(pages, endpoints, matchers, warnings, layouts) {
+    const routeFamilies = pages.map((page) => {
+        const layoutFiles = layoutFilesForRoute(page.routePath, layouts);
+        return {
+            name: migrationFamilyName(page.routePath, "Page"),
+            routePath: page.routePath,
+            pattern: page.stoneagePattern,
+            files: page.files,
+            params: page.params,
+            usesPageServer: page.hasPageServer,
+            usesUniversalLoad: page.usesUniversalLoad,
+            usesEntries: page.usesEntries,
+            ...(page.usesActions ? { usesActions: true } : {}),
+            ...(layoutFiles.length > 0 ? { layoutFiles } : {}),
+            paramMatchers: paramMatcherMap(page.params),
+        };
+    });
+    const artifactFamilies = endpoints.filter(canEmitStaticArtifact).map((endpoint) => {
+        const nonStaticMethods = endpoint.methods.filter((method) => method !== "GET" && method !== "HEAD");
+        return {
+            name: migrationFamilyName(endpoint.routePath, "Artifact"),
+            routePath: endpoint.routePath,
+            pattern: endpoint.stoneagePattern,
+            file: endpoint.file,
+            kind: endpoint.kind,
+            renderer: endpointRenderer(endpoint.kind),
+            params: endpoint.params,
+            paramMatchers: paramMatcherMap(endpoint.params),
+            usesResponseMetadata: endpoint.usesResponse,
+            ...(endpoint.usesEntries ? { usesEntries: true } : {}),
+            ...(nonStaticMethods.length > 0 ? { methods: endpoint.methods } : {}),
+            ...(nonStaticMethods.length > 0 ? { nonStaticMethods } : {}),
+        };
+    });
+    const routes = [...pages, ...endpoints];
+    return {
+        routeFamilies,
+        artifactFamilies,
+        paramMatchers: Array.from(matchers.values())
+            .map((matcher) => ({
+            name: matcher.name,
+            file: matcher.file,
+            usedBy: routes
+                .filter((route) => route.params.some((param) => param.matcher === matcher.name))
+                .map((route) => route.routePath)
+                .sort(),
+        }))
+            .sort((left, right) => left.name.localeCompare(right.name)),
+        collisionTests: warnings
+            .filter((warning) => [
+            "route.page_artifact_same_path",
+            "route.sibling_dynamic_without_matcher",
+            "route.static_dynamic_shadow",
+        ].includes(warning.code))
+            .map((warning) => ({
+            code: warning.code,
+            path: warning.path,
+            message: warning.message,
+        })),
+    };
+}
+function layoutFilesForRoute(routePath, layouts) {
+    return layouts
+        .filter((layout) => layout.routePath === "/" || routePath === layout.routePath || routePath.startsWith(layout.routePath))
+        .map((layout) => layout.file)
+        .sort();
+}
+function canEmitStaticArtifact(endpoint) {
+    return endpoint.methods.length === 0 || endpoint.methods.some((method) => method === "GET" || method === "HEAD");
+}
+function paramMatcherMap(params) {
+    return Object.fromEntries(params
+        .filter((param) => param.matcher)
+        .map((param) => [param.name, param.matcher])
+        .sort(([left], [right]) => left.localeCompare(right)));
+}
+function endpointRenderer(kind) {
+    if (kind === "json") {
+        return "jsonArtifact";
+    }
+    if (kind === "csv") {
+        return "csvArtifact";
+    }
+    if (kind === "xml") {
+        return "xmlArtifact";
+    }
+    if (kind === "txt") {
+        return "textArtifact";
+    }
+    return "artifactResponse";
+}
+function migrationFamilyName(routePath, suffix) {
+    const words = routePath
+        .split("/")
+        .filter(Boolean)
+        .flatMap((segment) => migrationSegmentWords(segment));
+    const base = words.length > 0 ? words.map(capitalizeIdentifier).join("") : "root";
+    return `${lowerFirst(base)}${suffix}`;
+}
+function migrationSegmentWords(segment) {
+    return segment
+        .replace(/\[\[([^\]=]+)(?:=([^\]]+))?\]\]|\[\.\.\.([^\]]+)\]|\[([^\]=]+)(?:=([^\]]+))?\]/g, (_match, optionalName, _optionalMatcher, restName, dynamicName) => optionalName ?? restName ?? dynamicName ?? "")
+        .split(/[^A-Za-z0-9]+/)
+        .filter(Boolean);
+}
+function capitalizeIdentifier(word) {
+    return `${word.slice(0, 1).toUpperCase()}${word.slice(1)}`;
+}
+function lowerFirst(word) {
+    return `${word.slice(0, 1).toLowerCase()}${word.slice(1)}`;
+}
+function duplicatePageOutputFiles(files) {
+    return ["+page.svelte", "+page.server"].flatMap((kind) => {
+        const matches = files.filter((file) => {
+            if (kind === "+page.svelte") {
+                return isPageComponentFile(file);
+            }
+            return file.endsWith("+page.server.ts") || file.endsWith("+page.server.js");
+        });
+        return matches.length > 1 ? matches : [];
+    });
+}
+function hasSiblingDynamicWithoutMatcher(path, allPaths) {
+    const segments = path.split("/").filter(Boolean);
+    return bareDynamicSegmentIndexes(segments).some((dynamicIndex) => {
+        const dynamicSegment = segments[dynamicIndex] ?? "";
+        const parent = segments.slice(0, dynamicIndex).join("/");
+        const signature = dynamicSiblingSignature(dynamicSegment);
+        return allPaths.some((candidate) => {
+            if (candidate === path || canonicalRoutePath(candidate) === canonicalRoutePath(path)) {
+                return false;
+            }
+            const candidateSegments = candidate.split("/").filter(Boolean);
+            const candidateSegment = candidateSegments[dynamicIndex] ?? "";
+            return (candidateSegments.slice(0, dynamicIndex).join("/") === parent &&
+                candidateSegment !== dynamicSegment &&
+                anyDynamicParamPattern(candidateSegment) != null &&
+                dynamicSiblingSignature(candidateSegment) === signature);
+        });
+    });
+}
+function hasStaticDynamicShadow(path, allPaths) {
+    const segments = path.split("/").filter(Boolean);
+    return bareDynamicSegmentIndexes(segments).some((dynamicIndex) => {
+        return allPaths.some((candidate) => {
+            if (candidate === path || canonicalRoutePath(candidate) === canonicalRoutePath(path)) {
+                return false;
+            }
+            const candidateSegments = candidate.split("/").filter(Boolean);
+            return (candidateSegments.length === segments.length &&
+                candidateSegments.slice(0, dynamicIndex).join("/") === segments.slice(0, dynamicIndex).join("/") &&
+                candidateSegments.slice(dynamicIndex + 1).join("/") === segments.slice(dynamicIndex + 1).join("/") &&
+                isStaticRouteSegment(candidateSegments[dynamicIndex] ?? ""));
+        });
+    });
+}
+function bareDynamicSegmentIndexes(segments) {
+    return segments
+        .map((segment, index) => ({
+        index,
+        segment,
+    }))
+        .filter(({ segment }) => bareDynamicParamPattern(segment) != null && matcherDynamicParamPattern(segment) == null)
+        .map(({ index }) => index);
+}
+function canonicalRoutePath(path) {
+    if (path === "/") {
+        return path;
+    }
+    return path.endsWith("/") ? path.slice(0, -1) : path;
+}
+function isStaticRouteSegment(segment) {
+    return segment !== "" && !segment.includes("[");
+}
+function bareDynamicParamPattern(segment) {
+    if (segment.includes("[[") || segment.includes("[...")) {
+        return null;
+    }
+    return segment.match(/\[([^\]=.][^\]=]*)\]/);
+}
+function anyDynamicParamPattern(segment) {
+    if (segment.includes("[[") || segment.includes("[...")) {
+        return null;
+    }
+    return segment.match(/\[[^\]]+\]/);
+}
+function matcherDynamicParamPattern(segment) {
+    return segment.match(/\[[^\]=]+=([^\]]+)\]/);
+}
+function dynamicSiblingSignature(segment) {
+    return segment.replace(/\[[^\]]+\]/g, "[]");
+}
+function summarizeEndpointKinds(endpoints) {
+    const summary = {};
+    for (const endpoint of endpoints) {
+        summary[endpoint.kind] = (summary[endpoint.kind] ?? 0) + 1;
+    }
+    return summary;
+}
+function dedupeWarnings(warnings) {
+    return Array.from(new Map(warnings.map((warning) => [`${warning.code}:${warning.path}:${warning.message}`, warning])).values());
+}
+function renderDataProducerStubs() {
+    return [
+        "export type NormalizedData = {",
+        "  records: unknown[];",
+        "};",
+        "",
+        "export async function loadNormalizedData(): Promise<NormalizedData> {",
+        "  return {",
+        "    records: [],",
+        "  };",
+        "}",
+        "",
+    ].join("\n");
+}
+function renderRouteStubs(routeFamilies, matcherIdentifiers) {
+    const matcherNames = uniqueStringsFromPlans(routeFamilies.flatMap((family) => Object.values(family.paramMatchers)));
+    const imports = [
+        'import { defineRouteFamily, type RouteFamily } from "@t09tanaka/stoneage";',
+        'import type { NormalizedData } from "./data.js";',
+        ...(matcherNames.length > 0
+            ? [`import { ${matcherNames.map((name) => matcherIdentifiers.get(name) ?? identifierFor(name, "Matcher")).join(", ")} } from "./param-matchers.js";`]
+            : []),
+    ];
+    const body = routeFamilies.length === 0
+        ? "// No route families were found in the migration plan."
+        : routeFamilies
+            .map((family) => renderRouteFamilyStub(family, matcherIdentifiers))
+            .join("\n\n");
+    return `${imports.join("\n")}\n\n${body}\n\n${renderRouteFamilyFactory(routeFamilies)}\n`;
+}
+function renderRouteFamilyStub(family, matcherIdentifiers) {
+    const lines = [
+        `// Original route: ${family.routePath}`,
+        ...(family.layoutFiles ?? []).map((file) => `// Layout source: ${file}`),
+        ...family.files.map((file) => `// Source: ${file}`),
+        ...(family.usesUniversalLoad
+            ? ["// TODO: Move universal +page.ts/+page.js load data into normalized data producers."]
+            : []),
+        ...(family.usesActions
+            ? ["// TODO: Move SvelteKit page actions into explicit static data producers or remove them from the static output."]
+            : []),
+        family.usesPageServer
+            ? "// TODO: Move +page.server.ts loading into normalized data producers."
+            : "// TODO: Add normalized data entries for this page route.",
+        family.usesEntries
+            ? "// SvelteKit entries() was detected; use it only as a migration reference."
+            : "// TODO: Define explicit route entries from normalized data.",
+        `export const ${identifierFor(family.name, "routeFamily")} = defineRouteFamily({`,
+        `  name: ${stringLiteral(family.name)},`,
+        `  pattern: ${stringLiteral(family.pattern)},`,
+        ...renderParamMatchersProperty(family.paramMatchers, matcherIdentifiers, "  "),
+        "  entries: () => [",
+        "    {",
+        `      params: ${renderParamsPlaceholder(family.params)},`,
+        "      dependencies: [],",
+        "      metadata: {",
+        '        title: "TODO",',
+        '        description: "TODO",',
+        "      },",
+        "      // TODO: Replace this placeholder with normalized data entries.",
+        '      render: () => "<main>TODO</main>",',
+        "    },",
+        "  ],",
+        "});",
+    ];
+    return lines.join("\n");
+}
+function renderRouteFamilyFactory(routeFamilies) {
+    const identifiers = routeFamilies.map((family) => identifierFor(family.name, "routeFamily"));
+    return [
+        "export function createRouteFamilies(_data: NormalizedData): RouteFamily[] {",
+        "  return [",
+        ...identifiers.map((identifier) => `    ${identifier},`),
+        "  ];",
+        "}",
+    ].join("\n");
+}
+function renderArtifactStubs(artifactFamilies, matcherIdentifiers) {
+    const renderers = uniqueStringsFromPlans(artifactFamilies.map((family) => family.renderer));
+    const matcherNames = uniqueStringsFromPlans(artifactFamilies.flatMap((family) => Object.values(family.paramMatchers)));
+    const stoneageImports = uniqueStringsFromPlans([...renderers, "defineArtifactFamily"]);
+    const imports = [
+        `import { ${stoneageImports.join(", ")} } from "@t09tanaka/stoneage";`,
+        'import type { ArtifactFamily } from "@t09tanaka/stoneage";',
+        'import type { NormalizedData } from "./data.js";',
+        ...(matcherNames.length > 0
+            ? [`import { ${matcherNames.map((name) => matcherIdentifiers.get(name) ?? identifierFor(name, "Matcher")).join(", ")} } from "./param-matchers.js";`]
+            : []),
+    ];
+    const body = artifactFamilies.length === 0
+        ? "// No artifact families were found in the migration plan."
+        : artifactFamilies
+            .map((family) => renderArtifactFamilyStub(family, matcherIdentifiers))
+            .join("\n\n");
+    return `${imports.join("\n")}\n\n${body}\n\n${renderArtifactFamilyFactory(artifactFamilies)}\n`;
+}
+function renderArtifactFamilyStub(family, matcherIdentifiers) {
+    const lines = [
+        `// Original route: ${family.routePath}`,
+        `// Source: ${family.file}`,
+        `// Renderer hint: ${family.renderer} for ${family.kind} endpoints.`,
+        ...(family.usesEntries
+            ? ["// SvelteKit entries() was detected; use it only as a migration reference."]
+            : []),
+        ...(family.nonStaticMethods && family.nonStaticMethods.length > 0
+            ? [`// TODO: Non-static endpoint methods require a manual migration path: ${family.nonStaticMethods.join(", ")}.`]
+            : []),
+        family.usesResponseMetadata
+            ? "// TODO: Preserve status, headers, and content type metadata from the SvelteKit Response."
+            : "// TODO: Add status, headers, or content type metadata if this endpoint needs them.",
+        `export const ${identifierFor(family.name, "artifactFamily")} = defineArtifactFamily({`,
+        `  name: ${stringLiteral(family.name)},`,
+        `  pattern: ${stringLiteral(family.pattern)},`,
+        ...renderParamMatchersProperty(family.paramMatchers, matcherIdentifiers, "  "),
+        "  entries: () => [",
+        "    {",
+        `      params: ${renderParamsPlaceholder(family.params)},`,
+        "      dependencies: [],",
+        "      // TODO: Replace this placeholder with normalized data entries and render body.",
+        `      render: () => ${renderArtifactPlaceholder(family.renderer)},`,
+        "    },",
+        "  ],",
+        "});",
+    ];
+    return lines.join("\n");
+}
+function renderArtifactFamilyFactory(artifactFamilies) {
+    const identifiers = artifactFamilies.map((family) => identifierFor(family.name, "artifactFamily"));
+    return [
+        "export function createArtifactFamilies(_data: NormalizedData): ArtifactFamily[] {",
+        "  return [",
+        ...identifiers.map((identifier) => `    ${identifier},`),
+        "  ];",
+        "}",
+    ].join("\n");
+}
+function renderParamMatcherStubs(paramMatchers, matcherIdentifiers) {
+    const body = paramMatchers.length === 0
+        ? "// No param matchers were found in the migration plan."
+        : paramMatchers
+            .map((matcher) => {
+            const usedBy = matcher.usedBy.length > 0 ? matcher.usedBy.join(", ") : "none";
+            return [
+                `// Source: ${matcher.file}`,
+                `// Used by: ${usedBy}`,
+                `// TODO: Port the original SvelteKit matcher logic into this StoneAge matcher.`,
+                `export const ${matcherIdentifiers.get(matcher.name) ?? identifierFor(matcher.name, "Matcher")} = patternParamMatcher(/^TODO$/);`,
+            ].join("\n");
+        })
+            .join("\n\n");
+    return `import { patternParamMatcher } from "@t09tanaka/stoneage";\n\n${body}\n`;
+}
+function renderCollisionTestStubs(collisionTests) {
+    if (collisionTests.length === 0) {
+        return "# Collision Test Candidates\n\nNo collision test candidates were found.\n";
+    }
+    const items = collisionTests.map((candidate) => [
+        `- \`${candidate.code}\` \`${candidate.path}\``,
+        `  - ${candidate.message}`,
+        "  - TODO: Add a StoneAge route-entry test that proves this path cannot collide.",
+    ].join("\n"));
+    return `# Collision Test Candidates\n\n${items.join("\n")}\n`;
+}
+function renderBuildEntrypointStub() {
+    return [
+        'import { buildSite } from "@t09tanaka/stoneage";',
+        'import { createArtifactFamilies } from "./artifacts.js";',
+        'import { loadNormalizedData } from "./data.js";',
+        'import { createRouteFamilies } from "./routes.js";',
+        "",
+        "const data = await loadNormalizedData();",
+        "",
+        "await buildSite({",
+        '  outDir: "dist",',
+        "  site: {",
+        '    baseUrl: "https://example.com",',
+        '    title: "TODO",',
+        '    description: "TODO",',
+        "  },",
+        "  routes: createRouteFamilies(data),",
+        "  artifacts: createArtifactFamilies(data),",
+        "});",
+        "",
+    ].join("\n");
+}
+function renderParamMatchersProperty(paramMatchers, matcherIdentifiers, indent) {
+    const entries = Object.entries(paramMatchers).sort(([left], [right]) => left.localeCompare(right));
+    if (entries.length === 0) {
+        return [];
+    }
+    return [
+        `${indent}paramMatchers: {`,
+        ...entries.map(([paramName, matcherName]) => {
+            const identifier = matcherIdentifiers.get(matcherName) ?? identifierFor(matcherName, "Matcher");
+            return `${indent}  ${objectKey(paramName)}: ${identifier},`;
+        }),
+        `${indent}},`,
+    ];
+}
+function renderParamsPlaceholder(params) {
+    if (params.length === 0) {
+        return "{}";
+    }
+    const entries = params
+        .map((param) => `${objectKey(param.name)}: "TODO"`)
+        .join(", ");
+    return `{ ${entries} }`;
+}
+function renderArtifactPlaceholder(renderer) {
+    if (renderer === "jsonArtifact") {
+        return "jsonArtifact({ todo: true })";
+    }
+    if (renderer === "csvArtifact") {
+        return 'csvArtifact("TODO\\n")';
+    }
+    if (renderer === "xmlArtifact") {
+        return 'xmlArtifact("<root />")';
+    }
+    if (renderer === "textArtifact") {
+        return 'textArtifact("TODO")';
+    }
+    return 'artifactResponse("TODO")';
+}
+function uniqueIdentifierMap(names, fallback) {
+    const identifiers = new Map();
+    const used = new Set();
+    for (const name of uniqueStringsFromPlans(names)) {
+        const base = identifierFor(name, fallback);
+        let identifier = base;
+        let suffix = 2;
+        while (used.has(identifier)) {
+            identifier = `${base}${suffix}`;
+            suffix += 1;
+        }
+        used.add(identifier);
+        identifiers.set(name, identifier);
+    }
+    return identifiers;
+}
+function identifierFor(value, fallback) {
+    const words = value.split(/[^A-Za-z0-9_$]+/).filter(Boolean);
+    const candidate = words.length === 0
+        ? fallback
+        : `${words[0]}${words.slice(1).map(capitalizeIdentifier).join("")}`;
+    const identifier = candidate.replace(/^[^A-Za-z_$]+/, "");
+    return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(identifier) ? identifier : fallback;
+}
+function objectKey(value) {
+    return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(value) ? value : stringLiteral(value);
+}
+function stringLiteral(value) {
+    return JSON.stringify(value);
+}
+function uniqueStringsFromPlans(values) {
+    return Array.from(new Set(values)).sort((left, right) => left.localeCompare(right));
+}
+function uniqueImportSources(values) {
+    return Array.from(new Set(values)).sort((left, right) => {
+        const relativeOrder = Number(left.startsWith(".")) - Number(right.startsWith("."));
+        return relativeOrder || left.localeCompare(right);
+    });
+}
+function compareByRoutePath(left, right) {
+    return left.routePath.localeCompare(right.routePath);
+}
+function compareByFile(left, right) {
+    return left.file.localeCompare(right.file);
+}
+function compareWarnings(left, right) {
+    return left.path.localeCompare(right.path) || left.code.localeCompare(right.code);
+}
+function isRouteGroup(segment) {
+    return segment.startsWith("(") && segment.endsWith(")");
+}
+function toPosix(path) {
+    return path.split(sep).join("/");
+}
+function isNodeError(error) {
+    return typeof error === "object" && error !== null && "code" in error;
+}