@antelopejs/dms-frontend 0.9.3 → 0.10.0

package/dist/internal/vite-manifest.d.ts

@@ -0,0 +1,6 @@
+export interface ViteChunk {
+    file: string;
+    src?: string;
+    isEntry?: boolean;
+}
+export declare function parseViteManifest(content: string, label: string): ViteChunk[];

package/dist/internal/vite-manifest.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseViteManifest = parseViteManifest;
+const cli_1 = require("@antelopejs/core/cli");
+const guards_1 = require("./guards");
+const plain_object_1 = require("./plain-object");
+function isViteChunk(value) {
+    return ((0, plain_object_1.isPlainObject)(value) &&
+        (0, guards_1.isText)(value.file) &&
+        (value.src === undefined || (0, guards_1.isText)(value.src)) &&
+        (value.isEntry === undefined || (0, guards_1.isFlag)(value.isEntry)));
+}
+function parseViteManifest(content, label) {
+    const manifest = JSON.parse(content);
+    const chunks = (0, plain_object_1.isPlainObject)(manifest)
+        ? Object.values(manifest)
+        : [];
+    if (!(0, plain_object_1.isPlainObject)(manifest) || !chunks.every(isViteChunk))
+        throw new cli_1.CliError({
+            title: `The ${label} is not a Vite manifest`,
+            reason: "Every entry of it must name the chunk's file.",
+        });
+    return chunks;
+}

package/dist/layer-watch.js

@@ -24,11 +24,11 @@ function createSyncFailures(src, reporter) {
     const failed = new Set();
     const show = (rel) => reporter.show((0, node_path_1.join)(src, rel));
     return {
-        fail(rel, err) {
+        fail(rel, errorLines) {
             failed.add(rel);
             reporter.warn(`${show(rel)} not copied to the workspace`, {
                 details: [
-                    ...reporter.describe(err),
+                    ...errorLines,
                     "The dev server keeps its previous version until the next save.",
                 ],
             });
@@ -73,7 +73,7 @@ function createLayerSync(src, dest, reporter, onStaged) {
             failures.applied(rel);
         }
         catch (err) {
-            failures.fail(rel, err);
+            failures.fail(rel, reporter.describe((0, output_1.classifyFailure)(err)));
         }
     };
     const remove = (rel, recursive) => {
@@ -86,7 +86,7 @@ function createLayerSync(src, dest, reporter, onStaged) {
             failures.applied(rel);
         }
         catch (err) {
-            failures.fail(rel, err);
+            failures.fail(rel, reporter.describe((0, output_1.classifyFailure)(err)));
         }
     };
     const stage = (p, add, cancel) => {
@@ -113,7 +113,7 @@ function createLayerSync(src, dest, reporter, onStaged) {
                     failures.applied(rel);
                 }
                 catch (err) {
-                    failures.fail(rel, err);
+                    failures.fail(rel, reporter.describe((0, output_1.classifyFailure)(err)));
                 }
             }
         },
@@ -127,22 +127,6 @@ 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 locale_files_1.InvalidLocaleFileError) {
-        const file = reporter.show(err.path);
-        return {
-            text: `${file} is not a valid locale file`,
-            options: { details: [...err.reason.split("\n"), kept] },
-            fixed: [`${file} fixed`, `${output.name} regenerated`].join((0, cli_1.getProcessUi)().symbols.separator),
-        };
-    }
-    return {
-        text: `${capitalize(output.name)} not regenerated`,
-        options: { details: [...reporter.describe(err), kept] },
-        fixed: `${capitalize(output.name)} regenerated`,
-    };
-}
 function describeLayerDirectories(paths, reporter) {
     const layers = [...new Set(paths)].filter((path) => !paths.some((other) => other.startsWith(`${path}${node_path_1.sep}`)));
     const shown = layers.map((path) => reporter.show(path));
@@ -183,7 +167,24 @@ function createDerivedOutputRefresher(workspaceDir, layers, reporter) {
             return isChanged;
         }
         catch (err) {
-            fail(output, describeOutputFailure(output, err, reporter));
+            const kept = `The dev server keeps the previous ${output.name} until the file is fixed.`;
+            if (err instanceof locale_files_1.InvalidLocaleFileError) {
+                const file = reporter.show(err.path);
+                fail(output, {
+                    text: `${file} is not a valid locale file`,
+                    options: { details: [...err.reason.split("\n"), kept] },
+                    fixed: [`${file} fixed`, `${output.name} regenerated`].join((0, cli_1.getProcessUi)().symbols.separator),
+                });
+            }
+            else {
+                fail(output, {
+                    text: `${capitalize(output.name)} not regenerated`,
+                    options: {
+                        details: [...reporter.describe((0, output_1.classifyFailure)(err)), kept],
+                    },
+                    fixed: `${capitalize(output.name)} regenerated`,
+                });
+            }
             return false;
         }
     };
@@ -198,7 +199,7 @@ function createDerivedOutputRefresher(workspaceDir, layers, reporter) {
                 text: "Derived files not regenerated",
                 options: {
                     details: [
-                        ...reporter.describe(err),
+                        ...reporter.describe((0, output_1.classifyFailure)(err)),
                         "The dev server keeps the previous ones until the module is fixed.",
                     ],
                 },
@@ -278,7 +279,7 @@ function startLayerWatchers(workspaceDir, layers, ui = (0, cli_1.getProcessUi)()
             if (!isQuiet)
                 write((0, output_1.formatTimedMessage)("success", text, {}, ui));
         },
-        describe: (error) => (0, output_1.failureDetails)(error, ui).map((line) => mapPath(line)),
+        describe: (failure) => (0, output_1.failureDetails)(failure, ui).map((line) => mapPath(line)),
         show: (path) => {
             const mapped = mapPath(path);
             return mapped === path ? (0, output_1.showPath)(path) : mapped;

package/dist/layers.d.ts

@@ -9,7 +9,7 @@ interface PathlessManifestSource {
 export declare function assertLayerPathsServed(modules: ManifestModule[], backendUrl: string, { bootstrapSecret, cache }?: PathlessManifestSource): asserts modules is ServedWithPath[];
 export interface LayerPackage {
     name?: unknown;
-    engines?: Record<string, unknown>;
+    engines?: unknown;
     dmsFrontend?: unknown;
     antelopeJs?: unknown;
 }

package/dist/layers.js

@@ -12,6 +12,7 @@ const manifest_1 = require("./manifest");
 const config_1 = require("./config");
 const output_1 = require("./output");
 const guards_1 = require("./internal/guards");
+const plain_object_1 = require("./internal/plain-object");
 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);
@@ -56,7 +57,8 @@ function readLayerPackage(layerPath) {
     if (!(0, node_fs_1.existsSync)(pkgPath))
         return undefined;
     try {
-        return JSON.parse((0, node_fs_1.readFileSync)(pkgPath, "utf-8"));
+        const parsed = JSON.parse((0, node_fs_1.readFileSync)(pkgPath, "utf-8"));
+        return (0, plain_object_1.isPlainObject)(parsed) ? parsed : undefined;
     }
     catch {
         return undefined;

package/dist/locale-files.d.ts

@@ -1,6 +1,7 @@
+import { type LocaleMessages } from "./internal/locale-catalogs";
 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>;
+export declare function readLocaleFile(path: string): LocaleMessages;

package/dist/locale-files.js

@@ -5,6 +5,7 @@ exports.readLocaleFile = readLocaleFile;
 const node_fs_1 = require("node:fs");
 const message_compiler_1 = require("@intlify/message-compiler");
 const guards_1 = require("./internal/guards");
+const locale_catalogs_1 = require("./internal/locale-catalogs");
 class InvalidLocaleFileError extends Error {
     constructor(path, reason) {
         super(`Invalid locale file ${path}: ${reason}`);
@@ -68,6 +69,9 @@ function readLocaleFile(path) {
         const reason = error instanceof Error ? error.message : String(error);
         throw new InvalidLocaleFileError(path, reason);
     }
+    if (!(0, locale_catalogs_1.isLocaleValue)(value) || !(0, locale_catalogs_1.isMessageGroup)(value)) {
+        throw new InvalidLocaleFileError(path, "a locale file must hold a JSON object of messages");
+    }
     const problems = messageProblems(value, "");
     if (problems.length) {
         const reason = [

package/dist/manifest.d.ts

@@ -16,7 +16,7 @@ export declare function fetchFromBackend(backendUrl: string, url: URL, bootstrap
 export declare class ManifestRefusedError extends CliError {
     constructor(problem: string | CliProblem);
 }
-export declare function describeManifestVersion(version: unknown): CliProblem;
+export declare function describeManifestVersion(version: number | undefined): CliProblem;
 export declare class BackendResponseError extends CliError {
     readonly status: number;
     constructor(subject: string, url: string | URL, response: Pick<Response, "status" | "statusText">);

package/dist/manifest.js

@@ -17,6 +17,9 @@ const config_1 = require("./config");
 const output_1 = require("./output");
 const workspace_1 = require("./workspace");
 const guards_1 = require("./internal/guards");
+const plain_object_1 = require("./internal/plain-object");
+const manifest_decoder_1 = require("./internal/manifest-decoder");
+const own_release_1 = require("./internal/own-release");
 class ManifestUnauthorizedError extends cli_1.CliError {
     constructor(url, status, credentialSent) {
         super({
@@ -34,22 +37,23 @@ class ManifestUnauthorizedError extends cli_1.CliError {
     }
 }
 exports.ManifestUnauthorizedError = ManifestUnauthorizedError;
-const UNREACHABLE_REASONS = {
-    ECONNREFUSED: "Connection refused",
-    ECONNRESET: "Connection reset",
-    ENOTFOUND: "Unknown host",
-    EAI_AGAIN: "Host name lookup failed",
-    ETIMEDOUT: "Connection timed out",
-    UND_ERR_CONNECT_TIMEOUT: "Connection timed out",
-};
+const UNREACHABLE_REASONS = new Map([
+    ["ECONNREFUSED", "Connection refused"],
+    ["ECONNRESET", "Connection reset"],
+    ["ENOTFOUND", "Unknown host"],
+    ["EAI_AGAIN", "Host name lookup failed"],
+    ["ETIMEDOUT", "Connection timed out"],
+    ["UND_ERR_CONNECT_TIMEOUT", "Connection timed out"],
+]);
 const UNKNOWN_HOST_CODES = ["ENOTFOUND", "EAI_AGAIN"];
 class BackendUnreachableError extends cli_1.CliError {
     constructor(url, failure) {
         const cause = (hasProperties(failure) ? failure.cause : undefined) ?? failure;
-        const code = errorCode(cause);
+        const code = hasProperties(cause) ? errorCode(cause) : undefined;
+        const message = () => cause instanceof Error ? cause.message : String(cause);
         const detail = code
-            ? (UNREACHABLE_REASONS[code] ?? errorMessage(cause))
-            : `The request failed: ${errorMessage(cause)}`;
+            ? (UNREACHABLE_REASONS.get(code) ?? message())
+            : `The request failed: ${message()}`;
         const fix = code && UNKNOWN_HOST_CODES.includes(code)
             ? `Check the host name '${new URL(url).hostname}' in -b <url> or DMS_API_BASE_URL`
             : "Start the backend (`ajs project dev` for a local one), or pass its URL with -b <url>";
@@ -68,15 +72,13 @@ function hasProperties(value) {
     return (value !== null && (typeof value === "object" || typeof value === "function"));
 }
 function errorCode(err) {
-    if (!hasProperties(err))
-        return undefined;
     const { code, errors } = err;
     if ((0, guards_1.isText)(code))
         return code;
-    return Array.isArray(errors) ? errorCode(errors[0]) : undefined;
-}
-function errorMessage(err) {
-    return err instanceof Error ? err.message : String(err);
+    if (!Array.isArray(errors))
+        return undefined;
+    const first = errors[0];
+    return hasProperties(first) ? errorCode(first) : undefined;
 }
 function displayUrl(url) {
     const { origin, pathname } = new URL(url);
@@ -112,13 +114,12 @@ class ManifestRefusedError extends cli_1.CliError {
     }
 }
 exports.ManifestRefusedError = ManifestRefusedError;
-const OWN_RELEASE = require("../package.json");
 const BACKEND_PACKAGE = "@antelopejs/dms";
 const LOADER_UPDATE_COMMAND = "ajs update dms";
 function describeManifestVersion(version) {
-    const loader = `${OWN_RELEASE.name} ${OWN_RELEASE.version}`;
+    const loader = `${own_release_1.ownRelease.name} ${own_release_1.ownRelease.version}`;
     const supported = `This loader reads version ${workspace_1.FRONTEND_MANIFEST_VERSION}`;
-    if (!(0, guards_1.isNumber)(version)) {
+    if (version === undefined) {
         return {
             title: "The backend served a frontend manifest without a protocol version",
             reason: `${supported}; the answer does not look like one from ${BACKEND_PACKAGE}.`,
@@ -141,7 +142,7 @@ function describeManifestVersion(version) {
         title,
         reason: `${supported}; the backend's ${BACKEND_PACKAGE} is older than this loader.`,
         fixes: [
-            `Upgrade ${BACKEND_PACKAGE} on the backend, or use a ${OWN_RELEASE.name} release that reads version ${version}`,
+            `Upgrade ${BACKEND_PACKAGE} on the backend, or use a ${own_release_1.ownRelease.name} release that reads version ${version}`,
         ],
     };
 }
@@ -192,19 +193,29 @@ async function fetchManifest(backendUrl, clientUrl, bootstrapSecret) {
     if (!response.ok) {
         throw new BackendResponseError("the frontend manifest", frontendUrl, response);
     }
-    const manifest = (await response.json());
-    if (manifest.version !== workspace_1.FRONTEND_MANIFEST_VERSION) {
-        throw new ManifestRefusedError(describeManifestVersion(manifest.version));
+    const body = await response.json();
+    const version = (0, manifest_decoder_1.hasManifestVersion)(body) ? body.version : undefined;
+    if (version !== workspace_1.FRONTEND_MANIFEST_VERSION) {
+        throw new ManifestRefusedError(describeManifestVersion(version));
     }
-    const incompatible = manifest.modules.filter((module) => module.renderer?.name !== "vue" || module.renderer?.version !== "3");
+    if (!(0, manifest_decoder_1.isManifest)(body)) {
+        throw new ManifestRefusedError({
+            title: "The backend served a frontend manifest this loader cannot read",
+            reason: `It states version ${workspace_1.FRONTEND_MANIFEST_VERSION}, but its modules, settling flag or origin rewrites do not have the shape ${own_release_1.ownRelease.name} ${own_release_1.ownRelease.version} reads.`,
+            fixes: [
+                `Check that -b <url> points at a DMS backend running ${BACKEND_PACKAGE}`,
+            ],
+        });
+    }
+    const incompatible = body.modules.filter((module) => module.renderer?.name !== "vue" || module.renderer?.version !== "3");
     if (incompatible.length) {
         throw new ManifestRefusedError(`Frontend manifest contains incompatible renderer modules: ${incompatible.map((module) => module.name).join(", ")}`);
     }
-    const resolved = { modules: manifest.modules };
-    if (manifest.settling)
+    const resolved = { modules: body.modules };
+    if (body.settling)
         resolved.settling = true;
-    if (manifest.originRewrites)
-        resolved.originRewrites = manifest.originRewrites;
+    if (body.originRewrites)
+        resolved.originRewrites = body.originRewrites;
     return resolved;
 }
 const MANIFEST_CACHE_FILE = ".manifest-cache.json";
@@ -214,9 +225,11 @@ function readCachedManifest(workspaceDir) {
         return undefined;
     try {
         const parsed = JSON.parse((0, node_fs_1.readFileSync)(file, "utf-8"));
-        if (!parsed?.manifest)
+        if (!(0, plain_object_1.isPlainObject)(parsed) || !(0, guards_1.isText)(parsed.fetchedAt))
+            return undefined;
+        if (!(0, manifest_decoder_1.isManifest)(parsed.manifest))
             return undefined;
-        return parsed;
+        return { manifest: parsed.manifest, fetchedAt: parsed.fetchedAt };
     }
     catch {
         return undefined;

package/dist/materialize.js

@@ -16,6 +16,7 @@ const layers_1 = require("./layers");
 const manifest_secrets_1 = require("./manifest-secrets");
 const fs_sync_1 = require("./fs-sync");
 const guards_1 = require("./internal/guards");
+const plain_object_1 = require("./internal/plain-object");
 function getPackageRoot() {
     return (0, node_path_1.resolve)(__dirname, "..");
 }
@@ -43,11 +44,14 @@ function copyStaticTemplates(workspaceDir) {
 function writeWorkspacePackageJson(workspaceDir, layers) {
     const templatePath = (0, node_path_1.join)(getTemplateDir(), "package.json");
     const pkg = JSON.parse((0, node_fs_1.readFileSync)(templatePath, "utf-8"));
-    pkg.dependencies ??= {};
+    if (!(0, plain_object_1.isPlainObject)(pkg))
+        throw new Error(`${templatePath} is not a JSON object`);
+    const dependencies = (0, plain_object_1.isPlainObject)(pkg.dependencies) ? pkg.dependencies : {};
+    pkg.dependencies = dependencies;
     for (const layer of layers) {
         if (!layer.packageName)
             continue;
-        pkg.dependencies[layer.packageName] = "workspace:*";
+        dependencies[layer.packageName] = "workspace:*";
     }
     (0, node_fs_1.writeFileSync)((0, node_path_1.join)(workspaceDir, "package.json"), `${JSON.stringify(pkg, null, 2)}\n`);
 }

package/dist/module-set.js

@@ -7,12 +7,13 @@ exports.reportFrontendReady = reportFrontendReady;
 exports.reportFrontendReadyOnceAnswered = reportFrontendReadyOnceAnswered;
 const promises_1 = require("node:timers/promises");
 const manifest_1 = require("./manifest");
+const own_release_1 = require("./internal/own-release");
 const workspace_1 = require("./workspace");
 exports.MODULE_SET_POLL_INTERVAL_MS = 3000;
 const READY_ENDPOINT = "/dms/frontend/ready";
 const READY_TIMEOUT_MS = 5000;
 const JSON_CONTENT_TYPE = "application/json";
-exports.OWN_RELEASE = require("../package.json");
+exports.OWN_RELEASE = own_release_1.ownRelease;
 function moduleSetFingerprint(modules) {
     return JSON.stringify([...modules]
         .sort((left, right) => left.name.localeCompare(right.name))

package/dist/node-options.d.ts

@@ -0,0 +1 @@
+export declare function serverNodeOptions(inherited: string | undefined): string;

package/dist/node-options.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serverNodeOptions = serverNodeOptions;
+const HEAP_OPTION = "--max-old-space-size=4096";
+function serverNodeOptions(inherited) {
+    const own = inherited?.trim();
+    return own ? `${HEAP_OPTION} ${own}` : HEAP_OPTION;
+}

package/dist/output.d.ts

@@ -1,4 +1,4 @@
-import { type TaskHandle, type Ui } from "@antelopejs/core/cli";
+import { CliError, type TaskHandle, type Ui } from "@antelopejs/core/cli";
 import { CancelledError } from "./cancellation";
 export declare function exitOnBrokenPipe(stream?: NodeJS.WriteStream): void;
 export declare function isTerminalFeedback(): boolean;
@@ -15,8 +15,19 @@ export declare function workspaceId(dir: string, isTerminal: boolean): string;
 export declare function formatSize(bytes: number): string;
 export declare function formatAge(iso: string, now?: number): string;
 export declare function cachedAge(fetchedAt: string | undefined): string;
-export declare function failureDetails(error: unknown, ui?: Ui): string[];
-export declare function endInterruptedTask(task: TaskHandle, error: unknown, stopped: string): void;
+export type Failure = {
+    kind: "cli";
+    error: CliError;
+} | {
+    kind: "error";
+    error: Error;
+} | {
+    kind: "thrown";
+    text: string;
+};
+export declare function classifyFailure(thrown: unknown): Failure;
+export declare function failureDetails(failure: Failure, ui?: Ui): string[];
+export declare function endInterruptedTask(task: TaskHandle, error: CancelledError | undefined, stopped: string): void;
 export declare function reportStopped(stop: CancelledError, ui?: Ui): void;
 export interface ReadyLine {
     label: string;
@@ -31,12 +42,7 @@ export interface ReadyBlock {
 }
 export declare function formatReadyBlock(block: ReadyBlock, ui?: Ui, isQuiet?: boolean, columns?: number | undefined): string[];
 export declare function writeReadyBlock(block: ReadyBlock, ui?: Ui): void;
-declare const TIMED_LEVEL_COLORS: {
-    readonly success: "green";
-    readonly info: "blue";
-    readonly warn: "yellow";
-};
-type TimedLevel = keyof typeof TIMED_LEVEL_COLORS;
+type TimedLevel = "success" | "info" | "warn";
 export interface TimedMessageOptions {
     details?: readonly string[];
     fixes?: readonly string[];

package/dist/output.js

@@ -15,6 +15,7 @@ exports.workspaceId = workspaceId;
 exports.formatSize = formatSize;
 exports.formatAge = formatAge;
 exports.cachedAge = cachedAge;
+exports.classifyFailure = classifyFailure;
 exports.failureDetails = failureDetails;
 exports.endInterruptedTask = endInterruptedTask;
 exports.reportStopped = reportStopped;
@@ -25,7 +26,6 @@ const node_os_1 = require("node:os");
 const node_path_1 = require("node:path");
 const node_util_1 = require("node:util");
 const cli_1 = require("@antelopejs/core/cli");
-const cancellation_1 = require("./cancellation");
 const HOME_PREFIX = "~";
 const CURRENT_DIRECTORY = ".";
 const WORKSPACE_ID_LENGTH = 8;
@@ -140,17 +140,24 @@ function formatAge(iso, now = Date.now()) {
 function cachedAge(fetchedAt) {
     return fetchedAt ? ` cached ${formatAge(fetchedAt)}` : "";
 }
-function describeProblem(error) {
-    if (error instanceof cli_1.CliError)
-        return error.problem;
-    const message = error instanceof Error ? error.message : String(error);
-    return { title: message.split(LINE_BREAK)[0] };
-}
-function failureDetails(error, ui = (0, cli_1.getProcessUi)()) {
-    const { title, reason, fixes = [], details = [] } = describeProblem(error);
+function classifyFailure(thrown) {
+    if (thrown instanceof cli_1.CliError)
+        return { kind: "cli", error: thrown };
+    if (thrown instanceof Error)
+        return { kind: "error", error: thrown };
+    return { kind: "thrown", text: String(thrown) };
+}
+function failureDetails(failure, ui = (0, cli_1.getProcessUi)()) {
+    const { title, reason, fixes = [], details = [], } = failure.kind === "cli"
+        ? failure.error.problem
+        : {
+            title: (failure.kind === "error"
+                ? failure.error.message
+                : failure.text).split(LINE_BREAK)[0],
+        };
     const hint = ui.symbols.levels.hint;
-    const stack = (0, cli_1.isVerboseRun)() && error instanceof Error && !(error instanceof cli_1.CliError)
-        ? (error.stack ?? "").split(LINE_BREAK).slice(1)
+    const stack = (0, cli_1.isVerboseRun)() && failure.kind === "error"
+        ? (failure.error.stack ?? "").split(LINE_BREAK).slice(1)
         : [];
     return [
         title,
@@ -164,7 +171,7 @@ function lineStartAfter(signal) {
     return signal === "SIGINT" && process.stderr.isTTY ? CARRIAGE_RETURN : "";
 }
 function endInterruptedTask(task, error, stopped) {
-    if (!(error instanceof cancellation_1.CancelledError))
+    if (!error)
         return task.dismiss();
     const lineStart = lineStartAfter(error.signal);
     if (lineStart)
@@ -212,18 +219,23 @@ function writeReadyBlock(block, ui = (0, cli_1.getProcessUi)()) {
         writeFeedback(line);
     writeInfo("");
 }
-const TIMED_LEVEL_COLORS = {
-    success: "green",
-    info: "blue",
-    warn: "yellow",
-};
+function timedLevelColor(level) {
+    switch (level) {
+        case "success":
+            return "green";
+        case "info":
+            return "blue";
+        case "warn":
+            return "yellow";
+    }
+}
 function clockTime(date) {
     return date.toTimeString().slice(0, TIME_LENGTH);
 }
 function formatTimedMessage(level, text, options = {}, ui = (0, cli_1.getProcessUi)(), now = new Date()) {
     const { details = [], fixes = [], columns = feedbackColumns() } = options;
     const palette = ui.palette();
-    const paint = palette[TIMED_LEVEL_COLORS[level]];
+    const paint = palette[timedLevelColor(level)];
     const hint = palette.cyan(ui.symbols.levels.hint);
     const indent = " ".repeat(TIME_LENGTH + 1) + BLOCK_INDENT;
     return [

package/dist/private-values.d.ts

@@ -1,6 +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 function filledOptions(declared: FrontendModuleOptions, values: FrontendModuleOptions | undefined): FrontendModuleOptions;
 export declare const PRIVATE_OPTIONS_VARIABLE = "DMS_PRIVATE_OPTIONS";
 export interface UnfilledPrivateValue {
     module: string;

package/dist/private-values.js

@@ -34,8 +34,8 @@ function filled(declared, value) {
         return filledOptions(declared, isOptions(value) ? value : undefined);
     return declared;
 }
-function filledOptions(shape, values) {
-    return Object.fromEntries(Object.entries(shape).map(([key, value]) => [
+function filledOptions(declared, values) {
+    return Object.fromEntries(Object.entries(declared).map(([key, value]) => [
         key,
         filled(value, values?.[key]),
     ]));
@@ -90,7 +90,9 @@ function unfilledPrivateValues(modules, given, covered) {
     return Object.entries(modules).flatMap(([module, options]) => [...emptyStrings(options)]
         .filter((path) => path.length > 0 && !isCovered(path))
         .filter((path) => {
-        const value = readPath(given[module], path);
+        const value = readPath(Object.prototype.hasOwnProperty.call(given, module)
+            ? given[module]
+            : undefined, path);
         return !(0, guards_1.isText)(value) || value === "";
     })
         .map((path) => ({ module, path })));

package/dist/project-modules.js

@@ -107,26 +107,31 @@ function computeConfigVars(id, provider, config) {
             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]]));
+    return Object.fromEntries(provider.declared.flatMap((name) => Object.prototype.hasOwnProperty.call(computed, 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 module = Object.prototype.hasOwnProperty.call(modules, id)
+                ? modules[id]
+                : undefined;
             const provider = module?.folder && configVarsProvider(id, module.folder);
-            if (provider)
+            if (module && provider)
                 published.set(id, computeConfigVars(id, provider, substituteConfigVars(module.config, lookup)));
         }
-        return published.get(id)?.[name];
+        const variables = published.get(id);
+        return variables && Object.prototype.hasOwnProperty.call(variables, name)
+            ? variables[name]
+            : undefined;
     };
     return lookup;
 }
 function substituteConfigVars(value, lookup) {
-    if (typeof value === "string") {
+    if ((0, guards_1.isText)(value)) {
         const pure = value.match(PURE_CONFIG_VAR);
         if (pure)
             return lookup(pure[1], pure[2]);
@@ -137,7 +142,7 @@ function substituteConfigVars(value, lookup) {
     }
     if (Array.isArray(value))
         return value.map((item) => substituteConfigVars(item, lookup));
-    if (value && typeof value === "object") {
+    if ((0, guards_1.isObjectLike)(value)) {
         return Object.fromEntries(Object.entries(value).map(([key, item]) => [
             key,
             substituteConfigVars(item, lookup),

package/dist/renderer-range.js

@@ -11,7 +11,8 @@ const semver_1 = __importDefault(require("semver"));
 const layers_1 = require("./layers");
 const output_1 = require("./output");
 const guards_1 = require("./internal/guards");
-const OWN_RELEASE = require("../package.json");
+const plain_object_1 = require("./internal/plain-object");
+const own_release_1 = require("./internal/own-release");
 const noticedModules = new Set();
 const NOTICED_MODULES_FILE = ".renderer-range-noticed";
 function readNoticedModules(workspaceDir) {
@@ -35,10 +36,11 @@ function shownModule(layer) {
     return layer.packageName ? `${layer.packageName} (${where})` : where;
 }
 function declaredRange(layer, rendererName) {
+    const engines = (0, layers_1.readLayerPackage)(layer.path)?.engines;
     return {
         module: moduleLabel(layer),
         shown: shownModule(layer),
-        range: (0, layers_1.readLayerPackage)(layer.path)?.engines?.[rendererName],
+        range: (0, plain_object_1.isPlainObject)(engines) ? engines[rendererName] : undefined,
     };
 }
 function releaseLine(version) {
@@ -73,7 +75,7 @@ function noticeUndeclared(declarations, renderer, warn, workspaceDir) {
     });
 }
 function assertLayersSupportRenderer(layers, options = {}) {
-    const renderer = options.renderer ?? OWN_RELEASE;
+    const renderer = options.renderer ?? own_release_1.ownRelease;
     const declarations = layers.map((layer) => declaredRange(layer, renderer.name));
     noticeUndeclared(declarations, renderer, options.warn ??
         ((text, messageOptions) => (0, cli_1.getProcessUi)().message("warn", text, messageOptions)), options.workspaceDir);