ignotum 0.0.16 → 0.0.18

package/src/cli/build/asset-names.ts

@@ -0,0 +1,190 @@
+import MagicString from "magic-string";
+import remapping from "@jridgewell/remapping";
+import { createHash } from "node:crypto";
+import { posix } from "node:path";
+import { Graph, Schema } from "effect";
+import { parseSync } from "oxc-parser";
+
+export interface ClientOutputChunk {
+  readonly fileName: string;
+  readonly code: string;
+  readonly sourceMap?: string;
+  readonly imports: readonly string[];
+  readonly dynamicImports: readonly string[];
+  readonly modules: Readonly<Record<string, { readonly renderedLength: number }>>;
+}
+
+export class AssetNamingError extends Schema.TaggedError<AssetNamingError>()("AssetNamingError", {
+  message: Schema.String,
+}) {}
+
+/** The bundler must merge these source groups before assigning final-byte hashes. */
+export const cyclicChunkGroups = (
+  chunks: readonly ClientOutputChunk[],
+): readonly (readonly string[])[] => {
+  const ids = new Map<string, Graph.NodeIndex>();
+  const byIndex = new Map<Graph.NodeIndex, ClientOutputChunk>();
+  const graph = Graph.directed<string, void>((mutable) => {
+    for (const chunk of chunks) {
+      const index = Graph.addNode(mutable, chunk.fileName);
+      ids.set(chunk.fileName, index);
+      byIndex.set(index, chunk);
+    }
+    for (const chunk of chunks) {
+      for (const dependency of [...chunk.imports, ...chunk.dynamicImports]) {
+        const target = ids.get(dependency);
+        if (target !== undefined)
+          Graph.addEdge(mutable, ids.get(chunk.fileName)!, target, undefined);
+      }
+    }
+  });
+  return Graph.stronglyConnectedComponents(graph)
+    .filter((component) => component.length > 1)
+    .map((component) =>
+      [...new Set(component.flatMap((index) => Object.keys(byIndex.get(index)!.modules)))].sort(),
+    );
+};
+
+export interface NamedClientChunk {
+  readonly fileName: string;
+  readonly code: string;
+  readonly sha256: string;
+  readonly sourceMap?: string;
+}
+
+/** Call only after CSS/media URLs and chunk grouping have been finalized. */
+export const nameClientChunks = (
+  chunks: readonly ClientOutputChunk[],
+  entry: string,
+): ReadonlyMap<string, NamedClientChunk> => {
+  if (cyclicChunkGroups(chunks).length !== 0) {
+    throw AssetNamingError.make({
+      message: "Merge cyclic emitted chunks before hashing their bytes.",
+    });
+  }
+  const sources = new Map(chunks.map((chunk) => [chunk.fileName, chunk]));
+  const named = new Map<string, NamedClientChunk>();
+  const visiting = new Set<string>();
+  const name = (fileName: string): NamedClientChunk => {
+    const found = named.get(fileName);
+    if (found !== undefined) return found;
+    const chunk = sources.get(fileName);
+    if (chunk === undefined || visiting.has(fileName)) {
+      throw AssetNamingError.make({ message: `Unresolved or cyclic app chunk '${fileName}'.` });
+    }
+    visiting.add(fileName);
+    const parsed = parseSync(fileName, chunk.code);
+    if (parsed.errors.length > 0)
+      throw AssetNamingError.make({ message: `Invalid app chunk '${fileName}'.` });
+    const requests = [
+      ...parsed.module.staticImports.map((item) => item.moduleRequest),
+      ...parsed.module.staticExports.flatMap((item) =>
+        item.entries.flatMap((item) => (item.moduleRequest === null ? [] : [item.moduleRequest])),
+      ),
+      ...parsed.module.dynamicImports.map((item) => {
+        const expression = parseSync(
+          "import.js",
+          chunk.code.slice(item.moduleRequest.start, item.moduleRequest.end),
+        ).program.body[0];
+        const value =
+          expression?.type === "ExpressionStatement" ? expression.expression : undefined;
+        const address =
+          value?.type === "Literal"
+            ? value.value
+            : value?.type === "TemplateLiteral" &&
+                value.expressions.length === 0 &&
+                value.quasis.length === 1
+              ? value.quasis[0]!.value.cooked
+              : undefined;
+        if (address === undefined)
+          throw AssetNamingError.make({
+            message: `App dynamic import in '${fileName}' must have a literal module address.`,
+          });
+        return { ...item.moduleRequest, value: Schema.decodeUnknownSync(Schema.String)(address) };
+      }),
+    ];
+    const edited = new MagicString(chunk.code);
+    const replacements = new Map<number, { readonly end: number; readonly text: string }>();
+    for (const request of requests) {
+      if (!request.value.startsWith(".")) continue;
+      const dependency = posix.normalize(posix.join(posix.dirname(fileName), request.value));
+      const target = name(dependency);
+      if (dependency === entry)
+        throw AssetNamingError.make({
+          message: "An app dependency cannot import the publication entry.",
+        });
+      const relative = posix.relative(posix.dirname(fileName), target.fileName);
+      replacements.set(request.start, {
+        end: request.end,
+        text: JSON.stringify(relative.startsWith(".") ? relative : `./${relative}`),
+      });
+    }
+    for (const [start, replacement] of [...replacements].sort(([a], [b]) => b - a)) {
+      edited.overwrite(start, replacement.end, replacement.text);
+    }
+    const code = edited.toString();
+    const sha256 = createHash("sha256").update(code).digest("hex");
+    const outputName =
+      fileName === entry ? "entry.js" : fileName.replace(/\.(?:m?js)$/, `-${sha256}.js`);
+    if (fileName !== entry && outputName === fileName)
+      throw AssetNamingError.make({
+        message: `App chunk '${fileName}' must have a JavaScript extension.`,
+      });
+    const sourceMap =
+      chunk.sourceMap === undefined
+        ? undefined
+        : remapping(
+            [edited.generateMap({ hires: true, source: fileName }).toString(), chunk.sourceMap],
+            () => null,
+          ).toString();
+    const output = { fileName: outputName, code, sha256, sourceMap };
+    const collision = [...named.values()].find(
+      (other) => other.fileName === outputName && other.code !== code,
+    );
+    if (collision !== undefined)
+      throw AssetNamingError.make({ message: `Conflicting public path '${outputName}'.` });
+    named.set(fileName, output);
+    visiting.delete(fileName);
+    return output;
+  };
+  for (const chunk of chunks) name(chunk.fileName);
+  return named;
+};
+
+/** Group source cycles before rendering so final-byte dependency hashing terminates. */
+export const clientCycleGroupsPlugin = (appDirectory: string): import("vite").Plugin => {
+  const groups = new Map<string, string>();
+  return {
+    name: "ignotum:client-cycle-groups",
+    buildEnd() {
+      groups.clear();
+      const sources = [...this.getModuleIds()].flatMap((id) => {
+        const info = this.getModuleInfo(id);
+        return info === null
+          ? []
+          : [
+              {
+                fileName: id,
+                code: "",
+                imports: info.importedIds,
+                dynamicImports: info.dynamicallyImportedIds,
+                modules: { [id]: { renderedLength: 1 } },
+              },
+            ];
+      });
+      for (const ids of cyclicChunkGroups(sources)) {
+        const identity = ids
+          .map((id) => posix.relative(appDirectory.replaceAll("\\", "/"), id.replaceAll("\\", "/")))
+          .sort();
+        const name = `cycle-${createHash("sha256").update(JSON.stringify(identity)).digest("hex").slice(0, 16)}`;
+        for (const id of ids) groups.set(id, name);
+      }
+    },
+    outputOptions(options) {
+      return {
+        ...options,
+        codeSplitting: { groups: [{ name: (id: string) => groups.get(id) ?? null }] },
+      };
+    },
+  };
+};

package/src/cli/build/managed-client.ts

@@ -1,6 +1,6 @@
 import { createHash } from "node:crypto";
 import { fileURLToPath } from "node:url";
-import { Effect, FileSystem, Option, Path, Predicate, Schema } from "effect";
+import { Effect, FileSystem, Option, Path, Schema } from "effect";
 import tailwindcss from "@tailwindcss/vite";
 import { defaultClientConditions, normalizePath, type Plugin } from "vite";
 import {
@@ -16,7 +16,9 @@ import { InvalidClientFile } from "../client-config.js";
 import { clientStylesSource } from "../client-styles.js";
 import { createImageAssetsPlugin } from "../image-assets.js";
 import { managedClientBoundariesPlugin } from "../managed-client-boundaries.js";
-import { managedPreactPeerPlugin } from "../managed-exports.js";
+import { platformImportsPlugin } from "@ignotum/platform/compiler";
+import { compilerExports } from "@ignotum/platform/compiler-exports";
+import { clientCycleGroupsPlugin, nameClientChunks } from "./asset-names.js";
 import { moduleBoundariesPlugin } from "../module-boundaries.js";
 import { generateClientRoutes } from "../route-codegen.js";
 import { InvalidBuildOutput, runViteBuild, sourceMapPathTransform } from "./artifact.js";
@@ -38,14 +40,7 @@ interface ClientChunk {
 
 const literal = Schema.encodeSync(Schema.fromJsonString(Schema.String));
 const globalStylesId = "virtual:ignotum/managed-global.css";
-
-const stylesheetFileName = (source: string | Uint8Array): string => {
-  // Vite removes its internal hash-update marker before writing CSS assets.
-  const finalSource = Predicate.isString(source)
-    ? source.replace(/\/\*\$vite\$:\d+\*\//, "")
-    : source;
-  return `assets/${createHash("sha256").update(finalSource).digest("hex")}/style.css`;
-};
+const globalEntryId = "virtual:ignotum/managed-global.js";
 
 /** Compile route definitions and app dependencies without embedding browser runtime code. */
 export const buildManagedClient = Effect.fn("Deploy.buildManagedClient")(function* (
@@ -74,16 +69,34 @@ export const buildManagedClient = Effect.fn("Deploy.buildManagedClient")(functio
   }
   const discovery = yield* generateClientRoutes(appDirectory);
   const stage = yield* fs.makeTempDirectoryScoped({ prefix: "ignotum-managed-client-" });
-  const images = yield* createImageAssetsPlugin(appDirectory);
+  const images = yield* createImageAssetsPlugin(appDirectory, true);
   const boundaries = yield* moduleBoundariesPlugin("Client", appDirectory);
-  const platform = yield* managedClientBoundariesPlugin(appDirectory);
-  const peers = yield* managedPreactPeerPlugin({ resolvePeer: (specifier) => specifier });
+  const platform = yield* managedClientBoundariesPlugin(appDirectory, true);
   const entrySources = new Map<string, string>();
   const input: Record<string, string> = {};
-  input.global = globalStylesId;
+  input.global = globalEntryId;
   const sourceEntries = new Map<AppModuleId, string>();
-  for (const [index, module] of discovery.modules.entries()) {
-    const name = `${module.kind}-${index}`;
+  const segmentName = (segment: string): string => {
+    const escape = (value: string) =>
+      value.replace(/[^a-zA-Z0-9.-]/g, (value) => `_${value.codePointAt(0)!.toString(16)}_`);
+    const parameter = /^\[([^\]]+)\]$/.exec(segment);
+    return parameter ? `_param_${escape(parameter[1]!)}` : escape(segment);
+  };
+  for (const module of discovery.modules) {
+    const relative = normalizePath(
+      path.relative(path.join(appDirectory, "client"), module.path),
+    ).replace(/\.[^.]+$/, "");
+    const ownership =
+      module.kind === "layout"
+        ? path.dirname(relative) === "."
+          ? "root"
+          : normalizePath(path.dirname(relative))
+        : relative;
+    const name = `${module.kind === "route" ? "routes" : "layouts"}/${ownership.split("/").map(segmentName).join("/")}`;
+    if (Object.hasOwn(input, name))
+      return yield* InvalidBuildOutput.make({
+        message: `Conflicting client module ownership '${name}'.`,
+      });
     const id = `virtual:ignotum/managed-client/${name}`;
     input[name] = id;
     sourceEntries.set(module.id, `${name}.mjs`);
@@ -115,9 +128,11 @@ export const buildManagedClient = Effect.fn("Deploy.buildManagedClient")(functio
     name: "ignotum:managed-client-entries",
     enforce: "post",
     resolveId(id) {
-      if (id === globalStylesId || entrySources.has(`\0${id}`)) return `\0${id}`;
+      if (id === globalStylesId || id === globalEntryId || entrySources.has(`\0${id}`))
+        return `\0${id}`;
     },
     load(id) {
+      if (id === `\0${globalEntryId}`) return `import ${literal(globalStylesId)};`;
       if (id === `\0${globalStylesId}`) return clientStylesSource;
       return entrySources.get(id);
     },
@@ -139,7 +154,13 @@ export const buildManagedClient = Effect.fn("Deploy.buildManagedClient")(functio
           isEntry: item.isEntry,
         });
         if (item.map === null) {
-          if (Object.values(item.modules).some((module) => module.renderedLength > 0))
+          const applicationRoot = `${normalizePath(appDirectory)}/`;
+          if (
+            Object.entries(item.modules).some(
+              ([id, module]) =>
+                normalizePath(id).startsWith(applicationRoot) && module.renderedLength > 0,
+            )
+          )
             this.error(`Missing source map for app implementation '${item.fileName}'.`);
           continue;
         }
@@ -163,7 +184,7 @@ export const buildManagedClient = Effect.fn("Deploy.buildManagedClient")(functio
       "import.meta.env.DEV": "false",
       "import.meta.env.PROD": "true",
     },
-    base: "/_ignotum/",
+    base: "/_ignotum/assets/",
     oxc: { jsx: { importSource: "ignotum/client", runtime: "automatic", development: false } },
     resolve: {
       alias: [
@@ -177,11 +198,21 @@ export const buildManagedClient = Effect.fn("Deploy.buildManagedClient")(functio
       ),
       tsconfigPaths: true,
     },
-    plugins: [privateMaps, images.plugin, boundaries, platform, peers, collect, tailwindcss()],
+    plugins: [
+      privateMaps,
+      images.plugin,
+      boundaries,
+      platform,
+      platformImportsPlugin(compilerExports),
+      clientCycleGroupsPlugin(appDirectory),
+      collect,
+      tailwindcss(),
+    ],
     build: {
       emptyOutDir: false,
       outDir: stage,
       modulePreload: false,
+      cssCodeSplit: false,
       sourcemap: "hidden",
       target: "es2022",
       rolldownOptions: {
@@ -189,18 +220,31 @@ export const buildManagedClient = Effect.fn("Deploy.buildManagedClient")(functio
         preserveEntrySignatures: "strict",
         output: {
           entryFileNames: "[name].mjs",
-          chunkFileNames: "shared-[hash].mjs",
+          chunkFileNames: (chunk) => {
+            const owners = chunk.moduleIds
+              .map((id) => {
+                const normalized = normalizePath(id);
+                const dependency = normalized.lastIndexOf("/node_modules/");
+                return dependency < 0
+                  ? normalized
+                      .replace(normalizePath(appDirectory), "app")
+                      .replace(encodeURIComponent(normalizePath(appDirectory)), "app")
+                  : normalized.slice(dependency + 14);
+              })
+              .sort();
+            return `shared/chunk-${createHash("sha256").update(JSON.stringify(owners)).digest("hex").slice(0, 16)}.mjs`;
+          },
           assetFileNames: (asset) =>
             asset.names.some((name) => name.endsWith(".css"))
-              ? stylesheetFileName(asset.source)
-              : "assets/[name]-[hash][extname]",
+              ? "styles.css"
+              : "media/[name]-[hash][extname]",
           sourcemapPathTransform: yield* sourceMapPathTransform(appDirectory),
         },
       },
     },
   });
   const chunks = output.flatMap((item) =>
-    item.type === "chunk"
+    item.type === "chunk" && item.fileName !== "global.mjs"
       ? [
           {
             fileName: item.fileName,
@@ -214,6 +258,7 @@ export const buildManagedClient = Effect.fn("Deploy.buildManagedClient")(functio
   );
   const files = new Map<string, Uint8Array>();
   for (const item of output) {
+    if (item.fileName === "global.mjs") continue;
     if (
       item.type === "asset" &&
       !item.fileName.endsWith(".css") &&
@@ -224,53 +269,81 @@ export const buildManagedClient = Effect.fn("Deploy.buildManagedClient")(functio
       });
     files.set(item.fileName, yield* fs.readFile(path.join(stage, item.fileName)));
   }
+  for (const [name, contents] of [...files]) {
+    if (!name.endsWith(".css")) continue;
+    files.delete(name);
+    files.set(`styles-${yield* sha256(contents)}.css`, contents);
+  }
   for (const [name, bytes] of maps) files.set(name, bytes);
-  const knownChunks = new Map(chunks.map((chunk) => [chunk.fileName, chunk]));
-  const stylesFor = (fileName: string, visited = new Set<string>()): ReadonlyArray<string> => {
-    if (visited.has(fileName)) return [];
-    visited.add(fileName);
-    const chunk = knownChunks.get(fileName);
-    if (chunk === undefined) return [];
-    return [
-      ...new Set([
-        ...chunk.styles,
-        ...chunk.imports.flatMap((dependency) => stylesFor(dependency, visited)),
-      ]),
-    ].sort();
+  const styles = [...files.keys()].filter((name) => name.endsWith(".css")).sort();
+  const registration = `const registration = {
+    applicationName: ${literal(appName)},
+    routes: ${JSON.stringify(discovery.routes)},
+    layouts: ${JSON.stringify(discovery.layouts)},
+    styles: ${JSON.stringify(styles.map((name) => `/_ignotum/assets/${name}`))},
+    modules: new Map([
+${discovery.modules.map((module) => `      [${literal(module.id)}, { load: () => import(${literal(`./${sourceEntries.get(module.id)!}`)}), styles: [] }]`).join(",\n")}
+    ])
   };
-  const globalCss = new Set(chunkMetadata.get("global.mjs")?.styles ?? []);
-  const routeStyles = new Set(
-    chunks.filter((chunk) => chunk.fileName !== "global.mjs").flatMap((chunk) => chunk.styles),
-  );
-  const styles = [...files.keys()]
-    .filter((name) => name.endsWith(".css") && (globalCss.has(name) || !routeStyles.has(name)))
-    .sort();
-  const registration = `import { mountClient } from "ignotum/internal/bootstrap";
-const registration = {
-  applicationName: ${literal(appName)},
-  routes: ${JSON.stringify(discovery.routes)},
-  layouts: ${JSON.stringify(discovery.layouts)},
-  styles: ${JSON.stringify(styles.map((name) => `/_ignotum/${name}`))},
-  modules: new Map([
-${discovery.modules
-  .map((module) => {
-    const name = sourceEntries.get(module.id)!;
-    return `    [${literal(module.id)}, { load: () => import(${literal(`./${name}`)}), styles: ${JSON.stringify(stylesFor(name).map((style) => `/_ignotum/${style}`))} }]`;
-  })
-  .join(",\n")}
-  ])
-};
-export default function mount(selection) { return mountClient(registration, selection); }
+export default registration;
 `;
-  files.set("registration.mjs", utf8Bytes(registration));
   chunks.push({
-    fileName: "registration.mjs",
-    imports: ["ignotum/internal/bootstrap"],
+    fileName: "entry.mjs",
+    imports: [],
     dynamicImports: [...sourceEntries.values()],
     styles,
     isEntry: true,
   });
-  chunks.sort((a, b) => a.fileName.localeCompare(b.fileName));
+  const names = yield* Effect.try({
+    try: () =>
+      nameClientChunks(
+        [
+          ...output.flatMap((item) =>
+            item.type === "chunk" && item.fileName !== "global.mjs"
+              ? [
+                  {
+                    fileName: item.fileName,
+                    code: new TextDecoder().decode(files.get(item.fileName)!),
+                    imports: item.imports,
+                    dynamicImports: item.dynamicImports,
+                    modules: {},
+                    sourceMap: maps.has(`${item.fileName}.map`)
+                      ? new TextDecoder().decode(maps.get(`${item.fileName}.map`))
+                      : undefined,
+                  },
+                ]
+              : [],
+          ),
+          {
+            fileName: "entry.mjs",
+            code: registration,
+            imports: [],
+            dynamicImports: [...sourceEntries.values()],
+            modules: {},
+          },
+        ],
+        "entry.mjs",
+      ),
+    catch: (cause) =>
+      InvalidBuildOutput.make({ message: `Client dependency naming failed: ${String(cause)}` }),
+  });
+  for (const [original, named] of names) {
+    files.delete(original);
+    files.delete(`${original}.map`);
+    maps.delete(`${original}.map`);
+    files.set(named.fileName, utf8Bytes(named.code));
+    if (named.sourceMap !== undefined)
+      maps.set(`${named.fileName}.map`, utf8Bytes(named.sourceMap));
+  }
+  for (const [id, original] of sourceEntries) sourceEntries.set(id, names.get(original)!.fileName);
+  const finalChunks = chunks.map((chunk) => ({
+    ...chunk,
+    fileName: names.get(chunk.fileName)!.fileName,
+    imports: chunk.imports.map((name) => names.get(name)?.fileName ?? name),
+    dynamicImports: chunk.dynamicImports.map((name) => names.get(name)?.fileName ?? name),
+    styles: [],
+  }));
+  const knownChunks = new Map(finalChunks.map((chunk) => [chunk.fileName, chunk]));
   let icon: AppArtifactPath | undefined;
   const iconPath = path.join(appDirectory, "client/icon.svg");
   if (yield* fs.exists(iconPath)) {
@@ -280,23 +353,16 @@ export default function mount(selection) { return mountClient(registration, sele
         message: "The client icon must be a regular file.",
       });
     const bytes = yield* fs.readFile(iconPath);
-    icon = AppArtifactPath.make(`assets/${yield* sha256(bytes)}/icon.svg`);
+    icon = AppArtifactPath.make(`media/icon-${yield* sha256(bytes)}.svg`);
     files.set(icon, bytes);
   }
-  // App module identities include the completed inventory digest. Its source retains relative
-  // imports and content-named asset URLs, so cycles and registration never hash their own identity.
-  const inventory = yield* Effect.forEach(
-    [...files].sort(([a], [b]) => a.localeCompare(b)),
-    ([name, bytes]) => sha256(bytes).pipe(Effect.map((digest) => ({ name, digest }))),
-  );
-  const graphDigest = yield* sha256(utf8Bytes(JSON.stringify(inventory)));
-  const moduleId = (name: string) => AppModuleId.make(`app/client/${graphDigest}/${name}`);
-  const modulePath = (name: string) => AppArtifactPath.make(`client/${graphDigest}/${name}`);
+  const moduleId = (name: string) => AppModuleId.make(`app/client/${name}`);
+  const modulePath = (name: string) => AppArtifactPath.make(name);
   const artifacts: AppArtifact[] = [];
   const bytes = new Map<string, Uint8Array>();
   const modules: AppModule[] = [];
   const imagePaths = [...images.assets.keys()];
-  for (const chunk of chunks) {
+  for (const chunk of finalChunks) {
     const source = files.get(chunk.fileName)!;
     const id = moduleId(chunk.fileName);
     const artifact = {
@@ -317,7 +383,7 @@ export default function mount(selection) { return mountClient(registration, sele
       } else {
         const kind = imported.startsWith("ignotum/internal/")
           ? "Compiler"
-          : imported.startsWith("ignotum/client")
+          : imported.startsWith("ignotum/client") || imported === "ignotum/platform"
             ? "Runtime"
             : "RenderingPeer";
         imports.push(
@@ -327,7 +393,7 @@ export default function mount(selection) { return mountClient(registration, sele
     }
     const map = maps.get(`${chunk.fileName}.map`);
     const mapPath = modulePath(`${chunk.fileName}.map`);
-    const moduleStyles = chunk.fileName === "registration.mjs" ? styles : stylesFor(chunk.fileName);
+    const moduleStyles = chunk.fileName === "entry.js" ? styles : [];
     const assetSources = [
       new TextDecoder().decode(source),
       ...moduleStyles.map((style) => new TextDecoder().decode(files.get(style))),
@@ -338,7 +404,9 @@ export default function mount(selection) { return mountClient(registration, sele
       imports,
       styles: moduleStyles.map((name) => AppArtifactPath.make(name)),
       assets: imagePaths
-        .filter((name) => assetSources.some((contents) => contents.includes(`/_ignotum/${name}`)))
+        .filter((name) =>
+          assetSources.some((contents) => contents.includes(`/_ignotum/assets/${name}`)),
+        )
         .map((name) => AppArtifactPath.make(name)),
     };
     const module = map === undefined ? baseModule : { ...baseModule, sourceMap: mapPath };
@@ -358,7 +426,7 @@ export default function mount(selection) { return mountClient(registration, sele
     }
   }
   for (const [name, contents] of [...files].sort(([a], [b]) => a.localeCompare(b))) {
-    if (knownChunks.has(name) || name === "registration.mjs" || name.endsWith(".map")) continue;
+    if (knownChunks.has(name) || name === "entry.js" || name.endsWith(".map")) continue;
     const kind = name === icon ? "Icon" : name.endsWith(".css") ? "Style" : "Image";
     const contentType =
       kind === "Icon"
@@ -369,7 +437,7 @@ export default function mount(selection) { return mountClient(registration, sele
     if (contentType === undefined)
       return yield* InvalidBuildOutput.make({ message: `Unknown client asset '${name}'.` });
     const reference = yield* artifactReference(name, contents);
-    if (kind === "Style" && name !== `assets/${reference.sha256}/style.css`)
+    if (kind === "Style" && name !== `styles-${reference.sha256}.css`)
       return yield* InvalidBuildOutput.make({
         message: "The bundler changed stylesheet bytes after their content identity was assigned.",
       });
@@ -387,9 +455,11 @@ export default function mount(selection) { return mountClient(registration, sele
     exportName: "default",
   });
   const baseClient = {
-    registration: { module: moduleId("registration.mjs"), exportName: "default" },
+    registration: { module: moduleId("entry.js"), exportName: "default" },
     graph: {
-      entries: chunks.filter((chunk) => chunk.isEntry).map((chunk) => moduleId(chunk.fileName)),
+      entries: finalChunks
+        .filter((chunk) => chunk.isEntry)
+        .map((chunk) => moduleId(chunk.fileName)),
       modules,
     },
     routes: discovery.routes.map((route) => ({ ...route, page: reference(route.page.module) })),

package/src/cli/build/managed-server.ts

@@ -19,7 +19,7 @@ import {
   validateAppModuleBytes,
   validateManagedServerDefinition,
 } from "@ignotum/versions";
-import { managedGuestExports } from "../managed-exports.js";
+import { guestEntries } from "@ignotum/platform/registry";
 import { moduleBoundariesPlugin } from "../module-boundaries.js";
 import { InvalidBuildOutput, runViteBuild, sourceMapPathTransform } from "./artifact.js";
 import type { ServerDiscoveryManifest } from "./server.js";
@@ -36,9 +36,9 @@ export interface ManagedServerBuildResult {
 }
 
 const literal = Schema.encodeSync(Schema.fromJsonString(Schema.String));
-const externals = managedGuestExports
-  .filter((entry) => entry.specifier !== "ignotum/internal/host")
-  .map((entry) => entry.specifier);
+const externals = Object.keys(guestEntries).filter(
+  (specifier) => specifier !== "ignotum/internal/host",
+);
 
 export const compileManagedServer = Effect.fn("Deploy.compileManagedServer")(function* (
   appDirectory: string,

package/src/cli/build/managed.ts

@@ -1,10 +1,10 @@
 import { Effect, FileSystem, Path, Schema } from "effect";
 import { UploadDeclaration } from "@ignotum/contracts/app-definition";
-import { RuntimeRequirements } from "@ignotum/contracts/platform";
+import { PlatformRequirement } from "@ignotum/contracts/deployment";
 import { encodeCanonical, validateUploadDeclaration, utf8Bytes } from "@ignotum/versions";
 import { generate } from "../codegen.js";
 import { replaceBuildDirectory } from "./output.js";
-import { managedCompatibility } from "../managed-exports.js";
+
 import { buildManagedClient } from "./managed-client.js";
 import { buildManagedServer } from "./server.js";
 
@@ -35,10 +35,9 @@ export const buildManagedVersion = Effect.fn("Deploy.buildManagedVersion")(funct
       );
       const client = yield* buildManagedClient(appDirectory, staging, options);
       const server = yield* buildManagedServer(appDirectory, staging, generated.functionModules);
-      const requirements = yield* Schema.decodeUnknownEffect(RuntimeRequirements)({
-        clientApiVersion: managedCompatibility.clientApiVersion,
-        serverApiVersion: managedCompatibility.serverApiVersion,
-        capabilities: managedCompatibility.capabilities,
+      const requirements = yield* Schema.decodeEffect(PlatformRequirement)({
+        major: 1,
+        minimumMinor: 0,
       });
       const declaration = yield* validateUploadDeclaration({
         formatVersion: 1,