@antelopejs/dms-frontend 0.7.1 → 0.9.0

package/dist/derived-outputs.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DERIVED_OUTPUTS = exports.InvalidLocaleFileError = void 0;
+exports.DERIVED_OUTPUTS = void 0;
 exports.createFrontendModuleRegistry = createFrontendModuleRegistry;
 exports.affectsLocaleMessages = affectsLocaleMessages;
 exports.writeLocaleMessages = writeLocaleMessages;
@@ -8,9 +8,11 @@ const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
 const config_1 = require("./config");
 const app_configs_1 = require("./app-configs");
+const locale_files_1 = require("./locale-files");
 const asset_roots_1 = require("./asset-roots");
 const layer_aliases_1 = require("./layer-aliases");
 const layers_1 = require("./layers");
+const project_modules_1 = require("./project-modules");
 const fs_sync_1 = require("./fs-sync");
 const GENERATED_MODULE_ID = /^[A-Za-z0-9_-]+$/;
 function validateFrontendModuleRegistry(registry, workspaceDir) {
@@ -42,6 +44,7 @@ function createFrontendModuleRegistry(workspaceDir, layers) {
             id: (0, layers_1.getLayerSafeName)(layer),
             name: layer.name ?? layer.packageName,
             packageName: layer.packageName,
+            version: (0, project_modules_1.readShippingVersion)(layer.sourcePath ?? layer.path),
             root: (0, layers_1.getLayerWorkspacePath)(workspaceDir, layer),
             priority: layer.priority ?? 0,
             entry: (0, node_fs_1.existsSync)(sourceEntry) ? config_1.FRONTEND_MODULE_ENTRY : undefined,
@@ -72,7 +75,7 @@ function writeFrontendModuleLoader(workspaceDir, registry) {
         .map((module, index) => `import module${index} from "@frontend/${module.id}/${module.entry}";`)
         .join("\n");
     const registrations = modules
-        .map((module, index) => `{ name: ${JSON.stringify(module.name)}, module: module${index}, options: { public: ${JSON.stringify(module.options)} } }`)
+        .map((module, index) => `{ id: ${JSON.stringify(module.id)}, name: ${JSON.stringify(module.name)}, module: module${index}, options: { public: ${JSON.stringify(module.options)} } }`)
         .join(", ");
     const content = `${imports}\n\nimport type { DmsFrontendModuleRegistration } from "./frontend-module";\n\nexport const frontendModules: DmsFrontendModuleRegistration[] = [${registrations}];\n`;
     return (0, fs_sync_1.applyContent)(content, (0, node_path_1.join)(workspaceDir, "frontend-modules.generated.ts"));
@@ -85,7 +88,7 @@ function writeFrontendBuildLoader(workspaceDir, registry) {
     const declarations = modules
         .map((module, index) => `{ id: ${JSON.stringify(module.id)}, setup: build${index} }`)
         .join(", ");
-    const content = `${imports}\n\nimport type { FrontendBuildDeclaration } from "./frontend-build-loader";\n\nexport const frontendBuilds: FrontendBuildDeclaration[] = [${declarations}];\n`;
+    const content = `${imports}\n\nimport type { FrontendBuildDeclaration } from "./frontend-build-loader.ts";\n\nexport const frontendBuilds: FrontendBuildDeclaration[] = [${declarations}];\n`;
     return (0, fs_sync_1.applyContent)(content, (0, node_path_1.join)(workspaceDir, "frontend-builds.generated.ts"));
 }
 function writeServerModuleLoader(workspaceDir, registry) {
@@ -148,24 +151,6 @@ function mergeLocaleMessages(source, existing) {
     return merged;
 }
 const LOCALE_DIRECTORY = "i18n/locales";
-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;
-function readLocaleFile(path) {
-    try {
-        return 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);
-    }
-}
 function readLocaleMessages(assets, registry) {
     const roots = new Map(registry.modules.map((module) => [module.id, module.root]));
     const messages = {};
@@ -174,7 +159,7 @@ function readLocaleMessages(assets, registry) {
         const root = roots.get(asset.moduleId);
         if (!locale || !root)
             continue;
-        const value = readLocaleFile((0, node_path_1.join)(root, asset.relativePath));
+        const value = (0, locale_files_1.readLocaleFile)((0, node_path_1.join)(root, asset.relativePath));
         messages[locale] = mergeLocaleMessages(value, messages[locale] ?? {});
     }
     return messages;
@@ -182,13 +167,28 @@ function readLocaleMessages(assets, registry) {
 function affectsLocaleMessages(relativePath) {
     return (0, asset_roots_1.affectsAssetDirectory)(LOCALE_DIRECTORY, relativePath);
 }
+const FALLBACK_LOCALE = "en";
+const RENDERER_TRANSLATED_KEYS = ["error.network"];
+function withoutMessage(messages, key) {
+    const [head, ...rest] = key.split(".");
+    if (!(head in messages))
+        return messages;
+    const { [head]: value, ...others } = messages;
+    if (!rest.length)
+        return others;
+    if (!isRecord(value))
+        return messages;
+    const remaining = withoutMessage(value, rest.join("."));
+    return Object.keys(remaining).length
+        ? { ...others, [head]: remaining }
+        : others;
+}
 function localeModuleSource(supportedLocales) {
-    const loaders = supportedLocales
-        .filter((locale) => locale !== "en")
-        .map((locale) => `  ${JSON.stringify(locale)}: () => import(${JSON.stringify(`./locales.generated/${locale}`)}),`);
-    return `import defaultMessages from "./locales.generated/en";
-
-type LocaleMessages = Record<string, unknown>;
+    const loaders = supportedLocales.map((locale) => `  ${JSON.stringify(locale)}: () => import(${JSON.stringify(`./locales.generated/${locale}`)}),`);
+    const fallback = supportedLocales.includes(FALLBACK_LOCALE)
+        ? FALLBACK_LOCALE
+        : supportedLocales[0];
+    return `type LocaleMessages = Record<string, unknown>;
 type LocaleLoader = () => Promise<{ default: LocaleMessages }>;
 interface LocaleMessagesTarget {
   setLocaleMessage(locale: string, messages: LocaleMessages): void;
@@ -200,13 +200,13 @@ interface LocaleState {
 }
 
 export const supportedLocales = ${JSON.stringify(supportedLocales)};
+const fallbackLocale: string | undefined = ${JSON.stringify(fallback)};
 const localeLoaders: Record<string, LocaleLoader> = {
-  "en": async () => ({ default: defaultMessages }),
 ${loaders.join("\n")}
 };
 const shared: LocaleState | undefined = import.meta.hot?.data.state;
 const state: LocaleState = shared ?? {
-  messages: { en: defaultMessages },
+  messages: {},
   targets: new Set(),
   version: 0,
 };
@@ -216,11 +216,20 @@ async function readLocaleMessages(locale: string): Promise<LocaleMessages> {
   return (await localeLoaders[locale]()).default;
 }
 
-export async function loadLocaleMessages(locale: string): Promise<LocaleMessages> {
+/**
+ * The catalog that serves \`locale\`: its own when the application has one,
+ * else the fallback locale's.
+ */
+export function catalogLocale(locale: string): string | undefined {
   const normalized = locale.slice(0, 2);
-  if (!localeLoaders[normalized]) return localeMessages.en;
-  localeMessages[normalized] ??= await readLocaleMessages(normalized);
-  return localeMessages[normalized];
+  return normalized in localeLoaders ? normalized : fallbackLocale;
+}
+
+export async function loadLocaleMessages(locale: string): Promise<LocaleMessages> {
+  const catalog = catalogLocale(locale);
+  if (!catalog) return {};
+  localeMessages[catalog] ??= await readLocaleMessages(catalog);
+  return localeMessages[catalog];
 }
 
 /** Development only: applies every regenerated catalog to \`target\`. */
@@ -262,10 +271,14 @@ function writeLocaleMessages(workspaceDir, registry) {
         changed = (0, fs_sync_1.applyContent)(content, path) || changed;
     };
     (0, node_fs_1.mkdirSync)(outputDir, { recursive: true });
+    const fallback = RENDERER_TRANSLATED_KEYS.reduce(withoutMessage, messages[FALLBACK_LOCALE] ?? {});
     for (const [locale, value] of Object.entries(messages)) {
         const catalog = JSON.stringify(value);
+        const complete = locale === FALLBACK_LOCALE
+            ? catalog
+            : JSON.stringify(mergeLocaleMessages(fallback, value));
         apply(catalog, (0, node_path_1.join)(outputDir, `${locale}.json`));
-        apply(`const messages = ${catalog};\nexport default messages;\n`, (0, node_path_1.join)(outputDir, `${locale}.ts`));
+        apply(`const messages = ${complete};\nexport default messages;\n`, (0, node_path_1.join)(outputDir, `${locale}.ts`));
         outputs.add(`${locale}.json`).add(`${locale}.ts`);
     }
     const supportedLocales = Object.keys(messages);

package/dist/dev-modules.d.ts

@@ -0,0 +1,5 @@
+import type { ProjectFrontendModule, ProjectModulesOptions } from "./project-modules";
+import type { Manifest, ResolvedLayer } from "./workspace";
+export declare function readProjectModulesFresh(options: ProjectModulesOptions): Promise<ProjectFrontendModule[]>;
+export declare function warnModuleDrift(layers: readonly ResolvedLayer[], manifest: Manifest): void;
+export declare function withBackendValues(modules: readonly ProjectFrontendModule[], manifest: Manifest): ResolvedLayer[];

package/dist/dev-modules.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readProjectModulesFresh = readProjectModulesFresh;
+exports.warnModuleDrift = warnModuleDrift;
+exports.withBackendValues = withBackendValues;
+const node_child_process_1 = require("node:child_process");
+const cli_1 = require("@antelopejs/core/cli");
+const private_values_1 = require("./private-values");
+function readProjectModulesFresh(options) {
+    return new Promise((resolve, reject) => {
+        const child = (0, node_child_process_1.fork)(require.resolve("./project-modules-child"), [], {
+            stdio: ["ignore", "inherit", "inherit", "ipc"],
+        });
+        let reply;
+        child.once("message", (message) => {
+            reply = message;
+        });
+        child.once("error", reject);
+        child.once("exit", (code, signal) => {
+            if (!reply) {
+                reject(new Error(`Reading the project's modules stopped (${signal ?? `exit code ${code}`})`));
+                return;
+            }
+            const ui = (0, cli_1.getProcessUi)();
+            for (const message of reply.messages)
+                ui.message(...message);
+            if ("modules" in reply)
+                resolve(reply.modules);
+            else if ("problem" in reply)
+                reject(new cli_1.CliError(reply.problem));
+            else
+                reject(new Error(reply.failure));
+        });
+        child.send(options);
+    });
+}
+const URL_BOUNDARY = "(?=[/?#]|$)";
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function rewriteOrigins(options, rewrites) {
+    if (rewrites.length === 0)
+        return options;
+    const replacements = new Map(rewrites.map(({ from, to }) => [from, to]));
+    const alternation = [...replacements.keys()]
+        .sort((left, right) => right.length - left.length)
+        .map(escapeRegExp)
+        .join("|");
+    const pattern = new RegExp(`(?:${alternation})${URL_BOUNDARY}`, "g");
+    const rewrite = (value) => {
+        if (typeof value === "string")
+            return value.replace(pattern, (match) => replacements.get(match) ?? match);
+        if (Array.isArray(value))
+            return value.map(rewrite);
+        if (value !== null && typeof value === "object")
+            return rewriteObject(value);
+        return value;
+    };
+    const rewriteObject = (value) => Object.fromEntries(Object.entries(value).map(([key, item]) => [key, rewrite(item)]));
+    return rewriteObject(options);
+}
+function warnModuleDrift(layers, manifest) {
+    const served = new Set(layers.map((layer) => layer.name ?? ""));
+    const registered = new Set(manifest.modules.map((module) => module.name));
+    const ui = (0, cli_1.getProcessUi)();
+    for (const name of served) {
+        if (!registered.has(name))
+            ui.message("warn", `${name} is served from the project, but the backend does not register it`, {
+                detail: "Its frontendModule returns a registration the running backend did not add: check the module's configuration and startup",
+            });
+    }
+    for (const name of registered) {
+        if (!served.has(name))
+            ui.message("warn", `${name} is registered by the backend, but not in the project: its pages are left out`, {
+                detail: `A build leaves it out too. Declare its frontendModule (dmsFrontend in its package.json), or add the module to antelope.config.ts`,
+            });
+    }
+}
+function withBackendValues(modules, manifest) {
+    const registered = new Map(manifest.modules.map((module) => [module.name, module]));
+    return modules.map(({ layer }) => ({
+        ...layer,
+        options: layer.options &&
+            rewriteOrigins(layer.options, manifest.originRewrites ?? []),
+        privateOptions: layer.privateOptions &&
+            (0, private_values_1.filledOptions)(layer.privateOptions, registered.get(layer.name ?? "")?.privateOptions),
+    }));
+}

package/dist/entry-weight.d.ts

@@ -0,0 +1,24 @@
+export declare const ENTRY_WEIGHT_VARIABLE = "DMS_ENTRY_WEIGHT_WARNING";
+export declare const DEFAULT_ENTRY_WEIGHT_WARNING_KB = 50;
+export interface EntryShare {
+    owner: string;
+    bytes: number;
+    brotli: number;
+}
+export interface EntryWeight {
+    bytes: number;
+    brotli: number;
+    shares: EntryShare[];
+}
+export declare function readEntryWeight(workspaceDir: string): EntryWeight | undefined;
+export declare function entryWeightThreshold(env: NodeJS.ProcessEnv): number;
+export declare function heavyEntryModules(weight: EntryWeight, threshold: number): EntryShare[];
+export declare function describeEntryShares(weight: EntryWeight): string[];
+interface ReportUi {
+    message(level: "info" | "warn", text: string, options?: {
+        detail?: string;
+        details?: string[];
+    }): void;
+}
+export declare function reportEntryWeight(ui: ReportUi, workspaceDir: string, env: NodeJS.ProcessEnv): void;
+export {};

package/dist/entry-weight.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_ENTRY_WEIGHT_WARNING_KB = exports.ENTRY_WEIGHT_VARIABLE = void 0;
+exports.readEntryWeight = readEntryWeight;
+exports.entryWeightThreshold = entryWeightThreshold;
+exports.heavyEntryModules = heavyEntryModules;
+exports.describeEntryShares = describeEntryShares;
+exports.reportEntryWeight = reportEntryWeight;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const node_zlib_1 = require("node:zlib");
+const cli_1 = require("@antelopejs/core/cli");
+const output_1 = require("./output");
+exports.ENTRY_WEIGHT_VARIABLE = "DMS_ENTRY_WEIGHT_WARNING";
+exports.DEFAULT_ENTRY_WEIGHT_WARNING_KB = 50;
+const ENTRY_WEIGHT_FILE = (0, node_path_1.join)("dist", "client", ".vite", "entry-weight.json");
+const SHARED_OWNER = "shared";
+const TRANSLATIONS_OWNER = "translations";
+const NON_MODULE_OWNERS = new Set([SHARED_OWNER, TRANSLATIONS_OWNER]);
+const BYTES_PER_KB = 1024;
+function brotliSize(file) {
+    const compressed = `${file}.br`;
+    if ((0, node_fs_1.existsSync)(compressed))
+        return (0, node_fs_1.statSync)(compressed).size;
+    return (0, node_zlib_1.brotliCompressSync)((0, node_fs_1.readFileSync)(file), {
+        params: { [node_zlib_1.constants.BROTLI_PARAM_QUALITY]: node_zlib_1.constants.BROTLI_MAX_QUALITY },
+    }).length;
+}
+function readEntryWeight(workspaceDir) {
+    const path = (0, node_path_1.join)(workspaceDir, ENTRY_WEIGHT_FILE);
+    if (!(0, node_fs_1.existsSync)(path))
+        return undefined;
+    const recorded = JSON.parse((0, node_fs_1.readFileSync)(path, "utf8"));
+    const brotli = recorded.files.reduce((sum, file) => sum + brotliSize((0, node_path_1.join)(workspaceDir, "dist", "client", file)), 0);
+    const ratio = recorded.bytes ? brotli / recorded.bytes : 0;
+    const shares = Object.entries(recorded.owners)
+        .map(([owner, bytes]) => ({
+        owner,
+        bytes,
+        brotli: Math.round(bytes * ratio),
+    }))
+        .sort((left, right) => right.bytes - left.bytes);
+    return { bytes: recorded.bytes, brotli, shares };
+}
+function entryWeightThreshold(env) {
+    const value = env[exports.ENTRY_WEIGHT_VARIABLE]?.trim();
+    if (!value)
+        return exports.DEFAULT_ENTRY_WEIGHT_WARNING_KB * BYTES_PER_KB;
+    const kilobytes = Number(value);
+    if (!Number.isFinite(kilobytes) || kilobytes < 0)
+        throw new cli_1.CliError({
+            title: `${exports.ENTRY_WEIGHT_VARIABLE} is not a size`,
+            reason: `It is ${JSON.stringify(value)}; it takes a number of KB of Brotli.`,
+            fixes: [
+                `Set ${exports.ENTRY_WEIGHT_VARIABLE}=${exports.DEFAULT_ENTRY_WEIGHT_WARNING_KB}, or 0 to turn the warning off`,
+            ],
+        });
+    return kilobytes * BYTES_PER_KB;
+}
+function heavyEntryModules(weight, threshold) {
+    if (threshold <= 0)
+        return [];
+    return weight.shares.filter((share) => !NON_MODULE_OWNERS.has(share.owner) && share.brotli > threshold);
+}
+function describeEntryShares(weight) {
+    return weight.shares.map((share) => `${share.owner}  ${(0, output_1.formatSize)(share.brotli)} (${(0, output_1.formatSize)(share.bytes)})`);
+}
+function reportEntryWeight(ui, workspaceDir, env) {
+    const threshold = entryWeightThreshold(env);
+    const weight = readEntryWeight(workspaceDir);
+    if (!weight)
+        return;
+    ui.message("info", `Client entry ${(0, output_1.formatSize)(weight.brotli)} Brotli (${(0, output_1.formatSize)(weight.bytes)}), loaded first by every page`, { details: describeEntryShares(weight) });
+    const heavy = heavyEntryModules(weight, threshold);
+    heavy.forEach((share, index) => {
+        const isLast = index === heavy.length - 1;
+        ui.message("warn", `${share.owner} adds ${(0, output_1.formatSize)(share.brotli)} Brotli to the client entry`, {
+            details: isLast
+                ? [
+                    "What a module's dms.frontend.ts and its plugins import is loaded by every page: render a component they only show on some pages by its registered name or with defineAsyncComponent",
+                    `The threshold is ${(0, output_1.formatSize)(threshold)} (${exports.ENTRY_WEIGHT_VARIABLE}, in KB; 0 turns the warning off)`,
+                ]
+                : [],
+        });
+    });
+}

package/dist/fs-sync.d.ts

@@ -2,6 +2,7 @@ export declare function stripExtendedLengthPrefix(p: string): string;
 export declare function toPosixPath(path: string, separator?: string): string;
 export declare function isBlocklistedCopyPath(src: string, srcPath: string): boolean;
 export declare function sanitizedPackageContent(raw: string): string;
+export declare function sanitizedBuildDeclaration(raw: string): string;
 export declare function filesIdentical(srcPath: string, destPath: string): boolean;
 export declare function applyContent(content: string, destPath: string): boolean;
 export declare function applyFile(srcPath: string, destPath: string): boolean;

package/dist/fs-sync.js

@@ -7,6 +7,7 @@ exports.stripExtendedLengthPrefix = stripExtendedLengthPrefix;
 exports.toPosixPath = toPosixPath;
 exports.isBlocklistedCopyPath = isBlocklistedCopyPath;
 exports.sanitizedPackageContent = sanitizedPackageContent;
+exports.sanitizedBuildDeclaration = sanitizedBuildDeclaration;
 exports.filesIdentical = filesIdentical;
 exports.applyContent = applyContent;
 exports.applyFile = applyFile;
@@ -39,6 +40,11 @@ function sanitizedPackageContent(raw) {
     }
     return `${JSON.stringify(pkg, null, 2)}\n`;
 }
+const BUILD_HELPER_IMPORT = /(["'])#dms\/frontend-build\1/g;
+const BUILD_HELPER_FROM_MODULE_ROOT = "../../frontend-build.ts";
+function sanitizedBuildDeclaration(raw) {
+    return raw.replace(BUILD_HELPER_IMPORT, (_, quote) => `${quote}${BUILD_HELPER_FROM_MODULE_ROOT}${quote}`);
+}
 function filesIdentical(srcPath, destPath) {
     if (!(0, node_fs_1.existsSync)(destPath))
         return false;

package/dist/help.js

@@ -15,7 +15,15 @@ exports.ENVIRONMENT_VARIABLES = [
     ],
     ["DMS_OFFLINE", "Same as --offline, unless 0, false, no or off"],
     ["DMS_WORKSPACE_DIR", "Same as build and start --workspace"],
+    [
+        "ANTELOPEJS_LAUNCH_ENV",
+        "AntelopeJS environment dev, build and start evaluate the project in, same as -e",
+    ],
     ["DMS_PREPARE_STRICT", "Same as prepare --strict, read like DMS_OFFLINE"],
+    [
+        "DMS_ENTRY_WEIGHT_WARNING",
+        "KB of Brotli a module may add to the client entry before build warns (default: 50; 0: never)",
+    ],
     ["PORT", "Same as -p"],
     [
         "HOST",
@@ -29,6 +37,10 @@ exports.ENVIRONMENT_VARIABLES = [
         "NODE_ENV",
         "Build of Vue and its libraries the server loads (default: development in dev, production in start)",
     ],
+    [
+        "DMS_CLIENT_IP_HEADER",
+        "Header the hosting platform overwrites with the client's address, e.g. X-Client-IP (default: none)",
+    ],
     [
         "DMS_TRUSTED_PROXY_HOPS",
         "Trusted reverse-proxy hops, counted from the right (default: 0)",
@@ -61,10 +73,6 @@ exports.ENVIRONMENT_VARIABLES = [
         "DMS_BACKEND_PROXIES",
         "More backend prefixes the server proxies, as a JSON array of { path, auth? }",
     ],
-    [
-        "DMS_BACKEND_WAKE_BUDGET_MS",
-        "How long a GET or HEAD waits out a waking or starting backend's 503, in ms (default: 30000; 0: never)",
-    ],
     ["DMS_CLIENT_BASE_URL", "Public frontend URL used in links and e-mails"],
     ["NO_COLOR", "Same as --no-color"],
     ["ANTELOPEJS_VERBOSE", "Same as --verbose"],

package/dist/index.js

@@ -8,7 +8,6 @@ const build_1 = require("./commands/build");
 const clean_1 = require("./commands/clean");
 const dev_1 = require("./commands/dev");
 const prepare_1 = require("./commands/prepare");
-const snapshot_1 = require("./commands/snapshot");
 const start_1 = require("./commands/start");
 const verify_source_1 = require("./commands/verify-source");
 const workspaces_1 = require("./commands/workspaces");
@@ -29,12 +28,12 @@ const ROOT_EXAMPLES = [
         command: "ajs dms dev",
     },
     {
-        description: "Build for production, then serve the build",
-        command: "ajs dms build -b https://dms.example.com",
+        description: "Build for production from the project root, without a backend",
+        command: "ajs dms build",
     },
     {
-        description: "Serve it on another port",
-        command: "ajs dms start -b https://dms.example.com -p 3001",
+        description: "Serve the build against its backend, on another port",
+        command: "ajs dms start -b https://api.example.com -p 3001",
     },
 ];
 function describeVersion(version, width) {
@@ -117,7 +116,6 @@ const runCLI = async () => {
     program.addCommand((0, dev_1.cmdDev)());
     program.addCommand((0, build_1.cmdBuild)());
     program.addCommand((0, start_1.cmdStart)());
-    program.addCommand((0, snapshot_1.cmdSnapshot)());
     program.addCommand((0, prepare_1.cmdPrepare)());
     program.addCommand((0, workspaces_1.cmdWorkspaces)());
     program.addCommand((0, clean_1.cmdClean)());

package/dist/layer-watch.js

@@ -9,8 +9,10 @@ const node_path_1 = require("node:path");
 const cli_1 = require("@antelopejs/core/cli");
 const chokidar_1 = __importDefault(require("chokidar"));
 const child_output_1 = require("./child-output");
+const config_1 = require("./config");
 const layers_1 = require("./layers");
 const derived_outputs_1 = require("./derived-outputs");
+const locale_files_1 = require("./locale-files");
 const output_1 = require("./output");
 const fs_sync_1 = require("./fs-sync");
 const WATCH_DEBOUNCE_MS = 80;
@@ -62,6 +64,9 @@ function createLayerSync(src, dest, reporter, onStaged) {
             if (rel === "package.json") {
                 (0, fs_sync_1.applyContent)((0, fs_sync_1.sanitizedPackageContent)((0, node_fs_1.readFileSync)(srcPath, "utf-8")), destPath);
             }
+            else if (rel === config_1.FRONTEND_BUILD_ENTRY) {
+                (0, fs_sync_1.applyContent)((0, fs_sync_1.sanitizedBuildDeclaration)((0, node_fs_1.readFileSync)(srcPath, "utf-8")), destPath);
+            }
             else {
                 (0, fs_sync_1.applyFile)(srcPath, destPath);
             }
@@ -124,11 +129,11 @@ function createLayerSync(src, dest, reporter, onStaged) {
 }
 function describeOutputFailure(output, err, reporter) {
     const kept = `The dev server keeps the previous ${output.name} until the file is fixed.`;
-    if (err instanceof derived_outputs_1.InvalidLocaleFileError) {
+    if (err instanceof locale_files_1.InvalidLocaleFileError) {
         const file = reporter.show(err.path);
         return {
             text: `${file} is not a valid locale file`,
-            options: { details: [err.reason, kept] },
+            options: { details: [...err.reason.split("\n"), kept] },
             fixed: [`${file} fixed`, `${output.name} regenerated`].join((0, cli_1.getProcessUi)().symbols.separator),
         };
     }

package/dist/layers.d.ts

@@ -7,15 +7,14 @@ interface PathlessManifestSource {
     };
 }
 export declare function assertLayerPathsServed(modules: ManifestModule[], backendUrl: string, { bootstrapSecret, cache }?: PathlessManifestSource): asserts modules is ServedWithPath[];
-export declare function assertCachedArchivesExist(modules: ManifestModule[], cacheDir: string, fetchedAt?: string): void;
 export interface LayerPackage {
     name?: unknown;
     engines?: Record<string, unknown>;
+    dmsFrontend?: unknown;
+    antelopeJs?: unknown;
 }
 export declare function readLayerPackage(layerPath: string): LayerPackage | undefined;
 export declare function buildLayersFromPaths(modules: ServedWithPath[]): ResolvedLayer[];
-export declare function downloadAndExtractLayers(backendUrl: string, packUrl: string, cacheDir: string, force: boolean, bootstrapSecret?: string): Promise<void>;
-export declare function buildLayersFromCache(modules: ManifestModule[], cacheDir: string): Promise<ResolvedLayer[]>;
 export declare function getLayerSafeName(layer: ResolvedLayer): string;
 export declare function getLayerWorkspacePath(workspaceDir: string, layer: ResolvedLayer): string;
 export {};

package/dist/layers.js

@@ -1,57 +1,17 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.assertLayerPathsServed = assertLayerPathsServed;
-exports.assertCachedArchivesExist = assertCachedArchivesExist;
 exports.readLayerPackage = readLayerPackage;
 exports.buildLayersFromPaths = buildLayersFromPaths;
-exports.downloadAndExtractLayers = downloadAndExtractLayers;
-exports.buildLayersFromCache = buildLayersFromCache;
 exports.getLayerSafeName = getLayerSafeName;
 exports.getLayerWorkspacePath = getLayerWorkspacePath;
 const node_fs_1 = require("node:fs");
-const promises_1 = require("node:fs/promises");
 const node_path_1 = require("node:path");
-const node_stream_1 = require("node:stream");
-const consumers_1 = require("node:stream/consumers");
 const cli_1 = require("@antelopejs/core/cli");
 const manifest_1 = require("./manifest");
-const fs_sync_1 = require("./fs-sync");
 const config_1 = require("./config");
 const output_1 = require("./output");
-const BUILD_FIX = "A remote or production backend never sends them: use `ajs dms build` against it";
+const BUILD_FIX = "A remote or production backend never sends them: build the frontend from the project instead, with `ajs dms build`";
 function assertLayerPathsServed(modules, backendUrl, { bootstrapSecret, cache } = {}) {
     const pathless = modules.filter((mod) => !mod.path);
     if (pathless.length === 0)
@@ -87,17 +47,6 @@ function assertLayerPathsServed(modules, backendUrl, { bootstrapSecret, cache }
         fixes: [fix, BUILD_FIX],
     });
 }
-function assertCachedArchivesExist(modules, cacheDir, fetchedAt) {
-    const present = new Set((0, node_fs_1.readdirSync)(cacheDir));
-    const missing = modules.filter((mod) => !present.has(mod.archiveName));
-    if (missing.length === 0)
-        return;
-    throw new cli_1.CliError({
-        title: `The cached layers archive is missing entries listed in the manifest${fetchedAt ? ` (fetched ${(0, output_1.formatAge)(fetchedAt)})` : ""}`,
-        fixes: ["Run once with the backend reachable to download the layers again"],
-        details: missing.map((mod) => `${mod.name}: ${mod.archiveName}`),
-    });
-}
 function sortModulesByPriority(modules) {
     return [...modules].sort((a, b) => b.priority - a.priority);
 }
@@ -134,49 +83,6 @@ function resolveLayer(layerPath, mod) {
 function buildLayersFromPaths(modules) {
     return sortModulesByPriority(modules).map((mod) => resolveLayer(mod.path, mod));
 }
-async function downloadAndExtractLayers(backendUrl, packUrl, cacheDir, force, bootstrapSecret) {
-    const url = (0, manifest_1.backendEndpoint)(backendUrl, packUrl);
-    const response = await (0, manifest_1.fetchFromBackend)(backendUrl, url, bootstrapSecret);
-    if (!response.ok) {
-        throw new manifest_1.BackendResponseError("the layers archive", url, response);
-    }
-    if (!response.body) {
-        throw new Error(`The layers archive from ${(0, manifest_1.displayUrl)(url)} came without a body`);
-    }
-    const modulesBlob = await (0, consumers_1.buffer)(node_stream_1.Readable.fromWeb(response.body));
-    const { Open } = await Promise.resolve().then(() => __importStar(require("unzipper")));
-    const cacheExists = (0, node_fs_1.existsSync)(cacheDir);
-    if (force || !cacheExists) {
-        if (cacheExists) {
-            (0, node_fs_1.rmSync)(cacheDir, { recursive: true, force: true });
-        }
-        await (await Open.buffer(modulesBlob)).extract({ path: cacheDir });
-        return;
-    }
-    const tempDir = `${cacheDir}_temp`;
-    if ((0, node_fs_1.existsSync)(tempDir)) {
-        (0, node_fs_1.rmSync)(tempDir, { recursive: true, force: true });
-    }
-    await (await Open.buffer(modulesBlob)).extract({ path: tempDir });
-    const tempEntries = (0, node_fs_1.readdirSync)(tempDir);
-    for (const entry of tempEntries) {
-        (0, fs_sync_1.syncDirectories)((0, node_path_1.join)(tempDir, entry), (0, node_path_1.join)(cacheDir, entry));
-    }
-    (0, node_fs_1.rmSync)(tempDir, { recursive: true, force: true });
-}
-async function buildLayersFromCache(modules, cacheDir) {
-    if (!(0, node_fs_1.existsSync)(cacheDir))
-        return [];
-    const layerFiles = await (0, promises_1.readdir)(cacheDir);
-    const layers = [];
-    for (const mod of sortModulesByPriority(modules)) {
-        if (!layerFiles.includes(mod.archiveName))
-            continue;
-        const layerPath = (0, node_path_1.join)(cacheDir, mod.archiveName);
-        layers.push(resolveLayer(layerPath, mod));
-    }
-    return layers;
-}
 function getLayerSafeName(layer) {
     if (layer.packageName) {
         return layer.packageName.replace(/^@/, "").replace(/\//g, "__");

package/dist/locale-files.d.ts

@@ -0,0 +1,6 @@
+export declare class InvalidLocaleFileError extends Error {
+    readonly path: string;
+    readonly reason: string;
+    constructor(path: string, reason: string);
+}
+export declare function readLocaleFile(path: string): Record<string, unknown>;