@antelopejs/dms-frontend 0.3.7 → 0.3.9

package/dist/vite-output.d.ts

@@ -0,0 +1,14 @@
+import { type CliProblem, type Ui } from "@antelopejs/core/cli";
+export declare const VITE_LOG_LEVEL_VARIABLE = "DMS_VITE_LOG_LEVEL";
+export declare function viteLogLevel(isVerbose: boolean): string;
+export declare const VERBOSE_VITE_HINT = "Run with --verbose for the full Vite output.";
+export declare class ViteWarnings {
+    private readonly kept;
+    private opened;
+    private isAfterPluginTag;
+    read(line: string): void;
+    get count(): number;
+    lines(): string[];
+}
+export declare function reportViteWarnings(warnings: ViteWarnings, isVerbose: boolean, ui: Ui): void;
+export declare function describeViteFailure(lines: string[], subject: string, isVerbose: boolean, rerun?: string, nameFile?: (file: string) => string): CliProblem | undefined;

package/dist/vite-output.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ViteWarnings = exports.VERBOSE_VITE_HINT = exports.VITE_LOG_LEVEL_VARIABLE = void 0;
+exports.viteLogLevel = viteLogLevel;
+exports.reportViteWarnings = reportViteWarnings;
+exports.describeViteFailure = describeViteFailure;
+const cli_1 = require("@antelopejs/core/cli");
+const output_1 = require("./output");
+exports.VITE_LOG_LEVEL_VARIABLE = "DMS_VITE_LOG_LEVEL";
+function viteLogLevel(isVerbose) {
+    return isVerbose ? "info" : "warn";
+}
+exports.VERBOSE_VITE_HINT = "Run with --verbose for the full Vite output.";
+const WARNING_START = /^(\(!\)|\[plugin[ :][^\]]*\]|\(node:\d+\))/;
+const PLUGIN_TAG_LINE = /^\[plugin[ :][^\]]*\]$/;
+class ViteWarnings {
+    constructor() {
+        this.kept = [];
+        this.opened = 0;
+        this.isAfterPluginTag = false;
+    }
+    read(line) {
+        const text = line.trim();
+        if (text === "")
+            return;
+        this.kept.push(line.trimEnd());
+        const continuesTag = this.isAfterPluginTag && text.startsWith("(!)");
+        if (WARNING_START.test(text) && !continuesTag)
+            this.opened += 1;
+        this.isAfterPluginTag = PLUGIN_TAG_LINE.test(text);
+    }
+    get count() {
+        if (this.opened === 0 && this.kept.length > 0)
+            return 1;
+        return this.opened;
+    }
+    lines() {
+        return [...this.kept];
+    }
+}
+exports.ViteWarnings = ViteWarnings;
+function reportViteWarnings(warnings, isVerbose, ui) {
+    if (isVerbose || warnings.count === 0)
+        return;
+    const title = (0, cli_1.pluralize)(warnings.count, "Vite warning");
+    const details = (0, output_1.isTerminalFeedback)()
+        ? [`${ui.symbols.levels.hint} Run with --verbose to list them`]
+        : warnings.lines();
+    ui.message("warn", title, { details });
+}
+const ERROR_START = "error during build:";
+const FILE_LINE = /^file:\s+(.+)$/;
+const CODE_FRAME_LINE = /^\s*\d*\s*\|/;
+const STACK_FRAME = /^\s+at\s/;
+const LOCATION_SUFFIX = /\s*\(\d+:\d+\)$/;
+const VITE_PLUGIN_TAG = /^\[vite:[^\]]+\]\s+(?=\S)/;
+function errorBlock(lines) {
+    let start = -1;
+    lines.forEach((line, index) => {
+        if (line.trim() === ERROR_START)
+            start = index;
+    });
+    if (start < 0)
+        return undefined;
+    const block = [];
+    for (const line of lines.slice(start + 1)) {
+        if (STACK_FRAME.test(line))
+            break;
+        if (line.trim() !== "")
+            block.push(line.trimEnd());
+    }
+    return block;
+}
+function describeViteFailure(lines, subject, isVerbose, rerun = "ajs dms build", nameFile = (file) => file) {
+    const block = errorBlock(lines);
+    if (!block)
+        return undefined;
+    const [message = "", ...rest] = block;
+    const reason = message
+        .replace(LOCATION_SUFFIX, "")
+        .replace(VITE_PLUGIN_TAG, "");
+    const hint = isVerbose ? [] : [exports.VERBOSE_VITE_HINT];
+    const file = rest
+        .map((line) => FILE_LINE.exec(line.trim())?.[1])
+        .find((match) => match !== undefined);
+    if (file) {
+        return {
+            title: `Vite could not compile ${nameFile(file)}`,
+            reason,
+            fixes: [`Fix the file and run ${rerun} again`],
+            details: [...rest.filter((line) => CODE_FRAME_LINE.test(line)), ...hint],
+        };
+    }
+    return {
+        title: `Vite could not build the ${subject}`,
+        reason,
+        details: [...rest, ...hint],
+    };
+}

package/dist/workspace-setup.d.ts

@@ -1,11 +1,24 @@
-import { type SpawnOptions } from "node:child_process";
+import { type ChildProcess, type SpawnOptions } from "node:child_process";
+import { type PathMapper } from "./child-output";
 import { type ManifestSecrets } from "./manifest-secrets";
 import { ResolvedLayer } from "./workspace";
 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;
-export declare function installDeps(workspaceDir: string): void;
-export declare function runCommand(command: string, args: string[], options?: SpawnOptions): Promise<number>;
+export declare function installDeps(workspaceDir: string, mapLine?: PathMapper, extraArgs?: string[]): Promise<void>;
+export declare function runCommand(command: string, args: string[], options?: SpawnOptions, onSpawn?: (child: ChildProcess) => void): Promise<number>;
+export interface FramedCommandOptions {
+    name: string;
+    cwd: string;
+    env?: NodeJS.ProcessEnv;
+    mapLine?: PathMapper;
+    onLine?: (line: string) => void;
+}
+export interface FramedCommandResult {
+    code: number;
+    lines: string[];
+}
+export declare function runFramedCommand(command: string, args: string[], options: FramedCommandOptions): Promise<FramedCommandResult>;
 export interface SetupWorkspaceOptions {
     backendUrl: string;
     force: boolean;
@@ -14,6 +27,7 @@ export interface SetupWorkspaceOptions {
     clientUrl?: string;
     workspaceKey?: string;
     bootstrapSecret?: string;
+    beforeInstall?: () => Promise<void>;
 }
 export interface SetupWorkspaceResult {
     workspaceDir: string;

package/dist/workspace-setup.js

@@ -5,18 +5,22 @@ exports.needsInstall = needsInstall;
 exports.saveDepsHash = saveDepsHash;
 exports.installDeps = installDeps;
 exports.runCommand = runCommand;
+exports.runFramedCommand = runFramedCommand;
 exports.setupWorkspace = setupWorkspace;
 const node_child_process_1 = require("node:child_process");
 const node_crypto_1 = require("node:crypto");
 const node_fs_1 = require("node:fs");
-const node_os_1 = require("node:os");
 const node_path_1 = require("node:path");
+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 manifest_secrets_1 = require("./manifest-secrets");
 const renderer_range_1 = require("./renderer-range");
 const materialize_1 = require("./materialize");
 const workspace_1 = require("./workspace");
+const cancellation_1 = require("./cancellation");
+const output_1 = require("./output");
 const config_1 = require("./config");
 const WORKSPACE_PNPM_CONFIG = "pnpm-workspace.yaml";
 const WORKSPACE_PATCHES_DIR = "patches";
@@ -61,48 +65,77 @@ function saveDepsHash(workspaceDir, layerPaths) {
     const hash = computeDepsHash(layerPaths, (0, node_path_1.join)(workspaceDir, "package.json"), workspaceInstallInputs(workspaceDir));
     (0, node_fs_1.writeFileSync)((0, node_path_1.join)(workspaceDir, config_1.DEPS_HASH_FILE), hash);
 }
-function installDeps(workspaceDir) {
-    const { execSync } = require("node:child_process");
-    execSync("pnpm install", {
-        cwd: workspaceDir,
-        stdio: "inherit",
-    });
+const PNPM_INSTALL_ARGS = ["install", "--reporter=append-only"];
+async function installDeps(workspaceDir, mapLine, extraArgs = []) {
+    const progress = new child_output_1.InstallProgress();
+    const task = (0, cli_1.getProcessTasks)().start(progress.label);
+    try {
+        const { code, lines } = await runFramedCommand("pnpm", [...PNPM_INSTALL_ARGS, ...extraArgs], {
+            name: "pnpm",
+            cwd: workspaceDir,
+            env: { ...process.env, npm_config_update_notifier: "false" },
+            mapLine,
+            onLine: (line) => {
+                if (progress.read(line))
+                    task.update(progress.label);
+            },
+        });
+        if (code !== 0) {
+            throw new cli_1.CliError((0, child_output_1.describeChildFailure)({
+                title: "Dependency install failed",
+                command: "pnpm install",
+                code,
+                lines,
+                isVerbose: (0, cli_1.isVerboseRun)(),
+            }));
+        }
+        task.succeed(progress.doneLabel);
+    }
+    catch (error) {
+        (0, output_1.endInterruptedTask)(task, error, "Dependency install stopped");
+        throw error;
+    }
 }
 const FORWARDED_SIGNALS = ["SIGINT", "SIGTERM", "SIGHUP"];
 const CHILD_SHUTDOWN_TIMEOUT_MS = 5000;
-function exitCodeForSignal(signal) {
-    const number = node_os_1.constants.signals[signal];
-    return 128 + (typeof number === "number" ? number : 15);
-}
-function runCommand(command, args, options) {
+function runCommand(command, args, options, onSpawn) {
     const isWindows = process.platform === "win32";
     return new Promise((resolve, reject) => {
         const child = (0, node_child_process_1.spawn)(command, args, {
             stdio: "inherit",
             shell: isWindows,
             ...options,
+            detached: !isWindows,
         });
+        onSpawn?.(child);
         let escalation;
         let forwarded;
         const alive = () => child.exitCode === null && child.signalCode === null;
-        const stopChild = (signal) => {
-            if (!alive())
+        const signalTree = (signal) => {
+            if (child.pid === undefined)
                 return;
             try {
-                child.kill(isWindows ? "SIGTERM" : signal);
+                if (isWindows) {
+                    (0, node_child_process_1.spawnSync)("taskkill", ["/pid", String(child.pid), "/T", "/F"], {
+                        stdio: "ignore",
+                    });
+                }
+                else {
+                    process.kill(-child.pid, signal);
+                }
             }
             catch {
             }
+        };
+        const stopChild = (signal) => {
+            if (!alive())
+                return;
+            signalTree(signal);
             if (escalation || isWindows)
                 return;
             escalation = setTimeout(() => {
-                if (alive()) {
-                    try {
-                        child.kill("SIGKILL");
-                    }
-                    catch {
-                    }
-                }
+                if (alive())
+                    signalTree("SIGKILL");
             }, CHILD_SHUTDOWN_TIMEOUT_MS);
             escalation.unref();
         };
@@ -111,13 +144,8 @@ function runCommand(command, args, options) {
             stopChild(signal);
         };
         const onParentExit = () => {
-            if (alive()) {
-                try {
-                    child.kill("SIGKILL");
-                }
-                catch {
-                }
-            }
+            if (alive())
+                signalTree("SIGKILL");
         };
         for (const signal of FORWARDED_SIGNALS)
             process.on(signal, onSignal);
@@ -135,22 +163,72 @@ function runCommand(command, args, options) {
         });
         child.on("exit", (code, signal) => {
             cleanup();
+            if (forwarded) {
+                if (!isWindows)
+                    signalTree("SIGKILL");
+                return reject(new cancellation_1.CancelledError(forwarded));
+            }
             if (code !== null)
                 return resolve(code);
-            resolve(exitCodeForSignal(signal ?? forwarded ?? "SIGTERM"));
+            resolve((0, cancellation_1.exitCodeForSignal)(signal ?? "SIGTERM"));
         });
     });
 }
+const OUTPUT_DRAIN_TIMEOUT_MS = 2000;
+function drained(stream) {
+    if (!stream)
+        return Promise.resolve();
+    return new Promise((settle) => {
+        stream.once("end", settle);
+        stream.once("error", settle);
+    });
+}
+function drainTimeout() {
+    return new Promise((settle) => {
+        setTimeout(settle, OUTPUT_DRAIN_TIMEOUT_MS).unref();
+    });
+}
+async function runFramedCommand(command, args, options) {
+    const { name, cwd, env, mapLine = (line) => line, onLine } = options;
+    const isVerbose = (0, cli_1.isVerboseRun)();
+    const tails = [new child_output_1.OutputTail(), new child_output_1.OutputTail()];
+    const readLine = (tail, line) => {
+        const mapped = mapLine(line);
+        if (isVerbose)
+            (0, child_output_1.writeChildLine)(name, mapped);
+        const plain = (0, child_output_1.stripAnsi)(mapped);
+        tail.push(plain);
+        onLine?.(plain);
+    };
+    let ended = Promise.resolve();
+    const code = await runCommand(command, args, { cwd, env, stdio: ["ignore", "pipe", "pipe"] }, (child) => {
+        const streams = [child.stdout, child.stderr];
+        for (const [index, stream] of streams.entries()) {
+            const splitter = new child_output_1.LineSplitter((line) => readLine(tails[index], line));
+            stream?.setEncoding("utf8");
+            stream?.on("data", (chunk) => splitter.push(chunk));
+            stream?.once("end", () => splitter.flush());
+        }
+        ended = Promise.all(streams.map((stream) => drained(stream)));
+    });
+    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 setupWorkspace(opts) {
     const { backendUrl, force, mode, offline, clientUrl, bootstrapSecret } = opts;
     const workspaceKey = opts.workspaceKey ?? (0, config_1.canonicalizeBackendUrl)(backendUrl);
     const workspaceDir = (0, workspace_1.ensureWorkspace)(workspaceKey);
     (0, workspace_1.writeWorkspaceMeta)(workspaceDir, backendUrl, workspaceKey);
-    const resolved = await (0, manifest_1.resolveManifest)(workspaceDir, backendUrl, !!offline, clientUrl, bootstrapSecret);
+    const resolved = await (0, manifest_1.resolveManifest)(workspaceDir, backendUrl, manifestCacheUse(mode, offline), clientUrl, bootstrapSecret);
     const { manifest, fromCache, fetchedAt } = resolved;
     let layers;
     if (mode === "dev") {
-        (0, layers_1.assertLayerPathsServed)(manifest.modules);
+        (0, layers_1.assertLayerPathsServed)(manifest.modules, backendUrl, bootstrapSecret);
         if (fromCache) {
             (0, manifest_1.assertCachedLayerPathsExist)(manifest.modules, fetchedAt);
         }
@@ -160,7 +238,12 @@ async function setupWorkspace(opts) {
         const cacheDir = (0, node_path_1.join)(workspaceDir, ".layers-cache");
         if (fromCache) {
             if (!(0, node_fs_1.existsSync)(cacheDir)) {
-                throw new Error("Backend unreachable and no previously downloaded layers archive — run once with the backend reachable first.");
+                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);
         }
@@ -169,7 +252,7 @@ async function setupWorkspace(opts) {
         }
         layers = await (0, layers_1.buildLayersFromCache)(manifest.modules, cacheDir);
     }
-    (0, renderer_range_1.assertLayersSupportRenderer)(layers);
+    (0, renderer_range_1.assertLayersSupportRenderer)(layers, { workspaceDir });
     (0, materialize_1.copyStaticTemplates)(workspaceDir);
     (0, materialize_1.writeWorkspacePackageJson)(workspaceDir, layers);
     (0, materialize_1.materializeLayers)(workspaceDir, layers);
@@ -178,7 +261,8 @@ async function setupWorkspace(opts) {
     const layerPaths = layers.map((layer) => layer.path);
     const shouldInstall = needsInstall(workspaceDir, layerPaths, force);
     if (shouldInstall) {
-        installDeps(workspaceDir);
+        await opts.beforeInstall?.();
+        await installDeps(workspaceDir, (0, child_output_1.createPathMapper)(workspaceDir, layers));
         saveDepsHash(workspaceDir, layerPaths);
     }
     return {

package/dist/workspace.d.ts

@@ -27,6 +27,7 @@ export interface FrontendManifest {
 }
 export interface ResolvedLayer {
     path: string;
+    sourcePath?: string;
     packageName?: string;
     priority?: number;
     configKey?: string;
@@ -42,9 +43,14 @@ export interface WorkspaceEntry {
     dir: string;
     backendUrl: string;
     workspaceKey?: string;
+    lastUsedAt: string;
 }
-export declare function describeWorkspace(entry: WorkspaceEntry): string;
-export declare function listWorkspaces(): WorkspaceEntry[];
+export interface WorkspaceListing {
+    workspaces: WorkspaceEntry[];
+    skipped: string[];
+}
+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 function bootstrapHeaders(secret?: string): Record<string, string>;

package/dist/workspace.js

@@ -6,8 +6,8 @@ exports.projectWorkspaceKey = projectWorkspaceKey;
 exports.projectDirFromWorkspaceKey = projectDirFromWorkspaceKey;
 exports.getWorkspaceDir = getWorkspaceDir;
 exports.ensureWorkspace = ensureWorkspace;
-exports.describeWorkspace = describeWorkspace;
 exports.listWorkspaces = listWorkspaces;
+exports.directorySize = directorySize;
 exports.writeWorkspaceMeta = writeWorkspaceMeta;
 exports.bootstrapHeaders = bootstrapHeaders;
 exports.isUnauthorized = isUnauthorized;
@@ -38,32 +38,28 @@ function ensureWorkspace(workspaceKey) {
     (0, node_fs_1.chmodSync)(dir, config_1.WORKSPACE_DIR_MODE);
     return dir;
 }
-function describeWorkspace(entry) {
-    const projectDir = projectDirFromWorkspaceKey(entry.workspaceKey);
-    return projectDir
-        ? `${entry.backendUrl}, keyed on project ${projectDir}`
-        : entry.backendUrl;
-}
 function listWorkspaces() {
+    const listing = { workspaces: [], skipped: [] };
     if (!(0, node_fs_1.existsSync)(config_1.DMS_FRONTEND_HOME))
-        return [];
-    const workspaces = [];
+        return listing;
     for (const entry of (0, node_fs_1.readdirSync)(config_1.DMS_FRONTEND_HOME, { withFileTypes: true })) {
         if (!entry.isDirectory())
             continue;
         const dir = (0, node_path_1.join)(config_1.DMS_FRONTEND_HOME, entry.name);
         const meta = readWorkspaceMeta(dir);
         if (meta?.backendUrl === undefined) {
-            console.warn(`⚠ Skipping ${dir}: no readable ${WORKSPACE_META_FILE}.`);
+            listing.skipped.push(dir);
             continue;
         }
-        workspaces.push({
+        listing.workspaces.push({
             dir,
             backendUrl: meta.backendUrl,
             workspaceKey: meta.workspaceKey,
+            lastUsedAt: meta.updatedAt ?? metaModifiedAt(dir),
         });
     }
-    return workspaces;
+    listing.workspaces.sort((a, b) => b.lastUsedAt.localeCompare(a.lastUsedAt));
+    return listing;
 }
 function readWorkspaceMeta(dir) {
     let meta;
@@ -79,8 +75,47 @@ function readWorkspaceMeta(dir) {
         workspaceKey: typeof record?.workspaceKey === "string"
             ? record.workspaceKey
             : undefined,
+        updatedAt: typeof record?.updatedAt === "string" &&
+            !Number.isNaN(Date.parse(record.updatedAt))
+            ? new Date(record.updatedAt).toISOString()
+            : undefined,
     };
 }
+function metaModifiedAt(dir) {
+    return (0, node_fs_1.statSync)((0, node_path_1.join)(dir, WORKSPACE_META_FILE)).mtime.toISOString();
+}
+function directorySize(dir) {
+    const seen = new Set();
+    const pending = [dir];
+    let total = 0;
+    for (let current = pending.pop(); current; current = pending.pop()) {
+        let entries;
+        try {
+            entries = (0, node_fs_1.readdirSync)(current, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            const path = (0, node_path_1.join)(current, entry.name);
+            if (entry.isDirectory()) {
+                pending.push(path);
+                continue;
+            }
+            try {
+                const stats = (0, node_fs_1.lstatSync)(path);
+                const inode = `${stats.dev}:${stats.ino}`;
+                if (stats.nlink > 1 && seen.has(inode))
+                    continue;
+                seen.add(inode);
+                total += stats.size;
+            }
+            catch {
+            }
+        }
+    }
+    return total;
+}
 function writeWorkspaceMeta(workspaceDir, backendUrl, workspaceKey) {
     (0, node_fs_1.writeFileSync)((0, node_path_1.join)(workspaceDir, WORKSPACE_META_FILE), JSON.stringify({
         backendUrl: (0, config_1.canonicalizeBackendUrl)(backendUrl),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@antelopejs/dms-frontend",
-  "version": "0.3.7",
+  "version": "0.3.9",
   "description": "Frontend-agnostic loader for AntelopeJS DMS, shipping the Vue 3 renderer (Vite, Inertia, SSR)",
   "keywords": [
     "antelope",
@@ -55,7 +55,7 @@
   "scripts": {
     "build": "rimraf dist && tsc",
     "prepack": "pnpm run build",
-    "release": "pnpm run lint && pnpm run test && pnpm run prepack && release-it",
+    "release": "pnpm run lint && pnpm run build && pnpm run test && release-it",
     "test": "node --import tsx --test tests/*.test.ts tests/*.test.mts",
     "test:real-source": "pnpm run build && node dist/verify-source-runner.js",
     "format": "oxfmt .",
@@ -66,21 +66,18 @@
     "knip:all": "knip"
   },
   "dependencies": {
-    "boxen": "^5.1.2",
-    "chalk": "^4.1.2",
     "chokidar": "^4.0.3",
     "commander": "^13.1.0",
-    "figlet": "^1.9.4",
     "ignore": "^7.0.5",
     "semver": "^7.7.4",
     "unzipper": "^0.12.3"
   },
   "devDependencies": {
+    "@antelopejs/core": "^1.13.0",
     "@antelopejs/tooling-configs": ">=0.0.7 <1.0.0",
     "@iconify/utils": "^3.1.0",
     "@iconify/vue": "^5.0.1",
     "@inertiajs/vue3": "^3.7.1",
-    "@types/figlet": "^1.7.0",
     "@types/node": "^24.8.1",
     "@types/semver": "^7.7.1",
     "@types/unzipper": "^0.10.11",
@@ -104,12 +101,7 @@
     "vue-i18n": "^11.2.7"
   },
   "peerDependencies": {
-    "@antelopejs/core": ">=1.7.0 <2"
-  },
-  "peerDependenciesMeta": {
-    "@antelopejs/core": {
-      "optional": true
-    }
+    "@antelopejs/core": ">=1.13.0 <2"
   },
   "optionalDependencies": {
     "@oxc-parser/binding-darwin-arm64": "^0.95.0",

package/templates/vue/frontend-module.ts

@@ -333,6 +333,11 @@ export interface DmsFrontendRuntime {
   pendingNavigation?: Promise<void>;
   hasNavigationListener: boolean;
   pageVersion: number;
+  /**
+   * Identifies the page on screen (its path, or the error page shown at that
+   * path), whose meta `route.meta` holds.
+   */
+  pageKey?: string;
   /** The `Cookie` header of the request a server runtime renders. */
   requestCookies?: string;
   /**
@@ -495,7 +500,10 @@ function parseRoute(runtime: DmsFrontendRuntime, url: string): DmsRoute {
 }
 
 function updateRoute(runtime: DmsFrontendRuntime, url: string): void {
-  Object.assign(runtime.route, parseRoute(runtime, url));
+  // The meta is the page's, not the URL's: a page declares it, then reads its
+  // route, and the middleware the meta selected must still find it.
+  const { meta: _pageMeta, ...location } = parseRoute(runtime, url);
+  Object.assign(runtime.route, location);
 }
 
 function locationToUrl(
@@ -578,16 +586,22 @@ async function visit(
 export function useDmsRoute(pattern?: string): DmsRoute {
   const runtime = useDmsRuntime();
   runtime.currentRoutePattern = pattern;
+  // A server render answers one request, whose URL the runtime was given with
+  // its page, and never changes it. Inertia's page is one ref for the whole
+  // process, written by each render as it starts: after an await it may hold
+  // another request's URL, and while the plugins set up, the previous one's.
+  if (runtime.isServer) {
+    updateRoute(runtime, runtime.route.fullPath);
+    return runtime.route;
+  }
   const page = usePage();
-  updateRoute(runtime, page.url);
-  // A server render never changes its URL, and Inertia's page is shared by
-  // every render the process runs: a watcher there would only tie this
-  // request's runtime to all the requests after it.
-  if (!runtime.isServer)
-    watch(
-      () => page.url,
-      (url) => updateRoute(runtime, url),
-    );
+  // The browser's plugins set up before Inertia has a page: until then the
+  // runtime's route is the initial page's.
+  if (page.url !== undefined) updateRoute(runtime, page.url);
+  watch(
+    () => page.url,
+    (url) => updateRoute(runtime, url),
+  );
   return runtime.route;
 }
 
@@ -1360,6 +1374,14 @@ export function getDmsLayoutProps(
 export function hydrateDmsPageProps(props: DmsPageProps, url?: string): void {
   const runtime = useDmsRuntime();
   if (url) updateRoute(runtime, url);
+  // Pages are keyed by path: another path mounts another page, which declares
+  // its own meta, and so does an error page shown in place of the page. A
+  // visit that only changes the query keeps the page, and so its meta.
+  const pageKey = props.error ? `error:${props.path}` : props.path;
+  if (pageKey !== runtime.pageKey) {
+    runtime.pageKey = pageKey;
+    runtime.route.meta = {};
+  }
   runtime.pageVersion++;
   runtime.currentError.value = null;
   useDmsState<DmsUser | null>("dms-user", () => null).value =

package/templates/vue/package.json

@@ -5,6 +5,10 @@
   "scripts": {
     "dev": "vite",
     "build": "vite build && node compress-assets.mjs && vite build --ssr ssr-renderer.ts --outDir dist/ssr && vite build --config vite.email.config.ts",
+    "build:client": "vite build",
+    "build:compress": "node compress-assets.mjs",
+    "build:ssr": "vite build --ssr ssr-renderer.ts --outDir dist/ssr",
+    "build:email": "vite build --config vite.email.config.ts",
     "typecheck": "node --import ./typecheck-loader.mjs ./node_modules/vue-tsc/bin/vue-tsc.js --noEmit",
     "start": "node server.mjs"
   },