modviz 0.1.2

package/dist/mod/module-graph-plugins.js

@@ -0,0 +1,60 @@
+import path from "node:path";
+const WINDOWS_ABSOLUTE_PATH_RE = /^[A-Za-z]:[\\/]/;
+const ANALYZABLE_SOURCE_EXTENSIONS = new Set([
+    ".js",
+    ".jsx",
+    ".ts",
+    ".tsx",
+    ".mjs",
+    ".cjs",
+    ".mts",
+    ".cts",
+    ".json",
+    ".node",
+]);
+function findSpecifierSuffixIndex(importee) {
+    const queryIndex = importee.indexOf("?");
+    const hashIndex = importee.indexOf("#");
+    if (queryIndex === -1) {
+        return hashIndex;
+    }
+    if (hashIndex === -1) {
+        return queryIndex;
+    }
+    return Math.min(queryIndex, hashIndex);
+}
+function isFileLikeImportSpecifier(importee) {
+    return (importee.startsWith("./") ||
+        importee.startsWith("../") ||
+        importee.startsWith("/") ||
+        WINDOWS_ABSOLUTE_PATH_RE.test(importee));
+}
+export function sanitizeImportSpecifierForAnalysis(importee) {
+    const suffixIndex = findSpecifierSuffixIndex(importee);
+    if (suffixIndex === -1) {
+        return importee;
+    }
+    const cleanedImportee = importee.slice(0, suffixIndex);
+    if (!cleanedImportee || !isFileLikeImportSpecifier(cleanedImportee)) {
+        return importee;
+    }
+    return cleanedImportee;
+}
+export function shouldSkipImportForAnalysis(importee) {
+    const sanitizedImportee = sanitizeImportSpecifierForAnalysis(importee);
+    if (sanitizedImportee === importee) {
+        return false;
+    }
+    const extension = path.extname(sanitizedImportee).toLowerCase();
+    return extension.length > 0 && !ANALYZABLE_SOURCE_EXTENSIONS.has(extension);
+}
+export const sanitizeFileImportSuffixPlugin = {
+    name: "sanitize-file-import-suffix",
+    handleImport({ importee }) {
+        if (shouldSkipImportForAnalysis(importee)) {
+            return false;
+        }
+        const sanitizedImportee = sanitizeImportSpecifierForAnalysis(importee);
+        return sanitizedImportee === importee ? undefined : sanitizedImportee;
+    },
+};

package/dist/mod/production-server.js

@@ -0,0 +1,103 @@
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { resolveProductionRuntimePaths } from "./runtime-host.js";
+const __dirname = fileURLToPath(new URL(".", import.meta.url));
+const runtimePaths = resolveProductionRuntimePaths(import.meta.url);
+const openBrowser = async (url) => {
+    const platform = process.platform;
+    const command = platform === "darwin" ? "open" : platform === "win32" ? "cmd" : "xdg-open";
+    const args = platform === "win32" ? ["/c", "start", "", url] : [url];
+    spawn(command, args, {
+        detached: true,
+        stdio: "ignore",
+    }).unref();
+};
+const waitForServer = async (url, timeoutMs = 20000) => {
+    const start = Date.now();
+    while (Date.now() - start < timeoutMs) {
+        try {
+            const response = await fetch(url, { method: "GET" });
+            if (response.ok) {
+                return;
+            }
+        }
+        catch {
+            // Keep polling until the server is reachable.
+        }
+        await new Promise((resolve) => setTimeout(resolve, 250));
+    }
+    throw new Error(`Timed out waiting for the web UI server at ${url}`);
+};
+const formatEarlyExit = (code, signal) => {
+    const details = [code !== null ? `code ${code}` : null, signal ? `signal ${signal}` : null]
+        .filter(Boolean)
+        .join(", ");
+    return `The web UI server exited before it became ready${details ? ` (${details})` : ""}.`;
+};
+export async function startProductionServer(options) {
+    if (!existsSync(runtimePaths.runtimeServerEntry)) {
+        throw new Error([
+            `Expected packaged production runtime at ${runtimePaths.runtimeServerEntry}.`,
+            "Run `pnpm build` in the modviz package before launching the UI.",
+        ].join(" "));
+    }
+    const runtimeHostEntry = existsSync(runtimePaths.runtimeHostBuildEntry)
+        ? runtimePaths.runtimeHostBuildEntry
+        : runtimePaths.runtimeHostSourceEntry;
+    if (!existsSync(runtimeHostEntry)) {
+        throw new Error([
+            `Expected a runtime host entry at ${runtimePaths.runtimeHostBuildEntry} or ${runtimePaths.runtimeHostSourceEntry}.`,
+            "Run `pnpm build` in the modviz package before launching the UI.",
+        ].join(" "));
+    }
+    const historyDir = path.join(path.dirname(path.resolve(options.outputPath)), ".modviz", "history");
+    const child = spawn(process.execPath, [runtimeHostEntry], {
+        env: {
+            ...process.env,
+            MODVIZ_PATH: options.outputPath,
+            MODVIZ_HISTORY_DIR: process.env.MODVIZ_HISTORY_DIR ?? historyDir,
+            PORT: String(options.port),
+        },
+        stdio: "inherit",
+    });
+    const shutdown = () => {
+        child.kill("SIGTERM");
+    };
+    process.once("SIGINT", shutdown);
+    process.once("SIGTERM", shutdown);
+    const url = `http://localhost:${options.port}`;
+    let onEarlyError;
+    let onEarlyExit;
+    const childFailure = new Promise((_, reject) => {
+        onEarlyError = (error) => reject(error);
+        onEarlyExit = (code, signal) => reject(new Error(formatEarlyExit(code, signal)));
+        child.once("error", onEarlyError);
+        child.once("exit", onEarlyExit);
+    });
+    try {
+        await Promise.race([waitForServer(url), childFailure]);
+    }
+    finally {
+        if (onEarlyError) {
+            child.off("error", onEarlyError);
+        }
+        if (onEarlyExit) {
+            child.off("exit", onEarlyExit);
+        }
+    }
+    if (options.open !== false) {
+        await openBrowser(url);
+    }
+    await new Promise((resolve, reject) => {
+        child.once("error", reject);
+        child.once("exit", (code, signal) => {
+            if (code === 0 || signal === "SIGINT" || signal === "SIGTERM") {
+                resolve();
+                return;
+            }
+            reject(new Error(formatEarlyExit(code, signal)));
+        });
+    });
+}

package/dist/mod/runtime-host.js

@@ -0,0 +1,217 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { createReadStream, existsSync, statSync } from "node:fs";
+import { createServer } from "node:http";
+import path from "node:path";
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import { fileURLToPath, pathToFileURL } from "node:url";
+export const resolveProductionRuntimePaths = (fromImportUrl) => {
+    const currentDir = fileURLToPath(new URL(".", fromImportUrl));
+    const candidatePackageRoots = [path.resolve(currentDir, ".."), path.resolve(currentDir, "../..")];
+    const packageRoot = candidatePackageRoots.find((candidate) => existsSync(path.join(candidate, "package.json"))) ??
+        path.resolve(currentDir, "..");
+    const packagedRuntimeRoot = path.join(packageRoot, "dist");
+    return {
+        packageRoot,
+        packagedRuntimeRoot,
+        runtimeClientRoot: path.join(packagedRuntimeRoot, "client"),
+        runtimeHostBuildEntry: path.join(packagedRuntimeRoot, "mod", "runtime-host.js"),
+        runtimeHostSourceEntry: path.join(packageRoot, "mod", "runtime-host.ts"),
+        runtimeServerEntry: path.join(packagedRuntimeRoot, "server", "server.js"),
+    };
+};
+const STATIC_CONTENT_TYPES = {
+    ".css": "text/css; charset=utf-8",
+    ".gif": "image/gif",
+    ".html": "text/html; charset=utf-8",
+    ".ico": "image/x-icon",
+    ".jpeg": "image/jpeg",
+    ".jpg": "image/jpeg",
+    ".js": "text/javascript; charset=utf-8",
+    ".json": "application/json; charset=utf-8",
+    ".map": "application/json; charset=utf-8",
+    ".mjs": "text/javascript; charset=utf-8",
+    ".png": "image/png",
+    ".svg": "image/svg+xml",
+    ".txt": "text/plain; charset=utf-8",
+    ".webmanifest": "application/manifest+json; charset=utf-8",
+    ".webp": "image/webp",
+    ".woff": "font/woff",
+    ".woff2": "font/woff2",
+};
+const isDirectExecution = (importUrl) => {
+    const argvPath = process.argv[1];
+    if (!argvPath) {
+        return false;
+    }
+    return pathToFileURL(path.resolve(argvPath)).href === importUrl;
+};
+const createRequestFromNode = (request, port) => {
+    const forwardedProto = request.headers["x-forwarded-proto"];
+    const protocol = typeof forwardedProto === "string" && forwardedProto.trim().length > 0
+        ? forwardedProto.split(",")[0].trim()
+        : "http";
+    const host = request.headers.host ?? `localhost:${port}`;
+    const url = new URL(request.url ?? "/", `${protocol}://${host}`);
+    const headers = new Headers();
+    for (const [key, value] of Object.entries(request.headers)) {
+        if (Array.isArray(value)) {
+            for (const headerValue of value) {
+                headers.append(key, headerValue);
+            }
+            continue;
+        }
+        if (typeof value === "string") {
+            headers.set(key, value);
+        }
+    }
+    const method = request.method ?? "GET";
+    const hasBody = !["GET", "HEAD"].includes(method.toUpperCase());
+    const body = hasBody ? Readable.toWeb(request) : undefined;
+    const requestInit = {
+        body,
+        duplex: hasBody ? "half" : undefined,
+        headers,
+        method,
+    };
+    return new Request(url, requestInit);
+};
+const getContentType = (filePath) => STATIC_CONTENT_TYPES[path.extname(filePath).toLowerCase()] ?? "application/octet-stream";
+const resolveStaticAssetPath = (clientRoot, pathname) => {
+    const relativePath = decodeURIComponent(pathname).replace(/^\/+/, "");
+    if (!relativePath) {
+        return null;
+    }
+    const absoluteClientRoot = path.resolve(clientRoot);
+    const candidatePath = path.resolve(absoluteClientRoot, relativePath);
+    if (candidatePath !== absoluteClientRoot &&
+        !candidatePath.startsWith(`${absoluteClientRoot}${path.sep}`)) {
+        return null;
+    }
+    if (!existsSync(candidatePath)) {
+        return null;
+    }
+    const stat = statSync(candidatePath);
+    if (!stat.isFile()) {
+        return null;
+    }
+    return {
+        filePath: candidatePath,
+        stat,
+    };
+};
+const tryServeStaticAsset = async (request, response, clientRoot, port) => {
+    const method = (request.method ?? "GET").toUpperCase();
+    if (method !== "GET" && method !== "HEAD") {
+        return false;
+    }
+    const requestUrl = new URL(request.url ?? "/", `http://${request.headers.host ?? `localhost:${port}`}`);
+    if (path.posix.extname(requestUrl.pathname) === "") {
+        return false;
+    }
+    const asset = resolveStaticAssetPath(clientRoot, requestUrl.pathname);
+    if (!asset) {
+        return false;
+    }
+    response.statusCode = 200;
+    response.setHeader("content-length", String(asset.stat.size));
+    response.setHeader("content-type", getContentType(asset.filePath));
+    response.setHeader("cache-control", requestUrl.pathname.startsWith("/assets/")
+        ? "public, max-age=31536000, immutable"
+        : "public, max-age=3600");
+    if (method === "HEAD") {
+        response.end();
+        return true;
+    }
+    await pipeline(createReadStream(asset.filePath), response);
+    return true;
+};
+const writeResponseToNode = async (request, response, nodeResponse) => {
+    nodeResponse.statusCode = response.status;
+    nodeResponse.statusMessage = response.statusText;
+    const responseHeaders = response.headers;
+    const setCookieValues = responseHeaders.getSetCookie?.() ?? [];
+    response.headers.forEach((value, key) => {
+        if (key.toLowerCase() === "set-cookie" && setCookieValues.length > 0) {
+            return;
+        }
+        nodeResponse.setHeader(key, value);
+    });
+    if (setCookieValues.length > 0) {
+        nodeResponse.setHeader("set-cookie", setCookieValues);
+    }
+    if (!response.body || request.method?.toUpperCase() === "HEAD") {
+        nodeResponse.end();
+        return;
+    }
+    await pipeline(Readable.fromWeb(response.body), nodeResponse);
+};
+const handleNodeRequest = async (fetchHandler, request, response, clientRoot, port) => {
+    try {
+        if (await tryServeStaticAsset(request, response, clientRoot, port)) {
+            return;
+        }
+        const runtimeRequest = createRequestFromNode(request, port);
+        const runtimeResponse = await fetchHandler(runtimeRequest);
+        await writeResponseToNode(request, runtimeResponse, response);
+    }
+    catch (error) {
+        console.error(error);
+        if (!response.headersSent) {
+            response.statusCode = 500;
+            response.setHeader("content-type", "text/plain; charset=utf-8");
+        }
+        response.end("Internal Server Error");
+    }
+};
+export async function startRuntimeHost(options) {
+    const runtimePaths = resolveProductionRuntimePaths(import.meta.url);
+    if (!existsSync(runtimePaths.runtimeServerEntry)) {
+        throw new Error([
+            `Expected bundled TanStack server module at ${runtimePaths.runtimeServerEntry}.`,
+            "Run `pnpm build` before starting the production UI.",
+        ].join(" "));
+    }
+    const port = options?.port ?? Number.parseInt(process.env.PORT ?? "3000", 10);
+    if (!Number.isInteger(port) || port <= 0) {
+        throw new Error(`Invalid PORT value: ${process.env.PORT ?? String(options?.port)}`);
+    }
+    const serverModule = (await import(__rewriteRelativeImportExtension(pathToFileURL(runtimePaths.runtimeServerEntry).href)));
+    const fetchHandler = serverModule.default?.fetch;
+    if (typeof fetchHandler !== "function") {
+        throw new Error([
+            `Expected ${runtimePaths.runtimeServerEntry} to export a default fetch handler.`,
+            "The production UI build is incomplete or incompatible with the current launcher.",
+        ].join(" "));
+    }
+    const server = createServer((request, response) => {
+        void handleNodeRequest(fetchHandler, request, response, runtimePaths.runtimeClientRoot, port);
+    });
+    await new Promise((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(port, () => resolve());
+    });
+    const shutdown = () => {
+        server.close();
+        server.closeAllConnections?.();
+    };
+    process.once("SIGINT", shutdown);
+    process.once("SIGTERM", shutdown);
+    await new Promise((resolve, reject) => {
+        server.once("close", () => resolve());
+        server.once("error", reject);
+    });
+}
+if (isDirectExecution(import.meta.url)) {
+    void startRuntimeHost().catch((error) => {
+        console.error(error);
+        process.exit(1);
+    });
+}

package/dist/mod/snapshot-history.js

@@ -0,0 +1,73 @@
+import { mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import path from "node:path";
+const SNAPSHOT_NAME_SANITIZER = /[^a-z0-9-_]+/gi;
+export const resolveSnapshotHistoryDir = () => path.resolve(process.env.MODVIZ_HISTORY_DIR ??
+    (process.env.MODVIZ_PATH
+        ? path.join(path.dirname(path.resolve(process.env.MODVIZ_PATH)), ".modviz", "history")
+        : path.join(process.cwd(), ".modviz", "history")));
+const toSnapshotId = (snapshotName, generatedAt) => {
+    const timestamp = new Date(generatedAt ?? Date.now()).toISOString().replace(/[:.]/g, "-");
+    const normalizedName = snapshotName
+        .trim()
+        .replace(SNAPSHOT_NAME_SANITIZER, "-")
+        .replace(/-+/g, "-")
+        .replace(/^-|-$/g, "")
+        .toLowerCase() || "snapshot";
+    return `${timestamp}-${normalizedName}`;
+};
+const resolveSnapshotPaths = (snapshotId) => {
+    const historyDir = resolveSnapshotHistoryDir();
+    return {
+        historyDir,
+        graphPath: path.join(historyDir, `${snapshotId}.json`),
+        llmPath: path.join(historyDir, `${snapshotId}.llm.json`),
+    };
+};
+const readSnapshotItem = (graphPath) => {
+    try {
+        const raw = JSON.parse(readFileSync(graphPath, "utf-8"));
+        const fileStats = statSync(graphPath);
+        const snapshotId = path.basename(graphPath, ".json");
+        const llmPath = graphPath.replace(/\.json$/, ".llm.json");
+        return {
+            id: snapshotId,
+            label: snapshotId.replace(/^\d{4}-\d{2}-\d{2}t/i, "").replace(/-/g, " "),
+            graphPath,
+            llmPath,
+            generatedAt: raw.metadata.generatedAt ?? null,
+            lastModified: fileStats.mtimeMs,
+            totalNodes: raw.nodes.length,
+            entrypoints: raw.metadata.entrypoints,
+        };
+    }
+    catch {
+        return null;
+    }
+};
+export const listSnapshotHistory = () => {
+    const historyDir = resolveSnapshotHistoryDir();
+    try {
+        return readdirSync(historyDir)
+            .filter((fileName) => fileName.endsWith(".json") && !fileName.endsWith(".llm.json"))
+            .map((fileName) => readSnapshotItem(path.join(historyDir, fileName)))
+            .filter((item) => Boolean(item))
+            .sort((left, right) => right.lastModified - left.lastModified);
+    }
+    catch {
+        return [];
+    }
+};
+export const saveSnapshotToHistory = (options) => {
+    const snapshotId = toSnapshotId(options.snapshotName, options.graph.metadata.generatedAt);
+    const { historyDir, graphPath, llmPath } = resolveSnapshotPaths(snapshotId);
+    mkdirSync(historyDir, { recursive: true });
+    writeFileSync(graphPath, JSON.stringify(options.graph, null, 2));
+    if (options.llm) {
+        writeFileSync(llmPath, JSON.stringify(options.llm, null, 2));
+    }
+    return readSnapshotItem(graphPath);
+};
+export const loadSnapshotGraph = (snapshotId) => {
+    const { graphPath } = resolveSnapshotPaths(snapshotId);
+    return JSON.parse(readFileSync(graphPath, "utf-8"));
+};

package/dist/mod/types.js

@@ -0,0 +1,3 @@
+// TODO flame graph / show "hot spots" = problematic files (= introducing too many transitive imports)
+// TODO a way to show files that trigger transitive imports going through another package
+export {};

package/dist/server/assets/__23tanstack-start-plugin-adapters-3QxJs4a0.js

@@ -0,0 +1,5 @@
+//#region \0%23tanstack-start-plugin-adapters
+var pluginSerializationAdapters = [];
+var hasPluginAdapters = false;
+//#endregion
+export { hasPluginAdapters, pluginSerializationAdapters };

package/dist/server/assets/_tanstack-start-manifest_v-DMytuIue.js

@@ -0,0 +1,188 @@
+//#region \0tanstack-start-manifest:v
+var tsrStartManifest = () => ({
+	routes: {
+		__root__: {
+			filePath: "/Users/astahmer/dev/alex/module-graph-viz/src/routes/__root.tsx",
+			children: [
+				"/",
+				"/compare",
+				"/configure",
+				"/explorer",
+				"/graph",
+				"/hierarchy",
+				"/imports",
+				"/summary",
+				"/trace",
+				"/treemap",
+				"/api/json-status",
+				"/api/modviz-bundle",
+				"/api/snapshot-history",
+				"/api/users/$userId"
+			],
+			assets: void 0,
+			preloads: [
+				"/assets/index-Dj_rhLdR.js",
+				"/assets/jsx-runtime-DWSWI4JT.js",
+				"/assets/modviz-data-BiRqoDI5.js",
+				"/assets/lazyRouteComponent-PTSyFp1J.js",
+				"/assets/trace-B67CM5s2.js",
+				"/assets/graph-CVzypIGU.js",
+				"/assets/compare-TOnoe1EP.js",
+				"/assets/explorer-C7NclVKg.js",
+				"/assets/hierarchy-iO7d4oSK.js",
+				"/assets/imports-CPggnrs-.js",
+				"/assets/treemap-Csroy8Gy.js"
+			]
+		},
+		"/": {
+			filePath: "/Users/astahmer/dev/alex/module-graph-viz/src/routes/index.tsx",
+			children: void 0,
+			assets: void 0,
+			preloads: [
+				"/assets/routes-DBtN8hrZ.js",
+				"/assets/utils-DkkZd0ys.js",
+				"/assets/modviz-layout-Do93E-IB.js",
+				"/assets/setup-view-j1o0TuZz.js",
+				"/assets/formatting-CiC0SYI8.js"
+			]
+		},
+		"/compare": {
+			filePath: "/Users/astahmer/dev/alex/module-graph-viz/src/routes/compare.tsx",
+			children: void 0,
+			assets: void 0,
+			preloads: [
+				"/assets/compare-K6jVFsiI.js",
+				"/assets/button-aOWckyNs.js",
+				"/assets/tooltip-B1VDU9HG.js",
+				"/assets/command-kkF7_wdz.js",
+				"/assets/utils-DkkZd0ys.js",
+				"/assets/modviz-layout-Do93E-IB.js",
+				"/assets/formatting-CiC0SYI8.js"
+			]
+		},
+		"/configure": {
+			filePath: "/Users/astahmer/dev/alex/module-graph-viz/src/routes/configure.tsx",
+			children: void 0,
+			assets: void 0,
+			preloads: [
+				"/assets/configure-DnlSnhtN.js",
+				"/assets/button-aOWckyNs.js",
+				"/assets/utils-DkkZd0ys.js",
+				"/assets/modviz-layout-Do93E-IB.js",
+				"/assets/check-C0EQe2S8.js",
+				"/assets/input-BCFMF0aR.js"
+			]
+		},
+		"/explorer": {
+			filePath: "/Users/astahmer/dev/alex/module-graph-viz/src/routes/explorer.tsx",
+			children: void 0,
+			assets: void 0,
+			preloads: [
+				"/assets/explorer-Xu2X6XXF.js",
+				"/assets/button-aOWckyNs.js",
+				"/assets/utils-DkkZd0ys.js",
+				"/assets/modviz-layout-Do93E-IB.js",
+				"/assets/chevron-down-DrspihmT.js",
+				"/assets/chevron-right-DIJHr8AN.js",
+				"/assets/import-display-D-jRyyjM.js",
+				"/assets/external-link-B9eNA-li.js",
+				"/assets/setup-view-j1o0TuZz.js",
+				"/assets/input-BCFMF0aR.js"
+			]
+		},
+		"/graph": {
+			filePath: "/Users/astahmer/dev/alex/module-graph-viz/src/routes/graph.tsx",
+			children: void 0,
+			assets: [{
+				tag: "link",
+				attrs: {
+					rel: "stylesheet",
+					href: "/assets/graph-command-menu-VWiiW3qy.css#",
+					type: "text/css"
+				}
+			}],
+			preloads: [
+				"/assets/graph-6Vr74V1k.js",
+				"/assets/button-aOWckyNs.js",
+				"/assets/portal-BgAm3V3j.js",
+				"/assets/floating-ui.dom-DLIT5tPE.js",
+				"/assets/graph-command-menu-D2MoVT2B.js",
+				"/assets/command-kkF7_wdz.js",
+				"/assets/utils-DkkZd0ys.js",
+				"/assets/modviz-layout-Do93E-IB.js",
+				"/assets/setup-view-j1o0TuZz.js",
+				"/assets/loading-state-CyC_hrTF.js",
+				"/assets/input-BCFMF0aR.js"
+			]
+		},
+		"/hierarchy": {
+			filePath: "/Users/astahmer/dev/alex/module-graph-viz/src/routes/hierarchy.tsx",
+			children: void 0,
+			assets: void 0,
+			preloads: [
+				"/assets/hierarchy-C8xxGb_u.js",
+				"/assets/modviz-layout-Do93E-IB.js",
+				"/assets/setup-view-j1o0TuZz.js",
+				"/assets/loading-state-CyC_hrTF.js"
+			]
+		},
+		"/imports": {
+			filePath: "/Users/astahmer/dev/alex/module-graph-viz/src/routes/imports.tsx",
+			children: void 0,
+			assets: void 0,
+			preloads: [
+				"/assets/imports-CodbPyUJ.js",
+				"/assets/button-aOWckyNs.js",
+				"/assets/modviz-layout-Do93E-IB.js",
+				"/assets/chevron-down-DrspihmT.js",
+				"/assets/import-display-D-jRyyjM.js",
+				"/assets/setup-view-j1o0TuZz.js",
+				"/assets/input-BCFMF0aR.js"
+			]
+		},
+		"/summary": {
+			filePath: "/Users/astahmer/dev/alex/module-graph-viz/src/routes/summary.tsx",
+			children: void 0,
+			assets: void 0,
+			preloads: [
+				"/assets/summary-D703Zh3x.js",
+				"/assets/modviz-layout-Do93E-IB.js",
+				"/assets/setup-view-j1o0TuZz.js",
+				"/assets/formatting-CiC0SYI8.js"
+			]
+		},
+		"/trace": {
+			filePath: "/Users/astahmer/dev/alex/module-graph-viz/src/routes/trace.tsx",
+			children: void 0,
+			assets: void 0,
+			preloads: [
+				"/assets/trace-Bwwdw3AM.js",
+				"/assets/button-aOWckyNs.js",
+				"/assets/utils-DkkZd0ys.js",
+				"/assets/modviz-layout-Do93E-IB.js",
+				"/assets/setup-view-j1o0TuZz.js",
+				"/assets/search-BYHxNrYn.js",
+				"/assets/input-BCFMF0aR.js"
+			]
+		},
+		"/treemap": {
+			filePath: "/Users/astahmer/dev/alex/module-graph-viz/src/routes/treemap.tsx",
+			children: void 0,
+			assets: void 0,
+			preloads: [
+				"/assets/treemap-BZf2shzY.js",
+				"/assets/button-aOWckyNs.js",
+				"/assets/portal-BgAm3V3j.js",
+				"/assets/tooltip-B1VDU9HG.js",
+				"/assets/utils-DkkZd0ys.js",
+				"/assets/colors-CQoWjU5E.js",
+				"/assets/modviz-layout-Do93E-IB.js",
+				"/assets/external-link-B9eNA-li.js",
+				"/assets/setup-view-j1o0TuZz.js"
+			]
+		}
+	},
+	clientEntry: "/assets/index-Dj_rhLdR.js"
+});
+//#endregion
+export { tsrStartManifest };