@antelopejs/dms-frontend 0.7.1 → 0.9.0

package/dist/project-modules.js

@@ -0,0 +1,268 @@
+"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.FRONTEND_DECLARATION_FIELD = void 0;
+exports.loadProjectConfig = loadProjectConfig;
+exports.readShippingVersion = readShippingVersion;
+exports.readProjectFrontendModules = readProjectFrontendModules;
+const node_fs_1 = require("node:fs");
+const fsPromises = __importStar(require("node:fs/promises"));
+const node_path_1 = require("node:path");
+const cli_1 = require("@antelopejs/core/cli");
+const layers_1 = require("./layers");
+const private_values_1 = require("./private-values");
+exports.FRONTEND_DECLARATION_FIELD = "dmsFrontend";
+const FRONTEND_SOURCE_DIR = "frontend-vue";
+const RENDERER = { name: "vue", version: "3" };
+const CONFIG_VAR_PATTERN = /\$\{@([^.}]+)\.([^}]+)\}/g;
+const PURE_CONFIG_VAR = /^\$\{@([^.}]+)\.([^}]+)\}$/;
+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),
+    writeFile: (path, data) => fsPromises.writeFile(path, data),
+    readdir: (path) => fsPromises.readdir(path),
+    stat: (path) => fsPromises.stat(path),
+    mkdir: async (path, options) => {
+        await fsPromises.mkdir(path, options);
+    },
+    rm: (path, options) => fsPromises.rm(path, options),
+    exists: async (path) => (0, node_fs_1.existsSync)(path),
+    access: (path) => fsPromises.access(path),
+    copyFile: (src, dest) => fsPromises.copyFile(src, dest),
+    rename: (oldPath, newPath) => fsPromises.rename(oldPath, newPath),
+};
+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, lookup) {
+    if (typeof value === "string") {
+        const pure = value.match(PURE_CONFIG_VAR);
+        if (pure)
+            return lookup(pure[1], pure[2]);
+        return value.replace(CONFIG_VAR_PATTERN, (token, module, name) => {
+            const resolved = lookup(module, name);
+            return resolved === undefined ? token : String(resolved);
+        });
+    }
+    if (Array.isArray(value))
+        return value.map((item) => substituteConfigVars(item, lookup));
+    if (value && typeof value === "object") {
+        return Object.fromEntries(Object.entries(value).map(([key, item]) => [
+            key,
+            substituteConfigVars(item, lookup),
+        ]));
+    }
+    return value;
+}
+async function loadProjectConfig(projectDir, environment) {
+    const { ConfigLoader } = await Promise.resolve().then(() => __importStar(require("@antelopejs/core")));
+    const loader = new ConfigLoader(NODE_FILE_SYSTEM);
+    let loaded;
+    try {
+        loaded = (await loader.load(projectDir, environment));
+    }
+    catch (error) {
+        throw new cli_1.CliError({
+            title: `Could not evaluate the project's configuration in ${projectDir}`,
+            reason: error instanceof Error ? error.message : String(error),
+            fixes: ["Run from the project root, or pass --project <dir>"],
+        }, { cause: error });
+    }
+    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(located).map(([id, module]) => [
+            id,
+            { ...module, config: substituteConfigVars(module.config, lookup) },
+        ])),
+    };
+}
+function moduleFolder(projectDir, cacheFolder, source) {
+    const candidates = source.type === "local" && source.path
+        ? [(0, node_path_1.resolve)(projectDir, source.path)]
+        : source.package
+            ? [
+                (0, node_path_1.join)(projectDir, "node_modules", source.package),
+                (0, node_path_1.resolve)(projectDir, cacheFolder, source.package),
+            ]
+            : [];
+    return candidates.find((folder) => (0, node_fs_1.existsSync)((0, node_path_1.join)(folder, "package.json")));
+}
+function readShippingVersion(sourcePath) {
+    try {
+        const pkg = JSON.parse((0, node_fs_1.readFileSync)((0, node_path_1.join)((0, node_path_1.dirname)(sourcePath), "package.json"), "utf-8"));
+        return typeof pkg.version === "string" ? pkg.version : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function toLayer(registration) {
+    const name = (0, layers_1.readLayerPackage)(registration.sourcePath)?.name;
+    return {
+        path: registration.sourcePath,
+        name: registration.name,
+        sourcePath: registration.sourcePath,
+        packageName: typeof name === "string" ? name : undefined,
+        priority: registration.priority ?? 0,
+        configKey: registration.configKey,
+        options: registration.options ?? {},
+        privateOptions: registration.privateOptions &&
+            (0, private_values_1.emptiedOptions)(registration.privateOptions),
+        authEstablishEndpoints: registration.authEstablishEndpoints ?? [],
+        publicEndpoints: registration.publicEndpoints ?? [],
+        backendProxies: registration.backendProxies ?? [],
+    };
+}
+function warnMissingModule(id) {
+    (0, cli_1.getProcessUi)().message("warn", `${id} is not installed in the project: its pages, if it has any, are left out`, { detail: "Install the project's modules first: ajs project build" });
+}
+function warnUndeclaredFrontend(id, folder) {
+    if (!(0, node_fs_1.existsSync)((0, node_path_1.join)(folder, FRONTEND_SOURCE_DIR)))
+        return;
+    (0, cli_1.getProcessUi)().message("warn", `${id} ships ${FRONTEND_SOURCE_DIR}/ but declares no ${exports.FRONTEND_DECLARATION_FIELD} in its package.json: its pages are left out`);
+}
+function registrationOf(id, folder, config, context) {
+    const declaration = (0, layers_1.readLayerPackage)(folder)?.[exports.FRONTEND_DECLARATION_FIELD];
+    if (typeof declaration !== "string") {
+        warnUndeclaredFrontend(id, folder);
+        return undefined;
+    }
+    const { frontendModule } = require((0, node_path_1.join)(folder, declaration));
+    if (typeof frontendModule !== "function") {
+        throw new cli_1.CliError({
+            title: `${id}: ${declaration} exports no frontendModule function`,
+            fixes: [`Export frontendModule(config, context) from ${declaration}`],
+        });
+    }
+    return frontendModule(config, context);
+}
+function isServedRenderer(registration) {
+    return (registration.renderer.name === RENDERER.name &&
+        registration.renderer.version === RENDERER.version);
+}
+function keepHighestPriority(registrations) {
+    const byName = new Map();
+    for (const registration of registrations) {
+        const kept = byName.get(registration.name);
+        if (!kept || (kept.priority ?? 0) <= (registration.priority ?? 0))
+            byName.set(registration.name, registration);
+    }
+    return [...byName.values()];
+}
+async function readProjectFrontendModules(options) {
+    const projectDir = (0, node_path_1.resolve)(options.projectDir);
+    const config = await loadProjectConfig(projectDir, options.environment);
+    const context = { dev: !!options.dev };
+    const registrations = Object.entries(config.modules).flatMap(([id, module]) => {
+        const folder = module.folder;
+        if (!folder) {
+            warnMissingModule(id);
+            return [];
+        }
+        const registration = registrationOf(id, folder, module.config, context);
+        return registration && isServedRenderer(registration)
+            ? [registration]
+            : [];
+    });
+    return keepHighestPriority(registrations)
+        .sort((left, right) => (right.priority ?? 0) - (left.priority ?? 0))
+        .map((registration) => ({
+        layer: toLayer(registration),
+        version: readShippingVersion(registration.sourcePath),
+    }));
+}

package/dist/workspace-setup.d.ts

@@ -1,8 +1,8 @@
 import { type ChildProcess, type SpawnOptions } from "node:child_process";
 import { type PathMapper } from "./child-output";
+import { type ProjectModulesOptions } from "./project-modules";
 import { type ManifestSecrets } from "./manifest-secrets";
 import { ResolvedLayer } from "./workspace";
-import { type BuildOrigin, type FrontendSnapshot } from "./snapshot";
 export declare function computeDepsHash(layerPaths: string[], workspacePackage?: string, installInputs?: readonly string[]): string;
 export declare function needsInstall(workspaceDir: string, layerPaths: string[], force: boolean): boolean;
 export declare function saveDepsHash(workspaceDir: string, layerPaths: string[]): void;
@@ -21,18 +21,15 @@ export interface FramedCommandResult {
 }
 export declare function runFramedCommand(command: string, args: string[], options: FramedCommandOptions): Promise<FramedCommandResult>;
 export interface SetupWorkspaceOptions {
-    backendUrl: string;
     force: boolean;
     mode: "dev" | "build";
+    backendUrl?: string;
     offline?: boolean;
     clientUrl?: string;
     workspaceKey?: string;
     bootstrapSecret?: string;
     workspaceDir?: string;
-    snapshot?: {
-        dir: string;
-        snapshot: FrontendSnapshot;
-    };
+    project?: ProjectModulesOptions;
     beforeInstall?: () => Promise<void>;
 }
 export interface SetupWorkspaceResult {
@@ -41,6 +38,5 @@ export interface SetupWorkspaceResult {
     manifestFromCache: boolean;
     manifestFetchedAt?: string;
     manifestSecrets: ManifestSecrets;
-    buildOrigin: BuildOrigin;
 }
 export declare function setupWorkspace(opts: SetupWorkspaceOptions): Promise<SetupWorkspaceResult>;

package/dist/workspace-setup.js

@@ -15,14 +15,16 @@ 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");
 const materialize_1 = require("./materialize");
 const workspace_1 = require("./workspace");
-const snapshot_1 = require("./snapshot");
 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) {
@@ -215,85 +217,90 @@ async function runFramedCommand(command, args, options) {
     await Promise.race([ended, drainTimeout()]);
     return { code, lines: tails.flatMap((tail) => tail.lines()) };
 }
-function manifestCacheUse(mode, offline) {
-    if (offline)
-        return "offline";
-    return mode === "build" ? "never" : "fallback";
-}
-async function snapshotLayers({ dir, snapshot }, workspaceDir) {
-    const { manifest, takenAt } = snapshot;
-    const cacheDir = (0, node_path_1.join)(dir, snapshot_1.SNAPSHOT_LAYERS_DIR);
-    (0, layers_1.assertCachedArchivesExist)(manifest.modules, cacheDir, takenAt);
-    (0, manifest_1.writeCachedManifest)(workspaceDir, manifest, "drop", takenAt);
+async function projectLayers(project) {
+    const modules = await (0, project_modules_1.readProjectFrontendModules)(project);
     return {
-        manifest,
         fromCache: false,
-        layers: await (0, layers_1.buildLayersFromCache)(manifest.modules, cacheDir),
+        layers: modules.map((module) => module.layer),
+        secrets: { published: {}, conflicts: [] },
     };
 }
-async function servedLayers(opts, workspaceDir) {
-    const { backendUrl, force, mode, offline, clientUrl, bootstrapSecret } = opts;
-    const resolved = await (0, manifest_1.resolveManifest)(workspaceDir, backendUrl, manifestCacheUse(mode, offline), {
+function servedManifest(opts, backendUrl, workspaceDir) {
+    const { offline, clientUrl, bootstrapSecret } = opts;
+    const cacheUse = offline ? "offline" : "fallback";
+    return (0, manifest_1.resolveManifest)(workspaceDir, backendUrl, cacheUse, {
         clientUrl,
         bootstrapSecret,
-        privateValues: mode === "build" ? "drop" : "keep",
     });
-    const { manifest, fromCache, fetchedAt } = resolved;
-    if (mode === "dev") {
-        (0, layers_1.assertLayerPathsServed)(manifest.modules, backendUrl, {
-            bootstrapSecret,
-            cache: fromCache ? { fetchedAt } : undefined,
-        });
-        if (fromCache) {
-            (0, manifest_1.assertCachedLayerPathsExist)(manifest.modules, fetchedAt);
-        }
-        return { ...resolved, layers: (0, layers_1.buildLayersFromPaths)(manifest.modules) };
-    }
-    const cacheDir = (0, node_path_1.join)(workspaceDir, ".layers-cache");
+}
+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,
+    });
     if (fromCache) {
-        if (!(0, node_fs_1.existsSync)(cacheDir)) {
-            throw new cli_1.CliError({
-                title: "No layers archive was downloaded for this workspace",
-                fixes: [
-                    "Run once without --offline, with the backend reachable, first",
-                ],
-            });
-        }
-        (0, layers_1.assertCachedArchivesExist)(manifest.modules, cacheDir, fetchedAt);
-    }
-    else {
-        await (0, layers_1.downloadAndExtractLayers)(backendUrl, manifest.pack, cacheDir, force, bootstrapSecret);
+        (0, manifest_1.assertCachedLayerPathsExist)(manifest.modules, fetchedAt);
     }
     return {
-        ...resolved,
-        layers: await (0, layers_1.buildLayersFromCache)(manifest.modules, cacheDir),
+        fromCache,
+        fetchedAt,
+        layers: (0, layers_1.buildLayersFromPaths)(manifest.modules),
+        secrets: (0, manifest_secrets_1.collectManifestSecrets)(manifest.modules),
     };
 }
-async function setupWorkspace(opts) {
-    const { backendUrl, force } = opts;
+function workspaceDirFor(opts) {
+    if (opts.workspaceDir)
+        return (0, workspace_1.ensureExplicitWorkspace)(opts.workspaceDir);
+    const backendUrl = requireDevBackend(opts);
     const workspaceKey = opts.workspaceKey ?? (0, config_1.canonicalizeBackendUrl)(backendUrl);
-    const workspaceDir = opts.workspaceDir
-        ? (0, workspace_1.ensureExplicitWorkspace)(opts.workspaceDir)
-        : (0, workspace_1.ensureWorkspace)(workspaceKey);
+    const workspaceDir = (0, workspace_1.ensureWorkspace)(workspaceKey);
     (0, workspace_1.writeWorkspaceMeta)(workspaceDir, backendUrl, workspaceKey);
-    const { manifest, fromCache, fetchedAt, layers } = opts.snapshot
-        ? await snapshotLayers(opts.snapshot, workspaceDir)
-        : await servedLayers(opts, workspaceDir);
-    const buildOrigin = {
-        source: opts.snapshot ? "snapshot" : "backend",
-        backendUrl: (0, config_1.canonicalizeBackendUrl)(backendUrl),
-        takenAt: opts.snapshot?.snapshot.takenAt ?? fetchedAt ?? new Date().toISOString(),
-        digest: (0, snapshot_1.manifestDigest)(manifest.modules),
-        authenticated: !!opts.snapshot || (!!opts.bootstrapSecret && !fromCache),
-    };
+    return workspaceDir;
+}
+function requireDevBackend(opts) {
+    if (!opts.backendUrl)
+        throw new Error("A dev workspace is set up from a backend URL");
+    return opts.backendUrl;
+}
+function workspaceSource(opts, workspaceDir) {
+    if (opts.mode === "build") {
+        if (!opts.project)
+            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) {
+    const workspaceDir = workspaceDirFor(opts);
+    const { fromCache, fetchedAt, layers, secrets } = await workspaceSource(opts, workspaceDir);
     (0, renderer_range_1.assertLayersSupportRenderer)(layers, { workspaceDir });
     (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, force);
+    const shouldInstall = needsInstall(workspaceDir, layerPaths, opts.force);
     if (shouldInstall) {
         await opts.beforeInstall?.();
         await installDeps(workspaceDir, (0, child_output_1.createPathMapper)(workspaceDir, layers));
@@ -304,7 +311,17 @@ async function setupWorkspace(opts) {
         layers,
         manifestFromCache: fromCache,
         manifestFetchedAt: fetchedAt,
-        manifestSecrets: (0, manifest_secrets_1.collectManifestSecrets)(manifest.modules),
-        buildOrigin,
+        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

@@ -4,7 +4,6 @@ export interface FrontendModuleOptions {
 }
 export interface ManifestModule {
     name: string;
-    archiveName: string;
     renderer?: {
         name: string;
         version: string;
@@ -21,22 +20,27 @@ export interface ManifestModule {
 export interface BackendProxyDeclaration {
     path: string;
     auth?: "session" | "none";
+    maxBodyBytes?: number;
 }
 export interface PublicEndpointDeclaration {
     path: string;
     methods?: string[];
     headers?: string[];
 }
+export interface OriginRewrite {
+    from: string;
+    to: string;
+}
 export interface Manifest {
-    pack: string;
     modules: ManifestModule[];
     settling?: boolean;
+    originRewrites?: OriginRewrite[];
 }
 export interface FrontendManifest {
     version: number;
-    archive: string;
     modules: ManifestModule[];
     settling?: boolean;
+    originRewrites?: OriginRewrite[];
 }
 export interface ResolvedLayer {
     path: string;
@@ -70,6 +74,6 @@ export interface WorkspaceListing {
 export declare function listWorkspaces(): WorkspaceListing;
 export declare function directorySize(dir: string): number;
 export declare function writeWorkspaceMeta(workspaceDir: string, backendUrl: string, workspaceKey: string): void;
-export declare const FRONTEND_MANIFEST_VERSION = 1;
+export declare const FRONTEND_MANIFEST_VERSION = 2;
 export declare function bootstrapHeaders(secret?: string): Record<string, string>;
 export declare function isUnauthorized(status: number): boolean;

package/dist/workspace.js

@@ -131,7 +131,7 @@ function writeWorkspaceMeta(workspaceDir, backendUrl, workspaceKey) {
 }
 const BOOTSTRAP_HEADER = "x-dms-bootstrap";
 const UNAUTHORIZED_STATUSES = [401, 403];
-exports.FRONTEND_MANIFEST_VERSION = 1;
+exports.FRONTEND_MANIFEST_VERSION = 2;
 function bootstrapHeaders(secret) {
     return secret ? { [BOOTSTRAP_HEADER]: secret } : {};
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@antelopejs/dms-frontend",
-  "version": "0.7.1",
+  "version": "0.9.0",
   "description": "Frontend-agnostic loader for AntelopeJS DMS, shipping the Vue 3 renderer (Vite, Inertia, SSR)",
   "keywords": [
     "antelope",
@@ -73,11 +73,11 @@
     "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",
-    "semver": "^7.7.4",
-    "unzipper": "^0.12.3"
+    "semver": "^7.7.4"
   },
   "devDependencies": {
     "@antelopejs/core": "^1.16.0",
@@ -87,10 +87,10 @@
     "@inertiajs/vue3": "^3.7.1",
     "@types/node": "^24.8.1",
     "@types/semver": "^7.7.1",
-    "@types/unzipper": "^0.10.11",
     "@unhead/vue": "^2.1.4",
-    "@vitejs/plugin-vue": "^6.0.1",
+    "@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",
@@ -101,10 +101,10 @@
     "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": "^7.2.4",
+    "vite": "^8.3.4",
     "vue": "^3.5.25",
     "vue-i18n": "^11.2.7"
   },
@@ -119,9 +119,14 @@
     "@oxc-parser/binding-win32-x64-msvc": "^0.95.0"
   },
   "engines": {
-    "node": ">=20.12.0"
+    "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/skills/dms-frontend/SKILL.md

@@ -18,8 +18,8 @@ tags: [frontend, cli, renderer, vue, inertia, ssr, deployment, dms-module]
 
 ## Rules that bite
 
-- **One workspace per backend URL**, under `~/.antelopejs/dms-frontend/<sha256>/`. `dev` without `-b` keys its own on the project directory instead, so `dev` then `build -b` builds a second workspace. `start` serves the workspace `build` made for the same URL, user and home directory.
-- **Secrets.** `build` and `start` need the same `DMS_SESSION_SECRET` (32+ characters); `dev` generates one only when it is unset. `build` takes `DMS_BOOTSTRAP_SECRET` explicitly, never from `.antelope/dms-dev.json`. A build without it still succeeds, but loses the modules' private options, the manifest's backend proxies and the e-mail and OAuth secrets: `start` then warns that e-mail renders and OAuth sign-in will be refused.
+- **One dev workspace per backend URL**, under `~/.antelopejs/dms-frontend/<sha256>/`. `dev` without `-b` keys its own on the project directory instead. A production build is different: `build` reads the project itself (`antelope.config.ts` with `-e production`, each installed module's `dmsFrontend` function), needs no backend, and writes `<project>/.dms-frontend`, which `start` serves from the project root.
+- **Secrets.** `start` needs `DMS_SESSION_SECRET` (32+ characters); `dev` generates one only when it is unset. `build` needs no secret. `start` reads `DMS_HTML_RENDER_SECRET` and `DMS_OAUTH_RELAY_SECRET` from its environment and warns when they are unset, and computes the modules' public options from the project's configuration with its own variables, which must match the backend's.
 - **`.env`** is read from the current directory only (shell, then `.env.local`, then `.env`). A `DMS_API_BASE_URL` in `.env` turns off backend discovery for `dev`. `clean` never reads it.
 - **`prepare` never fails** without `--strict`: it warns and exits 0. Use `--strict` where the types are required.
 - **Exit codes:** 0 success, 1 failure, 2 usage error, 130 Ctrl+C.

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 };