@antelopejs/dms-frontend 0.8.0 → 0.9.0

package/dist/locale-files.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidLocaleFileError = void 0;
+exports.readLocaleFile = readLocaleFile;
+const node_fs_1 = require("node:fs");
+const message_compiler_1 = require("@intlify/message-compiler");
+class InvalidLocaleFileError extends Error {
+    constructor(path, reason) {
+        super(`Invalid locale file ${path}: ${reason}`);
+        this.path = path;
+        this.reason = reason;
+        this.name = "InvalidLocaleFileError";
+    }
+}
+exports.InvalidLocaleFileError = InvalidLocaleFileError;
+const LITERAL_ESCAPES = {
+    "@": "{'@'}",
+    "{": "{'{'}",
+    "}": "{'}'}",
+    "|": "{'|'}",
+};
+function reservedCharacterAt(message, offset) {
+    for (let index = Math.min(offset, message.length - 1); index >= 0; index--) {
+        if (message[index] in LITERAL_ESCAPES)
+            return message[index];
+    }
+    return null;
+}
+function describeProblem({ key, message, error }) {
+    const where = `${key}: ${error.message} in ${JSON.stringify(message)}`;
+    const character = reservedCharacterAt(message, error.location?.start.offset ?? message.length);
+    if (!character) {
+        return `${where}. Write ${Object.values(LITERAL_ESCAPES).join(", ")} for a literal ${Object.keys(LITERAL_ESCAPES).join(", ")}.`;
+    }
+    const fixed = message.replaceAll(character, LITERAL_ESCAPES[character]);
+    return `${where}. Write a literal ${character} as ${LITERAL_ESCAPES[character]}: ${JSON.stringify(fixed)}.`;
+}
+function firstCompileError(message) {
+    let first;
+    (0, message_compiler_1.baseCompile)(message, {
+        location: true,
+        onError: (error) => {
+            first ??= error;
+        },
+    });
+    return first;
+}
+function messageProblems(value, key) {
+    if (typeof value === "string") {
+        const error = firstCompileError(value);
+        return error ? [{ key, message: value, error }] : [];
+    }
+    if (typeof value !== "object" || value === null)
+        return [];
+    return Object.entries(value).flatMap(([child, nested]) => messageProblems(nested, key ? `${key}.${child}` : child));
+}
+function readLocaleFile(path) {
+    let value;
+    try {
+        value = JSON.parse((0, node_fs_1.readFileSync)(path, "utf8"));
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        throw new InvalidLocaleFileError(path, reason);
+    }
+    const problems = messageProblems(value, "");
+    if (problems.length) {
+        const reason = [
+            `${problems.length} message(s) vue-i18n cannot compile:`,
+            ...problems.map(describeProblem),
+        ].join("\n");
+        throw new InvalidLocaleFileError(path, reason);
+    }
+    return value;
+}

package/dist/manifest.js

@@ -197,6 +197,8 @@ async function fetchManifest(backendUrl, clientUrl, bootstrapSecret) {
     const resolved = { modules: manifest.modules };
     if (manifest.settling)
         resolved.settling = true;
+    if (manifest.originRewrites)
+        resolved.originRewrites = manifest.originRewrites;
     return resolved;
 }
 const MANIFEST_CACHE_FILE = ".manifest-cache.json";

package/dist/private-values.d.ts

@@ -1,5 +1,6 @@
 import type { FrontendModuleOptions } from "./workspace";
 export declare function emptiedOptions(options: FrontendModuleOptions): FrontendModuleOptions;
+export declare function filledOptions(shape: FrontendModuleOptions, values: FrontendModuleOptions | undefined): FrontendModuleOptions;
 export declare const PRIVATE_OPTIONS_VARIABLE = "DMS_PRIVATE_OPTIONS";
 export interface UnfilledPrivateValue {
     module: string;

package/dist/private-values.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PRIVATE_OPTIONS_VARIABLE = void 0;
 exports.emptiedOptions = emptiedOptions;
+exports.filledOptions = filledOptions;
 exports.parsePrivateOptions = parsePrivateOptions;
 exports.unfilledPrivateValues = unfilledPrivateValues;
 const config_1 = require("./config");
@@ -17,6 +18,21 @@ function emptied(value) {
 function emptiedOptions(options) {
     return Object.fromEntries(Object.entries(options).map(([key, value]) => [key, emptied(value)]));
 }
+function filled(shape, value) {
+    if (typeof shape === "string")
+        return typeof value === "string" ? value : "";
+    if (Array.isArray(shape))
+        return shape.map((item, index) => filled(item, Array.isArray(value) ? value[index] : undefined));
+    if (shape !== null && typeof shape === "object")
+        return filledOptions(shape, isOptions(value) ? value : undefined);
+    return shape;
+}
+function filledOptions(shape, values) {
+    return Object.fromEntries(Object.entries(shape).map(([key, value]) => [
+        key,
+        filled(value, values?.[key]),
+    ]));
+}
 exports.PRIVATE_OPTIONS_VARIABLE = "DMS_PRIVATE_OPTIONS";
 function isOptions(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);

package/dist/project-modules-child.d.ts

@@ -0,0 +1,13 @@
+import { CliError, type Ui } from "@antelopejs/core/cli";
+import { type ProjectFrontendModule } from "./project-modules";
+type MessageArgs = Parameters<Ui["message"]>;
+export type ProjectModulesReply = {
+    messages: MessageArgs[];
+} & ({
+    modules: ProjectFrontendModule[];
+} | {
+    problem: CliError["problem"];
+} | {
+    failure: string;
+});
+export {};

package/dist/project-modules-child.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const cli_1 = require("@antelopejs/core/cli");
+const project_modules_1 = require("./project-modules");
+process.once("message", async (options) => {
+    const messages = [];
+    (0, cli_1.getProcessUi)().message = (...args) => {
+        messages.push(args);
+    };
+    let reply;
+    try {
+        reply = { messages, modules: await (0, project_modules_1.readProjectFrontendModules)(options) };
+    }
+    catch (error) {
+        reply =
+            error instanceof cli_1.CliError
+                ? { messages, problem: error.problem }
+                : {
+                    messages,
+                    failure: error instanceof Error
+                        ? (error.stack ?? error.message)
+                        : String(error),
+                };
+    }
+    process.send?.(reply, () => process.disconnect());
+});

package/dist/project-modules.d.ts

@@ -26,6 +26,7 @@ interface ModuleSource {
 interface ProjectModule {
     source: ModuleSource;
     config: unknown;
+    folder?: string;
 }
 interface ProjectConfig {
     cacheFolder: string;

package/dist/project-modules.js

@@ -48,10 +48,7 @@ const FRONTEND_SOURCE_DIR = "frontend-vue";
 const RENDERER = { name: "vue", version: "3" };
 const CONFIG_VAR_PATTERN = /\$\{@([^.}]+)\.([^}]+)\}/g;
 const PURE_CONFIG_VAR = /^\$\{@([^.}]+)\.([^}]+)\}$/;
-const TRAILING_SLASHES = /\/+$/;
-const DEFAULT_API_PORT = 80;
-const LOOPBACK_HOST = "127.0.0.1";
-const WILDCARD_HOSTS = new Set(["0.0.0.0", "::", "[::]"]);
+const MODULE_MANIFEST_FILE = "antelope.module.json";
 const NODE_FILE_SYSTEM = {
     readFile: (path) => fsPromises.readFile(path),
     readFileString: (path, encoding = "utf-8") => fsPromises.readFile(path, encoding),
@@ -67,48 +64,79 @@ const NODE_FILE_SYSTEM = {
     copyFile: (src, dest) => fsPromises.copyFile(src, dest),
     rename: (oldPath, newPath) => fsPromises.rename(oldPath, newPath),
 };
-function apiLocalBaseUrl(server) {
-    const host = !server.host || WILDCARD_HOSTS.has(server.host)
-        ? LOOPBACK_HOST
-        : server.host;
-    const protocol = server.protocol ?? "http";
-    return `${protocol}://${host}:${server.port ?? DEFAULT_API_PORT}`;
-}
-const CONFIG_VAR_PROVIDERS = {
-    api: (config) => {
-        const api = (config ?? {});
-        const server = api.servers?.[0];
-        if (!server)
-            return {};
-        const local = apiLocalBaseUrl(server);
-        return {
-            API_PORT: server.port ?? DEFAULT_API_PORT,
-            API_LOCAL_BASE_URL: local,
-            API_PUBLIC_BASE_URL: api.publicBaseUrl?.trim().replace(TRAILING_SLASHES, "") || local,
-        };
-    },
-};
-function projectConfigVars(config) {
-    return Object.fromEntries(Object.entries(CONFIG_VAR_PROVIDERS)
-        .filter(([id]) => config.modules[id])
-        .map(([id, provide]) => [id, provide(config.modules[id].config)]));
+function readAntelopeManifest(folder) {
+    const dedicated = (0, node_path_1.join)(folder, MODULE_MANIFEST_FILE);
+    if ((0, node_fs_1.existsSync)(dedicated))
+        return JSON.parse((0, node_fs_1.readFileSync)(dedicated, "utf-8"));
+    return (0, layers_1.readLayerPackage)(folder)?.antelopeJs;
+}
+function warnUndeclaredConfigVars(id) {
+    (0, cli_1.getProcessUi)().message("warn", `${id} declares no antelopeJs.configVarsFile in its package.json: the \${@${id}.<VAR>} references are left unresolved`, { detail: `Upgrade ${id} to a version that declares it` });
+}
+function configVarsProvider(id, folder) {
+    const manifest = readAntelopeManifest(folder);
+    const file = manifest?.configVarsFile;
+    if (typeof file !== "string") {
+        warnUndeclaredConfigVars(id);
+        return undefined;
+    }
+    const { configVars } = require((0, node_path_1.join)(folder, file));
+    if (typeof configVars !== "function") {
+        throw new cli_1.CliError({
+            title: `${id}: ${file} exports no configVars function`,
+            fixes: [`Export configVars(config) from ${file}`],
+        });
+    }
+    const declared = Array.isArray(manifest?.configVars)
+        ? manifest.configVars.filter((name) => typeof name === "string")
+        : [];
+    return { declared, configVars };
+}
+function computeConfigVars(id, provider, config) {
+    let computed;
+    try {
+        computed = provider.configVars(config) ?? {};
+    }
+    catch (error) {
+        throw new cli_1.CliError({
+            title: `${id}: could not compute its config variables`,
+            reason: error instanceof Error ? error.message : String(error),
+        }, { cause: error });
+    }
+    return Object.fromEntries(provider.declared
+        .filter((name) => name in computed)
+        .map((name) => [name, computed[name]]));
+}
+function configVarLookup(modules) {
+    const published = new Map();
+    const lookup = (id, name) => {
+        if (!published.has(id)) {
+            published.set(id, undefined);
+            const module = modules[id];
+            const provider = module?.folder && configVarsProvider(id, module.folder);
+            if (provider)
+                published.set(id, computeConfigVars(id, provider, substituteConfigVars(module.config, lookup)));
+        }
+        return published.get(id)?.[name];
+    };
+    return lookup;
 }
-function substituteConfigVars(value, vars) {
+function substituteConfigVars(value, lookup) {
     if (typeof value === "string") {
         const pure = value.match(PURE_CONFIG_VAR);
         if (pure)
-            return vars[pure[1]]?.[pure[2]];
+            return lookup(pure[1], pure[2]);
         return value.replace(CONFIG_VAR_PATTERN, (token, module, name) => {
-            const resolved = vars[module]?.[name];
+            const resolved = lookup(module, name);
             return resolved === undefined ? token : String(resolved);
         });
     }
     if (Array.isArray(value))
-        return value.map((item) => substituteConfigVars(item, vars));
+        return value.map((item) => substituteConfigVars(item, lookup));
     if (value && typeof value === "object") {
         return Object.fromEntries(Object.entries(value).map(([key, item]) => [
             key,
-            substituteConfigVars(item, vars),
+            substituteConfigVars(item, lookup),
         ]));
     }
     return value;
@@ -127,12 +155,19 @@ async function loadProjectConfig(projectDir, environment) {
             fixes: ["Run from the project root, or pass --project <dir>"],
         }, { cause: error });
     }
-    const vars = projectConfigVars(loaded);
+    const located = Object.fromEntries(Object.entries(loaded.modules).map(([id, module]) => [
+        id,
+        {
+            ...module,
+            folder: moduleFolder(projectDir, loaded.cacheFolder, module.source),
+        },
+    ]));
+    const lookup = configVarLookup(located);
     return {
         cacheFolder: loaded.cacheFolder,
-        modules: Object.fromEntries(Object.entries(loaded.modules).map(([id, module]) => [
+        modules: Object.fromEntries(Object.entries(located).map(([id, module]) => [
             id,
-            { ...module, config: substituteConfigVars(module.config, vars) },
+            { ...module, config: substituteConfigVars(module.config, lookup) },
         ])),
     };
 }
@@ -214,7 +249,7 @@ async function readProjectFrontendModules(options) {
     const config = await loadProjectConfig(projectDir, options.environment);
     const context = { dev: !!options.dev };
     const registrations = Object.entries(config.modules).flatMap(([id, module]) => {
-        const folder = moduleFolder(projectDir, config.cacheFolder, module.source);
+        const folder = module.folder;
         if (!folder) {
             warnMissingModule(id);
             return [];

package/dist/workspace-setup.js

@@ -15,6 +15,7 @@ const cli_1 = require("@antelopejs/core/cli");
 const child_output_1 = require("./child-output");
 const layers_1 = require("./layers");
 const manifest_1 = require("./manifest");
+const dev_modules_1 = require("./dev-modules");
 const project_modules_1 = require("./project-modules");
 const manifest_secrets_1 = require("./manifest-secrets");
 const renderer_range_1 = require("./renderer-range");
@@ -23,6 +24,7 @@ const workspace_1 = require("./workspace");
 const cancellation_1 = require("./cancellation");
 const output_1 = require("./output");
 const config_1 = require("./config");
+const locale_files_1 = require("./locale-files");
 const WORKSPACE_PNPM_CONFIG = "pnpm-workspace.yaml";
 const WORKSPACE_PATCHES_DIR = "patches";
 function workspaceInstallInputs(workspaceDir) {
@@ -223,10 +225,33 @@ async function projectLayers(project) {
         secrets: { published: {}, conflicts: [] },
     };
 }
-async function servedLayers(opts, backendUrl, workspaceDir) {
+function servedManifest(opts, backendUrl, workspaceDir) {
     const { offline, clientUrl, bootstrapSecret } = opts;
     const cacheUse = offline ? "offline" : "fallback";
-    const { manifest, fromCache, fetchedAt } = await (0, manifest_1.resolveManifest)(workspaceDir, backendUrl, cacheUse, { clientUrl, bootstrapSecret });
+    return (0, manifest_1.resolveManifest)(workspaceDir, backendUrl, cacheUse, {
+        clientUrl,
+        bootstrapSecret,
+    });
+}
+async function projectLayersInDev(opts, project, backendUrl, workspaceDir) {
+    const { manifest, fromCache, fetchedAt } = await servedManifest(opts, backendUrl, workspaceDir);
+    const modules = await (0, dev_modules_1.readProjectModulesFresh)({ ...project, dev: true });
+    const layers = (0, dev_modules_1.withBackendValues)(modules, manifest);
+    (0, dev_modules_1.warnModuleDrift)(layers, manifest);
+    return {
+        fromCache,
+        fetchedAt,
+        layers,
+        secrets: (0, manifest_secrets_1.collectManifestSecrets)(layers.map((layer) => ({
+            name: layer.name ?? "",
+            priority: layer.priority ?? 0,
+            privateOptions: layer.privateOptions,
+        }))),
+    };
+}
+async function servedLayers(opts, backendUrl, workspaceDir) {
+    const { bootstrapSecret } = opts;
+    const { manifest, fromCache, fetchedAt } = await servedManifest(opts, backendUrl, workspaceDir);
     (0, layers_1.assertLayerPathsServed)(manifest.modules, backendUrl, {
         bootstrapSecret,
         cache: fromCache ? { fetchedAt } : undefined,
@@ -261,6 +286,8 @@ function workspaceSource(opts, workspaceDir) {
             throw new Error("A build reads a project");
         return projectLayers(opts.project);
     }
+    if (opts.project)
+        return projectLayersInDev(opts, opts.project, requireDevBackend(opts), workspaceDir);
     return servedLayers(opts, requireDevBackend(opts), workspaceDir);
 }
 async function setupWorkspace(opts) {
@@ -270,7 +297,7 @@ async function setupWorkspace(opts) {
     (0, materialize_1.copyStaticTemplates)(workspaceDir);
     (0, materialize_1.writeWorkspacePackageJson)(workspaceDir, layers);
     (0, materialize_1.materializeLayers)(workspaceDir, layers);
-    (0, materialize_1.writeFrontendModuleRegistry)(workspaceDir, layers);
+    writeDerivedOutputs(workspaceDir, layers);
     (0, materialize_1.writeDmsMainCss)(workspaceDir, layers);
     const layerPaths = layers.map((layer) => layer.path);
     const shouldInstall = needsInstall(workspaceDir, layerPaths, opts.force);
@@ -287,3 +314,14 @@ async function setupWorkspace(opts) {
         manifestSecrets: secrets,
     };
 }
+function writeDerivedOutputs(workspaceDir, layers) {
+    try {
+        (0, materialize_1.writeFrontendModuleRegistry)(workspaceDir, layers);
+    }
+    catch (error) {
+        if (!(error instanceof locale_files_1.InvalidLocaleFileError))
+            throw error;
+        const showSource = (0, child_output_1.createPathMapper)(workspaceDir, layers);
+        throw new locale_files_1.InvalidLocaleFileError(showSource(error.path), error.reason);
+    }
+}

package/dist/workspace.d.ts

@@ -27,14 +27,20 @@ export interface PublicEndpointDeclaration {
     methods?: string[];
     headers?: string[];
 }
+export interface OriginRewrite {
+    from: string;
+    to: string;
+}
 export interface Manifest {
     modules: ManifestModule[];
     settling?: boolean;
+    originRewrites?: OriginRewrite[];
 }
 export interface FrontendManifest {
     version: number;
     modules: ManifestModule[];
     settling?: boolean;
+    originRewrites?: OriginRewrite[];
 }
 export interface ResolvedLayer {
     path: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@antelopejs/dms-frontend",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "description": "Frontend-agnostic loader for AntelopeJS DMS, shipping the Vue 3 renderer (Vite, Inertia, SSR)",
   "keywords": [
     "antelope",
@@ -73,6 +73,7 @@
     "docs:reference:check": "tsx scripts/docs-reference.ts --check"
   },
   "dependencies": {
+    "@intlify/message-compiler": "^11.1.12",
     "chokidar": "^4.0.3",
     "commander": "^13.1.0",
     "ignore": "^7.0.5",
@@ -89,6 +90,7 @@
     "@unhead/vue": "^2.1.4",
     "@vitejs/plugin-vue": "^6.0.6",
     "@vue/server-renderer": "^3.5.25",
+    "@vueuse/core": "14.4.0",
     "defu": "^6.1.4",
     "devalue": "^5.9.4",
     "knip": "^6.34.0",
@@ -99,7 +101,7 @@
     "release-it": "^19.2.4",
     "release-it-changelogen": "^0.1.0",
     "rimraf": "^6.1.2",
-    "tsx": "^4.20.6",
+    "tsx": "^4.23.15",
     "typescript": "^6.0.3",
     "unplugin-auto-import": "^20.2.0",
     "vite": "^8.3.4",
@@ -120,6 +122,11 @@
     "node": ">=20.19.0"
   },
   "packageManager": "pnpm@10.6.5",
+  "pnpm": {
+    "patchedDependencies": {
+      "@vueuse/core@14.4.0": "templates/vue/patches/@vueuse__core@14.4.0.patch"
+    }
+  },
   "antelopeJs": {
     "skills": [
       "./skills"

package/templates/vue/app-runtime.ts

@@ -58,6 +58,7 @@ import {
   drawLoadedIconsAtOnce,
 } from "./icon-hydration";
 import {
+  catalogLocale,
   loadLocaleMessages,
   localeMessages,
   supportedLocales,
@@ -85,6 +86,8 @@ export interface DmsAppOptions {
 }
 
 export interface DmsConfiguredApp {
+  /** The locale of the catalog the app shows its messages from now. */
+  catalogLocale: () => string | undefined;
   mounted: () => Promise<void>;
   runtime: ReturnType<typeof createDmsFrontendRuntime>;
 }
@@ -348,7 +351,11 @@ export async function configureDmsApp(
     loadLocaleMessages as DmsLocaleLoader,
     supportedLocales,
   );
-  return { mounted, runtime };
+  return {
+    catalogLocale: () => catalogLocale(i18n.global.locale.value),
+    mounted,
+    runtime,
+  };
 }
 
 export { trackDmsAsyncComponents };

package/templates/vue/entry-weight.mjs

@@ -0,0 +1,132 @@
+// What each frontend module adds to the client entry.
+//
+// Every page loads the entry, and everything it imports statically, before it
+// runs anything: a module's `dms.frontend.ts`, its plugins and whatever they
+// import land there, on every page of every application that loads the
+// module. The client build records, from the bundle's own metadata, how much
+// of the entry each module's sources make up; `ajs dms build` reports it and
+// warns about a module above its threshold.
+//
+// Kept beside vite.config.ts rather than inside it so the plugin can be
+// exercised on its own, the way client-chunking.mjs is.
+
+import { mkdirSync, writeFileSync } from "node:fs";
+import { dirname, join, relative, sep } from "node:path";
+
+/** Where the client build writes the attribution, under `dist/client`. */
+export const ENTRY_WEIGHT_FILE = ".vite/entry-weight.json";
+
+/** Owners of the entry's bytes that are no frontend module. */
+export const SHARED_OWNER = "shared";
+export const TRANSLATIONS_OWNER = "translations";
+
+const LOCALE_CATALOG = /[\\/]locales\.generated[\\/]/;
+
+function stripQuery(id) {
+  const query = id.indexOf("?");
+  return query === -1 ? id : id.slice(0, query);
+}
+
+function isInside(root, file) {
+  const path = relative(root, file);
+  return Boolean(path) && !path.startsWith("..") && !path.startsWith(sep);
+}
+
+/**
+ * The owner of a module id of the bundle: the frontend module whose sources
+ * hold the file, by its manifest name; the merged translation catalogs; else
+ * what every page shares (the renderer's runtime, the UI and icon libraries,
+ * an installed package).
+ *
+ * @param {{ root: string, name?: string, packageName?: string, id: string }[]} modules
+ */
+export function entryOwner(id, modules) {
+  if (id.startsWith("\0")) return SHARED_OWNER;
+  const file = stripQuery(id);
+  if (/[\\/]node_modules[\\/]/.test(file)) return SHARED_OWNER;
+  if (LOCALE_CATALOG.test(file)) return TRANSLATIONS_OWNER;
+  const module = modules.find(({ root }) => isInside(root, file));
+  return module
+    ? (module.name ?? module.packageName ?? module.id)
+    : SHARED_OWNER;
+}
+
+/**
+ * The files a page loads before its first line runs: the entry chunks and
+ * their static imports, transitively, by file name.
+ */
+function entryClosure(bundle) {
+  const chunks = Object.values(bundle).filter(
+    (output) => output.type === "chunk",
+  );
+  const byName = new Map(chunks.map((chunk) => [chunk.fileName, chunk]));
+  const seen = new Set();
+  const visit = (chunk) => {
+    if (!chunk || seen.has(chunk.fileName)) return;
+    seen.add(chunk.fileName);
+    for (const file of chunk.imports ?? []) visit(byName.get(file));
+  };
+  for (const chunk of chunks) if (chunk.isEntry) visit(chunk);
+  return [...seen].map((file) => byName.get(file));
+}
+
+/**
+ * The bytes of the entry each owner accounts for. Each chunk's bytes are
+ * shared out among the modules it holds in proportion to the code Rolldown
+ * rendered for each (`renderedLength`, before minification): an estimate that
+ * needs nothing the bundle does not already hold.
+ *
+ * @returns {{ files: string[], bytes: number, owners: Record<string, number> }}
+ */
+export function attributeEntry(bundle, modules) {
+  const files = entryClosure(bundle);
+  const owners = {};
+  let bytes = 0;
+  for (const chunk of files) {
+    const size = Buffer.byteLength(chunk.code);
+    bytes += size;
+    const rendered = Object.entries(chunk.modules ?? {});
+    const total = rendered.reduce(
+      (sum, [, info]) => sum + info.renderedLength,
+      0,
+    );
+    if (!total) {
+      owners[SHARED_OWNER] = (owners[SHARED_OWNER] ?? 0) + size;
+      continue;
+    }
+    for (const [id, info] of rendered) {
+      const owner = entryOwner(id, modules);
+      owners[owner] =
+        (owners[owner] ?? 0) + (size * info.renderedLength) / total;
+    }
+  }
+  for (const owner of Object.keys(owners))
+    owners[owner] = Math.round(owners[owner]);
+  return { files: files.map((chunk) => chunk.fileName), bytes, owners };
+}
+
+/**
+ * Records, in the client build, what each frontend module adds to the entry
+ * (`ENTRY_WEIGHT_FILE`). Server builds are left alone: their bundle is no
+ * page's entry.
+ */
+export function recordEntryWeight(modules) {
+  let ssrBuild = false;
+  return {
+    name: "dms-entry-weight",
+    configResolved(config) {
+      ssrBuild = Boolean(config.build.ssr);
+    },
+    // Once the bundle is written: plugins that generate the bundle after this
+    // one still rewrite the chunks' code.
+    writeBundle(options, bundle) {
+      if (ssrBuild || !options.dir) return;
+      const file = join(options.dir, ENTRY_WEIGHT_FILE);
+      mkdirSync(dirname(file), { recursive: true });
+      writeFileSync(
+        file,
+        `${JSON.stringify(attributeEntry(bundle, modules), null, 2)}\n`,
+      );
+    },
+  };
+}