akanjs 2.2.4 → 2.2.6

package/server/akanApp.test.ts

@@ -1,130 +0,0 @@
-import { afterEach, describe, expect, test } from "bun:test";
-import { mkdtemp, rm } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import path from "node:path";
-import { AkanApp } from "./akanApp";
-import { makeAkanChildProxyHeaders } from "./akanAppHeaders";
-
-const tempRoots: string[] = [];
-
-const wait = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
-
-const waitFor = async <T>(fn: () => Promise<T | null>, timeoutMs = 5_000): Promise<T> => {
-  const started = Date.now();
-  while (Date.now() - started < timeoutMs) {
-    const value = await fn();
-    if (value) return value;
-    await wait(50);
-  }
-  throw new Error(`Timed out after ${timeoutMs}ms`);
-};
-
-afterEach(async () => {
-  await Promise.all(tempRoots.splice(0).map((root) => rm(root, { recursive: true, force: true })));
-});
-
-describe("makeAkanChildProxyHeaders", () => {
-  test("preserves public forwarded host and protocol for child requests", () => {
-    const req = new Request("http://akan-internal/", {
-      headers: {
-        connection: "keep-alive",
-        host: "internal.example",
-        "x-forwarded-for": "203.0.113.10",
-        "x-forwarded-host": "akanjs.com",
-        "x-forwarded-proto": "https",
-        "x-real-ip": "10.0.0.5",
-      },
-    });
-
-    const headers = makeAkanChildProxyHeaders(req, 2);
-
-    expect(headers.get("connection")).toBeNull();
-    expect(headers.get("host")).toBe("akan-child");
-    expect(headers.get("x-forwarded-for")).toBe("203.0.113.10, 10.0.0.5");
-    expect(headers.get("x-forwarded-host")).toBe("akanjs.com");
-    expect(headers.get("x-forwarded-proto")).toBe("https");
-    expect(headers.get("x-akan-child-idx")).toBe("2");
-  });
-
-  test("falls back to request host and protocol without upstream forwarded headers", () => {
-    const req = new Request("http://internal.example/", {
-      headers: {
-        host: "internal.example",
-      },
-    });
-
-    const headers = makeAkanChildProxyHeaders(req, 0);
-
-    expect(headers.get("x-forwarded-host")).toBe("internal.example");
-    expect(headers.get("x-forwarded-proto")).toBe("http");
-  });
-});
-
-describe("AkanApp", () => {
-  test("restarts only the crashed replica", async () => {
-    const root = await mkdtemp(path.join(tmpdir(), "akan-app-restart-"));
-    tempRoots.push(root);
-    const counterPath = path.join(root, "counter.txt");
-    const serverPath = path.join(root, "server.ts");
-    const runtimeDir = path.join(root, "runtime");
-    const port = 24_000 + Math.floor(Math.random() * 10_000);
-
-    await Bun.write(
-      serverPath,
-      `
-        const counterPath = ${JSON.stringify(counterPath)};
-        export const server = {
-          async start() {
-            const file = Bun.file(counterPath);
-            const previous = await file.exists() ? Number(await file.text()) : 0;
-            const next = previous + 1;
-            await Bun.write(counterPath, String(next));
-            const http = Bun.serve({
-              unix: process.env.AKAN_CHILD_SOCKET,
-              fetch() { return new Response("ok"); },
-            });
-            process.on("message", (message) => {
-              if (!message || typeof message !== "object") return;
-              if (message.type === "health.ping") {
-                process.send?.({ type: "health.pong", nonce: message.nonce, sentAt: message.sentAt, pid: process.pid });
-              }
-              if (message.type === "shutdown") {
-                http.stop(true);
-                process.exit(0);
-              }
-            });
-            process.send?.({
-              type: "ready",
-              pid: process.pid,
-              replicaIdx: Number(process.env.AKAN_REPLICA_IDX ?? 0),
-              role: process.env.SERVER_MODE ?? "all",
-              upstream: { type: "unix", socketPath: process.env.AKAN_CHILD_SOCKET },
-              healthPath: "/_akan/app/child-health",
-            });
-            if (next === 1) setTimeout(() => process.exit(1), 50);
-          },
-        };
-      `,
-    );
-
-    const app = new AkanApp(serverPath, { replica: 1, runtimeDir, port });
-    const running = app.start();
-    try {
-      const health = await waitFor(async () => {
-        const res = await fetch(`http://127.0.0.1:${port}/_akan/app/health`).catch(() => null);
-        if (!res?.ok) return null;
-        const body = (await res.json()) as {
-          children: Array<{ ready: boolean; restartCount: number; restartPending: boolean }>;
-        };
-        const child = body.children[0];
-        return child?.ready && child.restartCount > 0 && !child.restartPending ? body : null;
-      }, 6_000);
-
-      expect(health.children[0]?.restartCount).toBeGreaterThanOrEqual(1);
-      expect(await Bun.file(counterPath).text()).toBe("2");
-    } finally {
-      await app.stop();
-      await Promise.race([running, wait(1_000)]);
-    }
-  });
-});

package/server/akanServer.test.ts

@@ -1,157 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { mkdtemp, rm } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import type { BackendEnv } from "akanjs/base";
-
-const createEnv = (tmp: string) =>
-  ({
-    repoName: "akan",
-    serveDomain: "example.com",
-    appName: "serverGet",
-    environment: "local",
-    operationMode: "local",
-    tunnelUsername: "root",
-    tunnelPassword: "akan",
-    workspaceRoot: tmp,
-    database: {
-      sqlite: {
-        filePath: join(tmp, "akan.db"),
-        journalMode: "WAL",
-        busyTimeoutMs: 1000,
-        synchronous: "NORMAL",
-        foreignKeys: true,
-      },
-    },
-    solid: {
-      filePath: join(tmp, "solid.db"),
-      journalMode: "WAL",
-      busyTimeoutMs: 1000,
-      synchronous: "NORMAL",
-      cleanupIntervalMs: 60_000,
-      queuePollIntervalMs: 60_000,
-      queueLeaseMs: 30_000,
-    },
-  }) satisfies BackendEnv & { workspaceRoot: string };
-
-const setAkanEnv = () => {
-  process.env.AKAN_PUBLIC_APP_NAME = "serverGet";
-  process.env.AKAN_PUBLIC_REPO_NAME = "akan";
-  process.env.AKAN_PUBLIC_SERVE_DOMAIN = "example.com";
-  process.env.AKAN_PUBLIC_ENV = "local";
-  process.env.AKAN_PUBLIC_OPERATION_MODE = "local";
-  process.env.SERVER_MODE = "all";
-  process.env.NODE_ENV = "test";
-};
-
-const loadRuntime = async () => {
-  const [
-    { SolidPubSub, WebsocketAdaptorRole },
-    { AkanLib },
-    { AkanOption },
-    { AkanServer },
-    {
-      ServerResolverTestEndpoint,
-      ServerResolverTestInternal,
-      ServerResolverTestServerSignal,
-      ServerResolverTestService,
-      ServerResolverTestSlice,
-      serverResolverTestConstant,
-      serverResolverTestDatabase,
-      serverResolverTestServiceModel,
-    },
-  ] = await Promise.all([
-    import("akanjs/service"),
-    import("./akanLib"),
-    import("./akanOption"),
-    import("./akanServer"),
-    import("./resolver/resolver.contract.fixture"),
-  ]);
-
-  const createLib = () =>
-    new AkanLib("serverGetTest", {
-      databases: [
-        {
-          constant: serverResolverTestConstant,
-          database: serverResolverTestDatabase,
-          service: serverResolverTestServiceModel,
-          signal: {
-            endpoint: ServerResolverTestEndpoint,
-            slice: ServerResolverTestSlice,
-            internal: ServerResolverTestInternal,
-            server: ServerResolverTestServerSignal,
-          },
-        },
-      ],
-      services: [],
-      scalars: [],
-      option: new AkanOption(),
-    });
-
-  return {
-    SolidPubSub,
-    WebsocketAdaptorRole,
-    AkanServer,
-    ServerResolverTestServerSignal,
-    ServerResolverTestService,
-    createLib,
-  };
-};
-
-describe("AkanServer DI lookup", () => {
-  test("gets service, server signal, and adaptor instances", async () => {
-    setAkanEnv();
-    const {
-      SolidPubSub,
-      WebsocketAdaptorRole,
-      AkanServer,
-      ServerResolverTestServerSignal,
-      ServerResolverTestService,
-      createLib,
-    } = await loadRuntime();
-
-    const tmp = await mkdtemp(join(tmpdir(), "akan-server-get-"));
-    const server = new AkanServer("serverGet", createEnv(tmp), "all", createLib());
-
-    try {
-      await server.start({ listen: false });
-
-      const serviceByClass = server.get(ServerResolverTestService);
-      expect(serviceByClass).toBe(server.getService("serverResolverTestItem"));
-      expect(server.getService("serverResolverTestItemService")).toBe(serviceByClass);
-
-      const signalByClass = server.get(ServerResolverTestServerSignal);
-      expect(server.getSignal("serverResolverTestItem")).toBe(signalByClass);
-      expect(server.getSignal("serverResolverTestItemSignal")).toBe(signalByClass);
-
-      const adaptorByClass = server.get(SolidPubSub);
-      expect(server.get(WebsocketAdaptorRole)).toBe(adaptorByClass);
-      expect(server.getAdaptor("solidPubsub")).toBe(adaptorByClass);
-    } finally {
-      await server.stop();
-      await rm(tmp, { recursive: true, force: true });
-    }
-  });
-
-  test("throws clear errors before initialization and for missing dependencies", async () => {
-    setAkanEnv();
-    const { AkanServer, createLib } = await loadRuntime();
-    const tmp = await mkdtemp(join(tmpdir(), "akan-server-get-"));
-    const server = new AkanServer("serverGet", createEnv(tmp), "all", createLib());
-
-    try {
-      expect(() => server.getService("serverResolverTestItem")).toThrow(
-        'Service "serverResolverTestItem" is not initialized while AkanServer status is "stopped"',
-      );
-
-      await server.start({ listen: false });
-
-      expect(() => server.getService("missing")).toThrow('Service "missing" is not registered.');
-      expect(() => server.getSignal("missing")).toThrow('Server signal "missingSignal" is not registered.');
-      expect(() => server.getAdaptor("missing")).toThrow('Adaptor "missing" is not registered.');
-    } finally {
-      await server.stop();
-      await rm(tmp, { recursive: true, force: true });
-    }
-  });
-});

package/server/artifact/routeClientCache.test.ts

@@ -1,265 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { RouteClientCache } from "./routeClientCache";
-import type { RoutesManifest } from "./routesManifestStore";
-
-const emptySsrManifest = { moduleLoading: null, moduleMap: {} };
-
-describe("RouteClientCache", () => {
-  test("seeds existing manifests and returns isolated snapshots", async () => {
-    const manifest: RoutesManifest = {
-      routeIds: ["/seeded"],
-      clientManifest: {
-        "apps/demo/Page.tsx#default": {
-          id: "/_akan/client/page.js",
-          chunks: ["/_akan/client/page.js"],
-          name: "default",
-          async: true,
-        },
-      },
-      ssrManifest: {
-        moduleLoading: null,
-        moduleMap: { "/_akan/client/page.js": { default: { id: "page.ssr.js", chunks: [], name: "default" } } },
-      },
-      knownEntries: ["/repo/apps/demo/Page.tsx"],
-    };
-    const cache = new RouteClientCache({
-      buildRoute: async () => {
-        throw new Error("seeded routes should not rebuild");
-      },
-    });
-
-    cache.seed(manifest);
-    await cache.ensure("/seeded", []);
-    const snapshot = cache.snapshot();
-    snapshot.knownEntries.add("/mutated");
-
-    expect(cache.snapshot().knownEntries.has("/mutated")).toBe(false);
-    expect(cache.snapshot().clientManifest).toEqual(manifest.clientManifest);
-  });
-
-  test("deduplicates concurrent builds and retries failures", async () => {
-    let attempts = 0;
-    const cache = new RouteClientCache({
-      buildRoute: async (routeId, info) => {
-        attempts += 1;
-        if (attempts === 1) throw new Error("boom");
-        return {
-          manifestDelta: {
-            [`${routeId}#default`]: {
-              id: `/_akan/client/${attempts}.js`,
-              chunks: [`/_akan/client/${attempts}.js`],
-              name: "default",
-            },
-          },
-          ssrManifestDelta: emptySsrManifest,
-          newEntries: [...info.knownEntries, `/repo${routeId}.tsx`],
-          clientDeps: [],
-        };
-      },
-    });
-
-    await expect(cache.ensure("/retry", [])).rejects.toThrow("boom");
-    const [first, second] = await Promise.all([cache.ensure("/retry", []), cache.ensure("/retry", [])]);
-
-    expect(first).toBe(second);
-    expect(attempts).toBe(2);
-    expect(cache.snapshot().knownEntries.has("/repo/retry.tsx")).toBe(true);
-  });
-
-  test("invalidates built routes, ignores stale builds, and clears generations", async () => {
-    let resolveBuild:
-      | ((value: Awaited<ReturnType<Parameters<typeof RouteClientCache>[0]["buildRoute"]>>) => void)
-      | null = null;
-    const cache = new RouteClientCache({
-      buildRoute: async (routeId, { generation }) =>
-        await new Promise((resolve) => {
-          resolveBuild = () =>
-            resolve({
-              manifestDelta: { [`${routeId}#${generation}`]: { id: "stale.js", chunks: [], name: "default" } },
-              ssrManifestDelta: emptySsrManifest,
-              newEntries: [`/repo/${routeId}-${generation}.tsx`],
-              clientDeps: [],
-            });
-        }),
-    });
-
-    const pending = cache.ensure("/slow", []);
-    expect(cache.clear()).toEqual([]);
-    resolveBuild?.({ manifestDelta: {}, ssrManifestDelta: emptySsrManifest, newEntries: [], clientDeps: [] });
-    await pending;
-
-    expect(cache.snapshot().clientManifest).toEqual({});
-    expect(cache.snapshot().knownEntries.size).toBe(0);
-
-    const immediate = new RouteClientCache({
-      buildRoute: async (routeId) => ({
-        manifestDelta: { [routeId]: { id: "fresh.js", chunks: [], name: "default" } },
-        ssrManifestDelta: emptySsrManifest,
-        newEntries: [`/repo/${routeId}.tsx`],
-        clientDeps: [],
-      }),
-    });
-    await immediate.ensure("/a", []);
-    await immediate.ensure("/b", []);
-    expect(immediate.invalidate((routeId) => routeId === "/a")).toEqual(["/a"]);
-    expect(immediate.snapshot().knownEntries).toEqual(new Set(["/repo//a.tsx", "/repo//b.tsx"]));
-    expect(immediate.clear().sort()).toEqual(["/b"]);
-    expect(immediate.snapshot().generation).toBe(2);
-  });
-
-  test("client entry invalidation drops only stale entries and manifest rows", async () => {
-    const cache = new RouteClientCache({
-      buildRoute: async (routeId) => ({
-        manifestDelta: {
-          [`/repo${routeId}.tsx#default`]: {
-            id: `/_akan/client${routeId}.js`,
-            chunks: [`/_akan/client${routeId}.js`, `/_akan/client/chunk${routeId}.js`],
-            name: "default",
-          },
-        },
-        ssrManifestDelta: {
-          moduleLoading: null,
-          moduleMap: {
-            [`/_akan/client${routeId}.js`]: {
-              default: { id: `ssr${routeId}.js`, chunks: [], name: "default" },
-            },
-          },
-        },
-        newEntries: [`/repo${routeId}.tsx`],
-        clientDeps: [],
-      }),
-    });
-    await cache.ensure("/a", []);
-    await cache.ensure("/b", []);
-
-    expect(
-      cache.invalidateClientEntries({
-        routePredicate: (routeId) => routeId === "/a",
-        staleEntries: ["/repo/a.tsx"],
-      }),
-    ).toEqual(["/a"]);
-
-    const snapshot = cache.snapshot();
-    expect(snapshot.knownEntries).toEqual(new Set(["/repo/b.tsx"]));
-    expect(snapshot.clientManifest["/repo/a.tsx#default"]).toBeUndefined();
-    expect(snapshot.clientManifest["/repo/b.tsx#default"]).toBeDefined();
-    expect(snapshot.ssrManifest.moduleMap["/_akan/client/a.js"]).toBeUndefined();
-    expect(snapshot.ssrManifest.moduleMap["/_akan/client/b.js"]).toBeDefined();
-  });
-
-  test("route invalidation preserves known entries and manifest rows for server-only edits", async () => {
-    const cache = new RouteClientCache({
-      buildRoute: async (routeId) => ({
-        manifestDelta: {
-          [`/repo${routeId}.tsx#default`]: {
-            id: `/_akan/client${routeId}.js`,
-            chunks: [`/_akan/client${routeId}.js`],
-            name: "default",
-          },
-        },
-        ssrManifestDelta: emptySsrManifest,
-        newEntries: [`/repo${routeId}.tsx`],
-        clientDeps: [],
-      }),
-    });
-    await cache.ensure("/a", []);
-
-    expect(cache.invalidate((routeId) => routeId === "/a")).toEqual(["/a"]);
-    const snapshot = cache.snapshot();
-    expect(snapshot.knownEntries).toEqual(new Set(["/repo/a.tsx"]));
-    expect(snapshot.clientManifest["/repo/a.tsx#default"]).toBeDefined();
-  });
-
-  test("client entry invalidation also removes rows by stale chunk urls", async () => {
-    const cache = new RouteClientCache({
-      buildRoute: async () => ({
-        manifestDelta: {
-          "/repo/Entry.tsx#default": {
-            id: "/_akan/client/entry.js",
-            chunks: ["/_akan/client/entry.js", "/_akan/client/shared.js"],
-            name: "default",
-          },
-          "/repo/Entry.tsx#Named": {
-            id: "/_akan/client/shared.js",
-            chunks: ["/_akan/client/shared.js"],
-            name: "Named",
-          },
-          "/repo/Other.tsx#default": {
-            id: "/_akan/client/other.js",
-            chunks: ["/_akan/client/other.js"],
-            name: "default",
-          },
-        },
-        ssrManifestDelta: {
-          moduleLoading: null,
-          moduleMap: {
-            "/_akan/client/entry.js": {
-              default: { id: "entry.ssr.js", chunks: [], name: "default" },
-            },
-            "/_akan/client/shared.js": {
-              Named: { id: "named.ssr.js", chunks: [], name: "Named" },
-            },
-            "/_akan/client/other.js": {
-              default: { id: "other.ssr.js", chunks: [], name: "default" },
-            },
-          },
-        },
-        newEntries: ["/repo/Entry.tsx", "/repo/Other.tsx"],
-        clientDeps: [],
-      }),
-    });
-    await cache.ensure("/a", []);
-
-    cache.invalidateClientEntries({
-      routePredicate: (routeId) => routeId === "/a",
-      staleEntries: ["/repo/Entry.tsx"],
-    });
-
-    const snapshot = cache.snapshot();
-    expect(Object.keys(snapshot.clientManifest).sort()).toEqual(["/repo/Other.tsx#default"]);
-    expect(Object.keys(snapshot.ssrManifest.moduleMap).sort()).toEqual(["/_akan/client/other.js"]);
-    expect(snapshot.knownEntries).toEqual(new Set(["/repo/Other.tsx"]));
-  });
-
-  test("shared entries can be discovered by later routes without rebuilding the shared entry", async () => {
-    const builds: Array<{ routeId: string; knownEntries: string[] }> = [];
-    const cache = new RouteClientCache({
-      buildRoute: async (routeId, { knownEntries }) => {
-        builds.push({ routeId, knownEntries: [...knownEntries].sort() });
-        if (routeId === "/a") {
-          return {
-            manifestDelta: {
-              "/repo/Shared.tsx#default": {
-                id: "/_akan/client/shared.js",
-                chunks: ["/_akan/client/shared.js"],
-                name: "default",
-              },
-            },
-            ssrManifestDelta: emptySsrManifest,
-            newEntries: ["/repo/Shared.tsx"],
-            discoveredEntries: ["/repo/Shared.tsx"],
-            clientDeps: ["/repo/Shared.tsx"],
-            clientDepsByEntry: { "/repo/Shared.tsx": ["/repo/Shared.tsx"] },
-          };
-        }
-        return {
-          manifestDelta: {},
-          ssrManifestDelta: emptySsrManifest,
-          newEntries: [],
-          discoveredEntries: ["/repo/Shared.tsx"],
-          clientDeps: [],
-          clientDepsByEntry: {},
-        };
-      },
-    });
-
-    await cache.ensure("/a", []);
-    await cache.ensure("/b", []);
-
-    expect(builds).toEqual([
-      { routeId: "/a", knownEntries: [] },
-      { routeId: "/b", knownEntries: ["/repo/Shared.tsx"] },
-    ]);
-    expect(cache.snapshot().knownEntries).toEqual(new Set(["/repo/Shared.tsx"]));
-  });
-});

package/server/artifact/routeSeedIndex.test.ts

@@ -1,56 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { RouteSeedIndexStore } from "./routeSeedIndexStore";
-
-describe("route seed index artifact paths", () => {
-  test("restores relative seed paths from the artifact directory", () => {
-    const artifactDir = "/repo/dist/apps/akan/.akan/artifact";
-    const normalized = RouteSeedIndexStore.normalize(
-      {
-        entries: [
-          {
-            routeId: "/profile",
-            pattern: "/profile",
-            seeds: ["../generated/implicit-root-layout.tsx", "../../../../../apps/akan/page/profile.tsx"],
-          },
-        ],
-        globalLayoutFiles: ["../generated/implicit-root-layout.tsx"],
-      },
-      artifactDir,
-    );
-
-    expect(normalized.entries[0]?.seeds).toEqual([
-      "/repo/dist/apps/akan/.akan/generated/implicit-root-layout.tsx",
-      "/repo/apps/akan/page/profile.tsx",
-    ]);
-    expect(normalized.globalLayoutFiles).toEqual(["/repo/dist/apps/akan/.akan/generated/implicit-root-layout.tsx"]);
-  });
-
-  test("restores slim production seed index defaults", () => {
-    const normalized = RouteSeedIndexStore.normalize(
-      {
-        entries: [{ routeId: "/:lang/profile" }],
-      },
-      "/repo/dist/apps/akan/.akan/artifact",
-    );
-
-    expect(normalized).toEqual({
-      entries: [{ routeId: "/:lang/profile", pattern: "/:lang/profile", seeds: [] }],
-      globalLayoutFiles: [],
-    });
-    expect(RouteSeedIndexStore.match("/ko/profile", normalized.entries)?.entry.routeId).toBe("/:lang/profile");
-  });
-
-  test("finds the nearest route seed prefix for unmatched layout fallbacks", () => {
-    const entries = [
-      { routeId: "/:lang/blog", pattern: "/:lang/blog", seeds: ["blog-layout"] },
-      { routeId: "/:lang/blog/benchmark", pattern: "/:lang/blog/benchmark", seeds: ["benchmark-page"] },
-      { routeId: "/:lang/docs", pattern: "/:lang/docs", seeds: ["docs-layout"] },
-    ];
-
-    const matched = RouteSeedIndexStore.matchPrefix("/ko/blog/missing", entries);
-
-    expect(matched?.entry.routeId).toBe("/:lang/blog");
-    expect(matched?.params).toEqual({ lang: "ko" });
-    expect(RouteSeedIndexStore.matchPrefix("/ko/unknown/missing", entries)).toBeNull();
-  });
-});

package/server/artifact/routesManifest.test.ts

@@ -1,64 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { type RoutesManifest, RoutesManifestStore } from "./routesManifestStore";
-
-describe("routes manifest artifact paths", () => {
-  test("serializes file-system paths relative to the artifact directory and restores them", () => {
-    const artifactDir = "/repo/dist/apps/akan/.akan/artifact";
-    const clientEntry = "apps/akan/ui/ProfileCard.tsx#default";
-    const knownEntry = "/repo/apps/akan/ui/ProfileCard.tsx";
-    const ssrEntry = "/repo/dist/apps/akan/.akan/artifact/client-ssr/ProfileCard-abc.js";
-    const manifest: RoutesManifest = {
-      routeIds: ["/profile"],
-      clientManifest: {
-        [clientEntry]: {
-          id: "/_akan/client/abc.js",
-          chunks: ["/_akan/client/abc.js", "/_akan/client/chunks/def.js"],
-          name: "default",
-          async: true,
-        },
-      },
-      ssrManifest: {
-        moduleLoading: null,
-        moduleMap: {
-          "/_akan/client/abc.js": {
-            default: {
-              id: ssrEntry,
-              chunks: [ssrEntry, ssrEntry],
-              name: "default",
-              async: true,
-            },
-          },
-        },
-      },
-      knownEntries: [knownEntry],
-    };
-
-    const serialized = RoutesManifestStore.serialize(manifest, artifactDir);
-
-    expect(Object.keys(serialized.clientManifest)).toEqual(["apps/akan/ui/ProfileCard.tsx#default"]);
-    expect(serialized.clientManifest["apps/akan/ui/ProfileCard.tsx#default"]?.id).toBe("/_akan/client/abc.js");
-    expect(serialized.ssrManifest.moduleMap["/_akan/client/abc.js"]?.default.id).toBe("client-ssr/ProfileCard-abc.js");
-    expect(serialized.knownEntries).toEqual(["../../../../../apps/akan/ui/ProfileCard.tsx"]);
-    expect(JSON.stringify(serialized)).not.toContain("/repo/");
-
-    expect(RoutesManifestStore.normalize(serialized, artifactDir)).toEqual({
-      ...manifest,
-      clientManifest: serialized.clientManifest,
-      knownEntries: manifest.knownEntries,
-    });
-  });
-
-  test("normalizes manifests without production-only known entries", () => {
-    const artifactDir = "/repo/dist/apps/akan/.akan/artifact";
-    const normalized = RoutesManifestStore.normalize(
-      {
-        routeIds: ["/profile"],
-        clientManifest: {},
-        ssrManifest: { moduleLoading: null, moduleMap: {} },
-      },
-      artifactDir,
-    );
-
-    expect(normalized.knownEntries).toEqual([]);
-  });
-});