@antelopejs/dms-frontend 0.3.8 → 0.3.9

package/dist/index.js

@@ -1,63 +1,123 @@
 #!/usr/bin/env node
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-const chalk_1 = __importDefault(require("chalk"));
+const cli_1 = require("@antelopejs/core/cli");
 const commander_1 = require("commander");
+const cancellation_1 = require("./cancellation");
 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 start_1 = require("./commands/start");
 const verify_source_1 = require("./commands/verify-source");
+const workspaces_1 = require("./commands/workspaces");
 const env_file_1 = require("./env-file");
+const help_1 = require("./help");
+const output_1 = require("./output");
 const update_check_1 = require("./update-check");
-const cli_ui_1 = require("./utils/cli-ui");
 const { version } = require("../package.json");
+const GLOBAL_FLAGS = ["--no-color", "--verbose"];
+const ROOT_EXAMPLES = [
+    {
+        description: "Inside a project started with ajs project dev",
+        command: "ajs dms dev",
+    },
+    {
+        description: "Build for production, then serve the build",
+        command: "ajs dms build -b https://dms.example.com",
+    },
+    {
+        description: "Serve it on another port",
+        command: "ajs dms start -b https://dms.example.com -p 3001",
+    },
+];
+function describeVersion(version, width) {
+    const name = `ajs dms ${version}`;
+    const line = [
+        (0, cli_1.unbreakable)(name),
+        "DMS frontend for AntelopeJS (Vue 3, Vite, Inertia)",
+    ].join((0, cli_1.getProcessUi)().symbols.separator);
+    const [first, ...rest] = (0, cli_1.wrapText)(line, width);
+    const title = first.replace(name, (0, cli_1.getProcessPalette)("result").bold(name));
+    return `${[title, ...rest].join("\n")}\n`;
+}
+function describeHelpFooter(width) {
+    const pointer = `Run ${(0, cli_1.unbreakable)("ajs dms <command> --help")} for its options and examples, and ` +
+        `${(0, cli_1.unbreakable)(`ajs dms help ${help_1.ENVIRONMENT_TOPIC}`)} for the variables read from the environment.`;
+    return [
+        "",
+        (0, cli_1.formatExamples)(ROOT_EXAMPLES, width),
+        "",
+        ...(0, cli_1.wrapText)(pointer, width),
+    ].join("\n");
+}
+function ownArguments(args) {
+    return args.filter((arg) => !GLOBAL_FLAGS.includes(arg));
+}
+function isInvocation(args, rest) {
+    const own = ownArguments(args);
+    return own.length === rest.length && own.every((arg, i) => arg === rest[i]);
+}
+function unknownHelpSubject(program, args) {
+    const [first, subject, ...rest] = ownArguments(args);
+    if (first !== "help" || subject === undefined || rest.length > 0) {
+        return undefined;
+    }
+    const known = [
+        ...program.commands.map((command) => command.name()),
+        "help",
+        help_1.ENVIRONMENT_TOPIC,
+    ];
+    return known.includes(subject) ? undefined : subject;
+}
 const runCLI = async () => {
+    (0, output_1.exitOnBrokenPipe)();
     (0, env_file_1.loadProjectEnv)();
     const argv = process.argv.slice(2);
-    void (0, update_check_1.checkForUpdate)({ currentVersion: version, argv });
-    if (process.argv.length <= 2) {
-        (0, cli_ui_1.displayBanner)("Antelope DMS");
-        console.log(chalk_1.default.dim(`  Frontend Loader for AntelopeJS DMS - v${version}\n`));
-    }
+    (0, update_check_1.startProcessUpdateCheck)({ currentVersion: version, argv });
     const program = new commander_1.Command()
         .name("ajs dms")
-        .description(`Antelope DMS - Frontend Loader v${version}\n\n` +
-        `Materializes frontend modules from an AntelopeJS backend and starts a Vue or React Vite and Inertia application.`)
-        .version(version, "-v, --version", "Display version number")
-        .option("--no-update-check", "Skip the daily check for a newer DMS frontend release")
-        .helpCommand("help [command]", "Display help for a specific command")
-        .addHelpText("after", `
-Environment:
-  Every command reads ${env_file_1.ENV_FILE_NAMES.join(" then ")} from the current directory before parsing
-  its options, so DMS_API_BASE_URL, DMS_BOOTSTRAP_SECRET, DMS_SESSION_SECRET and
-  the other variables below can live in the project's .env. A variable already
-  set in the environment always wins over a file, and .env.local wins over .env.
-  The generated workspace never loads a .env of its own.
-  'dev' generates an ephemeral 32-byte DMS_SESSION_SECRET when it is absent;
-  restarting dev invalidates its sessions. 'build' and 'start' require a
-  configured secret of at least 32 characters.
-
-Workspaces:
-  Each canonical backend URL gets its own workspace under
-  ~/.antelopejs/dms-frontend. 'dev' without -b is the exception: it keys the
-  workspace on the antelope project directory instead, so a backend that lands
-  on a different port between runs keeps its node_modules and manifest cache.
-  Pass -b to 'dev' to share one workspace with 'build' and 'start'.`);
+        .version(version, "-v, --version", "Print the version")
+        .option("--no-color", "Disable colors (also NO_COLOR=1)")
+        .option("--verbose", "Show full output and stack traces (also ANTELOPEJS_VERBOSE)")
+        .option("--no-update-check", "Skip the daily update check (also NO_UPDATE_NOTIFIER=1)")
+        .addHelpText("before", (context) => describeVersion(version, (0, cli_1.helpTextWidth)(context)))
+        .addHelpText("after", (context) => describeHelpFooter((0, cli_1.helpTextWidth)(context)));
     program.addCommand((0, dev_1.cmdDev)());
     program.addCommand((0, build_1.cmdBuild)());
     program.addCommand((0, start_1.cmdStart)());
     program.addCommand((0, prepare_1.cmdPrepare)());
+    program.addCommand((0, workspaces_1.cmdWorkspaces)());
     program.addCommand((0, clean_1.cmdClean)());
     program.addCommand((0, verify_source_1.cmdVerifySource)());
-    await program.parseAsync((0, update_check_1.stripUpdateCheckFlag)(argv), { from: "user" });
+    (0, help_1.applyDmsHelp)(program);
+    (0, cli_1.formatUsageErrors)(program);
+    const args = (0, update_check_1.stripUpdateCheckFlag)(argv);
+    if (isInvocation(args, [])) {
+        program.outputHelp();
+        return;
+    }
+    if (isInvocation(args, ["help", help_1.ENVIRONMENT_TOPIC])) {
+        (0, cli_1.getProcessUi)().value((0, help_1.formatEnvironmentHelp)());
+        return;
+    }
+    const helpSubject = unknownHelpSubject(program, args);
+    if (helpSubject !== undefined) {
+        program.error(`error: unknown command '${helpSubject}'`, {
+            code: "commander.unknownCommand",
+        });
+    }
+    try {
+        await program.parseAsync(args, { from: "user" });
+    }
+    catch (err) {
+        if (!(err instanceof cancellation_1.CancelledError))
+            throw err;
+        (0, output_1.reportStopped)(err);
+        process.exitCode = err.exitCode;
+        return;
+    }
+    if (!process.exitCode)
+        await (0, update_check_1.reportAvailableUpdate)();
 };
-process.on("SIGINT", () => process.exit(0));
-runCLI().catch((err) => {
-    console.error(chalk_1.default.red("Error:"), err.message || err);
-    process.exit(1);
-});
+void (0, cli_1.runWithErrorBoundary)(runCLI, { verbose: (0, cli_1.isVerboseRun)() }).then(() => process.exit());

package/dist/layer-watch.d.ts

@@ -1,2 +1,3 @@
+import { type Ui } from "@antelopejs/core/cli";
 import { ResolvedLayer } from "./workspace";
-export declare function startLayerWatchers(workspaceDir: string, layers: ResolvedLayer[]): () => Promise<void>;
+export declare function startLayerWatchers(workspaceDir: string, layers: ResolvedLayer[], ui?: Ui, write?: (text: string) => void): () => Promise<void>;

package/dist/layer-watch.js

@@ -6,25 +6,48 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.startLayerWatchers = startLayerWatchers;
 const node_fs_1 = require("node:fs");
 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 layers_1 = require("./layers");
 const derived_outputs_1 = require("./derived-outputs");
+const output_1 = require("./output");
 const fs_sync_1 = require("./fs-sync");
 const WATCH_DEBOUNCE_MS = 80;
 const DERIVED_REFRESH_DEBOUNCE_MS = 100;
-function createLayerSync(src, dest, onFlushed) {
+function capitalize(text) {
+    return `${text.charAt(0).toUpperCase()}${text.slice(1)}`;
+}
+function createSyncFailures(src, reporter) {
+    const failed = new Set();
+    const show = (rel) => reporter.show((0, node_path_1.join)(src, rel));
+    return {
+        fail(rel, err) {
+            failed.add(rel);
+            reporter.warn(`${show(rel)} not copied to the workspace`, {
+                details: [
+                    ...reporter.describe(err),
+                    "The dev server keeps its previous version until the next save.",
+                ],
+            });
+        },
+        applied(rel) {
+            if (failed.delete(rel))
+                reporter.succeed(`${show(rel)} copied to the workspace`);
+        },
+    };
+}
+function createLayerSync(src, dest, onFlushed, reporter) {
     const fileUpserts = new Set();
     const fileDeletes = new Set();
     const dirCreates = new Set();
     const dirDeletes = new Set();
+    const failures = createSyncFailures(src, reporter);
     let timer = null;
     const toRel = (p) => {
         const r = (0, node_path_1.relative)(src, p);
         return r ? r : null;
     };
-    const warnFailure = (rel, err) => {
-        console.warn(`[ajs-dms] layer sync skipped ${rel}:`, err);
-    };
     const flush = () => {
         timer = null;
         const touched = [
@@ -36,9 +59,10 @@ function createLayerSync(src, dest, onFlushed) {
         for (const rel of [...dirCreates].sort((a, b) => a.length - b.length)) {
             try {
                 (0, node_fs_1.mkdirSync)((0, node_path_1.join)(dest, rel), { recursive: true });
+                failures.applied(rel);
             }
             catch (err) {
-                warnFailure(rel, err);
+                failures.fail(rel, err);
             }
         }
         dirCreates.clear();
@@ -54,9 +78,10 @@ function createLayerSync(src, dest, onFlushed) {
                 else {
                     (0, fs_sync_1.applyFile)(srcPath, destPath);
                 }
+                failures.applied(rel);
             }
             catch (err) {
-                warnFailure(rel, err);
+                failures.fail(rel, err);
             }
         }
         fileUpserts.clear();
@@ -67,9 +92,10 @@ function createLayerSync(src, dest, onFlushed) {
                 const destPath = (0, node_path_1.join)(dest, rel);
                 if ((0, node_fs_1.existsSync)(destPath))
                     (0, node_fs_1.rmSync)(destPath, { force: true });
+                failures.applied(rel);
             }
             catch (err) {
-                warnFailure(rel, err);
+                failures.fail(rel, err);
             }
         }
         fileDeletes.clear();
@@ -80,9 +106,10 @@ function createLayerSync(src, dest, onFlushed) {
                 const destPath = (0, node_path_1.join)(dest, rel);
                 if ((0, node_fs_1.existsSync)(destPath))
                     (0, node_fs_1.rmSync)(destPath, { recursive: true, force: true });
+                failures.applied(rel);
             }
             catch (err) {
-                warnFailure(rel, err);
+                failures.fail(rel, err);
             }
         }
         dirDeletes.clear();
@@ -133,40 +160,106 @@ function createLayerSync(src, dest, onFlushed) {
         },
     };
 }
-function createDerivedOutputRefresher(workspaceDir, layers) {
-    const pending = new Set();
+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) {
+        const file = reporter.show(err.path);
+        return {
+            text: `${file} is not a valid locale file`,
+            options: { details: [err.reason, 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));
+    if (shown.length !== 1)
+        return `Layer directories added or removed: ${shown.join(", ")}`;
+    return (0, node_fs_1.existsSync)(layers[0])
+        ? `New layer directory ${shown[0]}`
+        : `Layer directory ${shown[0]} removed`;
+}
+function createDerivedOutputRefresher(workspaceDir, layers, reporter) {
+    const pending = new Map();
+    const failures = new Map();
+    let hasRestartNotice = false;
     let timer = null;
-    const regenerate = (output, registry) => {
+    const fail = (key, failure) => {
+        failures.set(key, failure);
+        reporter.warn(failure.text, failure.options);
+    };
+    const recover = (key) => {
+        const failure = failures.get(key);
+        if (!failure)
+            return;
+        failures.delete(key);
+        reporter.succeed(failure.fixed);
+    };
+    const noticeRestart = (output, paths) => {
+        if (!output.restartHint || hasRestartNotice)
+            return;
+        hasRestartNotice = true;
+        reporter.warn(describeLayerDirectories(paths, reporter), {
+            fixes: [output.restartHint],
+        });
+    };
+    const regenerate = (output, paths, registry) => {
         try {
-            if (output.write(workspaceDir, registry) && output.restartNotice)
-                console.warn(`[ajs-dms] ${output.restartNotice}`);
+            const isChanged = output.write(workspaceDir, registry);
+            recover(output);
+            if (isChanged)
+                noticeRestart(output, paths);
         }
         catch (err) {
-            console.warn(`[ajs-dms] ${output.name} not regenerated:`, err);
+            fail(output, describeOutputFailure(output, err, reporter));
         }
     };
     const refresh = () => {
         timer = null;
-        const outputs = derived_outputs_1.DERIVED_OUTPUTS.filter((output) => pending.has(output));
+        const outputs = derived_outputs_1.DERIVED_OUTPUTS.filter((output) => pending.has(output)).map((output) => [output, pending.get(output) ?? []]);
         pending.clear();
         let registry;
         try {
             registry = (0, derived_outputs_1.createFrontendModuleRegistry)(workspaceDir, layers);
+            recover("registry");
         }
         catch (err) {
-            console.warn("[ajs-dms] derived files not regenerated:", err);
+            fail("registry", {
+                text: "Derived files not regenerated",
+                options: {
+                    details: [
+                        ...reporter.describe(err),
+                        "The dev server keeps the previous ones until the module is fixed.",
+                    ],
+                },
+                fixed: "Derived files regenerated",
+            });
             return;
         }
-        for (const output of outputs)
-            regenerate(output, registry);
+        for (const [output, paths] of outputs)
+            regenerate(output, paths, registry);
     };
     return {
-        schedule(paths) {
-            const affected = derived_outputs_1.DERIVED_OUTPUTS.filter((output) => paths.some((path) => output.affects(path)));
-            if (affected.length === 0)
+        schedule(src, paths) {
+            let isAffected = false;
+            for (const output of derived_outputs_1.DERIVED_OUTPUTS) {
+                const affected = paths.filter((path) => output.affects(path));
+                if (affected.length === 0)
+                    continue;
+                isAffected = true;
+                pending.set(output, [
+                    ...(pending.get(output) ?? []),
+                    ...affected.map((path) => (0, node_path_1.join)(src, path)),
+                ]);
+            }
+            if (!isAffected)
                 return;
-            for (const output of affected)
-                pending.add(output);
             if (timer)
                 clearTimeout(timer);
             timer = setTimeout(refresh, DERIVED_REFRESH_DEBOUNCE_MS);
@@ -179,16 +272,26 @@ function createDerivedOutputRefresher(workspaceDir, layers) {
         },
     };
 }
-function startLayerWatchers(workspaceDir, layers) {
+function startLayerWatchers(workspaceDir, layers, ui = (0, cli_1.getProcessUi)(), write = output_1.writeFeedback) {
+    const mapPath = (0, child_output_1.createPathMapper)(workspaceDir, layers.map((layer) => ({ ...layer, sourcePath: layer.path })));
+    const reporter = {
+        warn: (text, options) => write((0, output_1.formatTimedMessage)("warn", text, options, ui)),
+        succeed: (text) => write((0, output_1.formatTimedMessage)("success", text, {}, ui)),
+        describe: (error) => (0, output_1.failureDetails)(error, ui).map((line) => mapPath(line)),
+        show: (path) => {
+            const mapped = mapPath(path);
+            return mapped === path ? (0, output_1.showPath)(path) : mapped;
+        },
+    };
     const watchers = [];
     const syncs = [];
-    const refresher = createDerivedOutputRefresher(workspaceDir, layers);
+    const refresher = createDerivedOutputRefresher(workspaceDir, layers, reporter);
     for (const layer of layers) {
         if (!layer.packageName)
             continue;
         const dest = (0, layers_1.getLayerWorkspacePath)(workspaceDir, layer);
         const src = layer.path;
-        const sync = createLayerSync(src, dest, (paths) => refresher.schedule(paths));
+        const sync = createLayerSync(src, dest, (paths) => refresher.schedule(src, paths), reporter);
         syncs.push(sync);
         const watcher = chokidar_1.default.watch(src, {
             ignoreInitial: true,

package/dist/layers.d.ts

@@ -1,13 +1,13 @@
 import { ServedWithPath } from "./manifest";
 import { ManifestModule, ResolvedLayer } from "./workspace";
-export declare function assertLayerPathsServed(modules: ManifestModule[]): asserts modules is ServedWithPath[];
+export declare function assertLayerPathsServed(modules: ManifestModule[], backendUrl: string, bootstrapSecret?: string): asserts modules is ServedWithPath[];
 export declare function assertCachedArchivesExist(modules: ManifestModule[], cacheDir: string, fetchedAt?: string): void;
 export interface LayerPackage {
     name?: unknown;
     engines?: Record<string, unknown>;
 }
 export declare function readLayerPackage(layerPath: string): LayerPackage | undefined;
-export declare function buildLayersFromPaths(modules: ManifestModule[]): ResolvedLayer[];
+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;

package/dist/layers.js

@@ -1,4 +1,37 @@
 "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;
@@ -13,30 +46,46 @@ 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 unzipper_1 = require("unzipper");
+const cli_1 = require("@antelopejs/core/cli");
 const manifest_1 = require("./manifest");
-const workspace_1 = require("./workspace");
 const fs_sync_1 = require("./fs-sync");
 const config_1 = require("./config");
-function assertLayerPathsServed(modules) {
+const output_1 = require("./output");
+function assertLayerPathsServed(modules, backendUrl, bootstrapSecret) {
     const pathless = modules.filter((mod) => !mod.path);
     if (pathless.length === 0)
         return;
-    throw new Error("The backend served a manifest without layer source paths:\n" +
-        pathless.map((mod) => `  - ${mod.name}`).join("\n") +
-        "\n`ajs dms dev` needs a development backend running on this machine (started with " +
-        "`ajs project dev`); use `ajs dms build` against a remote or production one.\n" +
-        "If the backend is local and in development mode, it did not recognize the bootstrap " +
-        "credential — see DMS_BOOTSTRAP_SECRET.");
+    const count = `${pathless.length} of ${modules.length} module${modules.length === 1 ? "" : "s"}`;
+    const { reason, fix } = bootstrapSecret
+        ? {
+            reason: "It sends them only to callers presenting its development credential, and did not accept the one this run sent.",
+            fix: "Run the command from the antelope project started with `ajs project dev`, without DMS_BOOTSTRAP_SECRET or --bootstrap-secret, so the credential is read from .antelope/dms-dev.json",
+        }
+        : {
+            reason: "It sends them only to callers presenting its development credential, and this run sent none: " +
+                "no DMS_BOOTSTRAP_SECRET or --bootstrap-secret, and no project started with `ajs project dev` " +
+                "serving this backend was found from the current directory, so no .antelope/dms-dev.json was read.",
+            fix: "Run the command from that project, or set DMS_BOOTSTRAP_SECRET to the backend's credential",
+        };
+    throw new cli_1.CliError({
+        title: `The backend at ${(0, manifest_1.displayUrl)(backendUrl)} did not send layer source paths (${count})`,
+        reason,
+        fixes: [
+            fix,
+            "A remote or production backend never sends them: use `ajs dms build` against it",
+        ],
+    });
 }
 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 Error(`Cached layers archive is missing entries listed in the manifest${fetchedAt ? ` (fetched ${fetchedAt})` : ""}:\n` +
-        missing.map((mod) => `  - ${mod.name}: ${mod.archiveName}`).join("\n") +
-        "\nRun once with the backend reachable to re-download the layers.");
+    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);
@@ -59,6 +108,7 @@ function readLayerPackageName(layerPath) {
 function resolveLayer(layerPath, mod) {
     return {
         path: layerPath,
+        sourcePath: mod.path,
         packageName: readLayerPackageName(layerPath),
         priority: mod.priority,
         configKey: mod.configKey,
@@ -67,34 +117,32 @@ function resolveLayer(layerPath, mod) {
     };
 }
 function buildLayersFromPaths(modules) {
-    assertLayerPathsServed(modules);
     return sortModulesByPriority(modules).map((mod) => resolveLayer(mod.path, mod));
 }
 async function downloadAndExtractLayers(backendUrl, packUrl, cacheDir, force, bootstrapSecret) {
-    const url = `${backendUrl}${packUrl}`;
-    const response = await fetch(url, {
-        headers: (0, workspace_1.bootstrapHeaders)(bootstrapSecret),
-    });
-    if ((0, workspace_1.isUnauthorized)(response.status)) {
-        throw new manifest_1.ManifestUnauthorizedError(url, response.status);
+    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.ok || !response.body) {
-        throw new Error("Failed to download layers archive");
+    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 unzipper_1.Open.buffer(modulesBlob)).extract({ path: cacheDir });
+        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 unzipper_1.Open.buffer(modulesBlob)).extract({ path: tempDir });
+    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));

package/dist/manifest-secrets.d.ts

@@ -1,3 +1,4 @@
+import { type Ui } from "@antelopejs/core/cli";
 import type { ManifestModule } from "./workspace";
 export declare const MANIFEST_SECRET_ENV: {
     readonly DMS_HTML_RENDER_SECRET: readonly ["htmlRender", "serviceSecret"];
@@ -26,6 +27,6 @@ export interface ResolvedManifestSecrets {
 export declare function collectManifestSecrets(modules: readonly ManifestModule[]): ManifestSecrets;
 export declare function resolveManifestSecrets(secrets: ManifestSecrets, env?: NodeJS.ProcessEnv): ResolvedManifestSecrets;
 export declare function formatSecretConflicts(conflicts: readonly ManifestSecretConflict[]): string[];
-export declare function formatSecretSources(sources: ResolvedManifestSecrets["sources"], manifestLabel?: string): string[];
-export declare function reportManifestSecrets(resolved: ResolvedManifestSecrets, manifestLabel?: string, log?: (line: string) => void): void;
+export declare function describeSecretSources(sources: ResolvedManifestSecrets["sources"], manifestLabel?: string): string | undefined;
+export declare function reportManifestSecrets(resolved: ResolvedManifestSecrets, fix: (count: number) => string, ui?: Ui): void;
 export {};