@phreshos/cli 0.1.4 → 0.1.6

package/dist/cli.js

@@ -1,261 +1,155 @@
 #!/usr/bin/env node
-import { bold, dim, heading } from "./style.js";
+import { Command, Option } from "commander";
 import metadata from "../package.json" with { type: "json" };
+import { PromptCancelled } from "./prompts.js";
 import create from "./create.js";
 import install from "./install.js";
 import launch from "./launch.js";
 import init from "./init.js";
 import pack from "./pack.js";
 import uninstall from "./uninstall.js";
+import systemCommands from "./system/command.js";
 const { version } = metadata;
 const coreRange = metadata.dependencies["@phreshos/core"];
-/**
- * One command system.
- *
- * Every command declares its options beside its help and all of them pass
- * through the same parser, error presentation, and exit rules. Interactive
- * behavior belongs to the command that needs it; parsing never guesses.
- */
-const commands = [
-    {
-        name: "create",
-        summary: "create a new Program project",
-        detail: [
-            "Creates a complete Server and Client project from the maintained",
-            "Get Started template bundled with this CLI.",
-            "",
-            "In a terminal, an omitted directory and the readable Program name",
-            "are collected interactively. Automation supplies the directory as",
-            "the first argument and may use named options."
-        ],
-        positionals: [{ name: "directory", required: false }],
-        options: [
-            { name: "name", value: "name", summary: "human-readable Program name" },
-            { name: "package-manager", value: "manager", summary: "bun, npm, pnpm, or yarn" },
-            { name: "no-install", summary: "create files without installing dependencies" }
-        ],
-        run: options => create({
-            directory: options.positionals[0],
-            name: text(options, "name"),
-            packageManager: packageManager(text(options, "package-manager")),
-            install: options["no-install"] !== true
-        })
-    },
-    {
-        name: "init",
-        summary: "initialize an existing Program project",
-        detail: [
-            "Reads identity, version, and description from package.json, then",
-            "writes phresh.config.ts. In a terminal it asks only for the Program",
-            "shape and values package.json cannot provide.",
-            "",
-            "Without a terminal, declare at least one half with named options.",
-            "No prompt is opened and no input is awaited."
-        ],
-        options: [
-            { name: "name", value: "name", summary: "human-readable Program name" },
-            { name: "api-docs", value: "path", summary: "official Program API documentation" },
-            { name: "build-command", value: "command", summary: "prepare production files before use" },
-            { name: "server", summary: "include a server half" },
-            { name: "server-location", value: "path", summary: "production server directory" },
-            { name: "server-start-command", value: "command", summary: "production server command" },
-            { name: "server-development-start-command", value: "command", summary: "development server command" },
-            { name: "client", summary: "include a client half" },
-            { name: "client-location", value: "path", summary: "production client directory" },
-            { name: "client-development-url", value: "url", summary: "development client URL" },
-            { name: "client-development-start-command", value: "command", summary: "client development command" },
-            { name: "force", summary: "replace an existing phresh.config.ts" }
-        ],
-        run: options => init({
-            name: text(options, "name"),
-            apiDocs: text(options, "api-docs"),
-            buildCommand: text(options, "build-command"),
-            server: options.server === true || text(options, "server-location") !== undefined || text(options, "server-start-command") !== undefined,
-            serverLocation: text(options, "server-location"),
-            serverStartCommand: text(options, "server-start-command"),
-            serverDevelopmentStartCommand: text(options, "server-development-start-command"),
-            client: options.client === true || text(options, "client-location") !== undefined,
-            clientLocation: text(options, "client-location"),
-            clientDevelopmentUrl: text(options, "client-development-url"),
-            clientDevelopmentStartCommand: text(options, "client-development-start-command"),
-            force: options.force === true
-        }, process.cwd(), coreRange)
-    },
-    {
-        name: "pack",
-        summary: "build and package this Program",
-        detail: [
-            "Runs an optional buildCommand, then assembles each half from where",
-            "the config says the production files are.",
-            "",
-            "A package carries a Program to another machine. Installing this",
-            "project takes no package because its description already names the",
-            "files on this machine."
-        ],
-        run: () => pack()
-    },
-    {
-        name: "install",
-        summary: "install this Program",
-        detail: [
-            "Builds and lays out the Program declared by this project.",
-            "",
-            "Running processes end before installed paths change. Program data is",
-            "preserved."
-        ],
-        run: () => install()
-    },
-    {
-        name: "uninstall",
-        summary: "uninstall this Program",
-        detail: [
-            "Removes the installed Program files. Its running processes, stored",
-            "data, and runtime Program remain available.",
-            "",
-            "--everything ends its processes, removes everything the system owns",
-            "for it, and forgets the runtime Program."
-        ],
-        options: [
-            { name: "everything", summary: "also remove processes, data, and runtime state" }
-        ],
-        run: options => uninstall(options.everything === true)
-    },
-    {
-        name: "start",
-        summary: "run the production Program without installing",
-        detail: [
-            "Runs this Program attached to the terminal. Its output arrives here,",
-            "and when this command ends the system stops the Program.",
-            "",
-            "An optional buildCommand runs before the production Program starts.",
-            "The Program's exit status becomes this command's exit status."
-        ],
-        runOptions: true,
-        run: options => launch("production", process.cwd(), options.run)
-    },
-    {
-        name: "dev",
-        summary: "run the development Program without installing",
-        detail: [
-            "Runs the same attached lifecycle as start, using each half's",
-            "development declaration.",
-            "",
-            "A declared client development command belongs to this session. Its",
-            "URL must respond within 15 seconds before the Program launches."
-        ],
-        runOptions: true,
-        run: options => launch("development", process.cwd(), options.run)
-    }
-];
 const runOptionPrefix = "--run-option-";
-const [asked = "", ...rest] = process.argv.slice(2);
-if (asked === "--version" || asked === "-v") {
-    console.log(version);
-    process.exit(0);
-}
-const wanted = commands.find(command => command.name === asked);
-if (!asked || asked === "--help" || asked === "-h") {
-    usage();
-    process.exit(0);
-}
-if (!wanted) {
-    console.error(`\n  phresh: no such command "${asked}"`);
-    usage();
-    process.exit(1);
-}
-if (rest.includes("--help") || rest.includes("-h")) {
-    about(wanted);
-    process.exit(0);
-}
+const program = new Command()
+    .name("phresh")
+    .description("Create Programs and manage PhreshOS")
+    .version(version, "-v, --version")
+    .showHelpAfterError()
+    .showSuggestionAfterError();
+program.addHelpText("after", "\nRun phresh <command> --help for detailed command guidance.\n");
+describe(program.command("create")
+    .description("create a new Program project")
+    .argument("[directory]", "directory for the new Program")
+    .option("--name <name>", "human-readable Program name")
+    .addOption(new Option("--package-manager <manager>", "package manager used to install dependencies").choices(["bun", "npm", "pnpm", "yarn"]))
+    .option("--no-install", "create files without installing dependencies")
+    .action(async function (directory, options) {
+    await create({
+        directory,
+        name: options.name,
+        packageManager: options.packageManager,
+        install: options.install
+    });
+}), [
+    "Creates a complete Server and Client project from the maintained",
+    "Phresh Program template bundled with this CLI.",
+    "",
+    "In a terminal, omitted values are collected interactively. Automation",
+    "supplies the directory and optional choices through named options."
+]);
+describe(program.command("init")
+    .description("initialize an existing Program project")
+    .option("--name <name>", "human-readable Program name")
+    .option("--api-docs <path>", "official Program API documentation")
+    .option("--build-command <command>", "prepare production files before use")
+    .option("--server", "include a Server endpoint")
+    .option("--server-location <path>", "production Server directory")
+    .option("--server-start-command <command>", "production Server command")
+    .option("--server-development-start-command <command>", "development Server command")
+    .option("--client", "include a Client endpoint")
+    .option("--client-location <path>", "production Client directory")
+    .option("--client-development-url <url>", "development Client URL")
+    .option("--client-development-start-command <command>", "development Client command")
+    .option("--force", "replace an existing phresh.config.ts")
+    .action(async function (options) {
+    await init({
+        name: options.name,
+        apiDocs: options.apiDocs,
+        buildCommand: options.buildCommand,
+        server: options.server === true || options.serverLocation !== undefined || options.serverStartCommand !== undefined,
+        serverLocation: options.serverLocation,
+        serverStartCommand: options.serverStartCommand,
+        serverDevelopmentStartCommand: options.serverDevelopmentStartCommand,
+        client: options.client === true || options.clientLocation !== undefined,
+        clientLocation: options.clientLocation,
+        clientDevelopmentUrl: options.clientDevelopmentUrl,
+        clientDevelopmentStartCommand: options.clientDevelopmentStartCommand,
+        force: options.force === true
+    }, process.cwd(), coreRange);
+}), [
+    "Reads identity, version, and description from package.json, then writes",
+    "phresh.config.ts. A terminal asks only for values the project cannot",
+    "provide. Without a terminal, declare at least one endpoint with options."
+]);
+describe(program.command("pack")
+    .description("build and package this Program")
+    .action(async function () {
+    await pack();
+}), [
+    "Runs an optional buildCommand, then packages the production files",
+    "declared for each endpoint."
+]);
+describe(program.command("install")
+    .description("install this Program")
+    .action(async function () {
+    await install();
+}), [
+    "Builds and installs the Program declared by this project. Running",
+    "Processes end before installed paths change; Program data is preserved."
+]);
+describe(program.command("uninstall")
+    .description("uninstall this Program")
+    .option("--everything", "also remove Processes, data, and runtime state")
+    .action(async function (options) {
+    await uninstall(options.everything === true);
+}), [
+    "Removes the installed Program files while preserving its Processes, data,",
+    "and runtime Program. --everything removes all system-owned state."
+]);
+attached("start", "run the production Program without installing", [
+    "Runs this Program attached to the terminal. Output arrives here, and",
+    "ending this command stops the Program. An optional buildCommand runs",
+    "before launch, and the Program's exit status becomes this command's status."
+], "production");
+attached("dev", "run the development Program without installing", [
+    "Runs the same attached lifecycle as start using the development",
+    "declarations. A Client URL must respond within 15 seconds before launch."
+], "development");
+systemCommands(program);
+// Every command begins with the same breathing room. Keep this at the entry
+// point so individual commands never need to manufacture their own opening.
+console.log("");
+if (process.argv.length === 2)
+    program.help();
 try {
-    await wanted.run(parse(wanted, rest));
+    await program.parseAsync();
 }
 catch (error) {
-    console.error(`\n  phresh: ${error instanceof Error ? error.message : String(error)}\n`);
-    process.exit(1);
-}
-function parse(command, args) {
-    const options = { run: {}, positionals: [] };
-    for (let index = 0; index < args.length; index += 1) {
-        const argument = args[index];
-        if (command.runOptions && argument.startsWith(runOptionPrefix)) {
-            const said = argument.slice(runOptionPrefix.length);
-            const at = said.indexOf("=");
-            if (at < 1)
-                throw new Error(`"${argument}" says no value — write ${runOptionPrefix}<name>=<value>, and end with = for an empty value`);
-            const name = said.slice(0, at);
-            if (Object.hasOwn(options.run, name))
-                throw new Error(`The run option "${name}" was given more than once`);
-            options.run[name] = said.slice(at + 1);
-            continue;
-        }
-        if (!argument.startsWith("--")) {
-            const positional = command.positionals?.[options.positionals.length];
-            if (!positional)
-                throw new Error(`${command.name} takes no more positional arguments, and I was given "${argument}"`);
-            options.positionals.push(argument);
-            continue;
-        }
-        const at = argument.indexOf("=");
-        const name = argument.slice(2, at < 0 ? undefined : at);
-        const declared = command.options?.find(option => option.name === name);
-        if (!declared)
-            throw new Error(`${command.name} does not know the option "--${name}"`);
-        if (Object.hasOwn(options, name))
-            throw new Error(`The option "--${name}" was given more than once`);
-        if (!declared.value) {
-            if (at >= 0)
-                throw new Error(`--${name} does not take a value`);
-            options[name] = true;
-            continue;
-        }
-        const value = at >= 0 ? argument.slice(at + 1) : args[++index];
-        if (value === undefined || at < 0 && value.startsWith("--"))
-            throw new Error(`--${name} needs <${declared.value}>`);
-        options[name] = value;
+    if (error instanceof PromptCancelled)
+        process.exitCode = 0;
+    else {
+        console.error(`\n  phresh: ${error instanceof Error ? error.message : String(error)}\n`);
+        process.exitCode = 1;
     }
-    const missing = command.positionals?.slice(options.positionals.length).find(positional => positional.required);
-    if (missing)
-        throw new Error(`${command.name} needs <${missing.name}>`);
-    return options;
-}
-function text(options, name) {
-    const value = options[name];
-    return typeof value === "string" ? value : undefined;
 }
-function packageManager(value) {
-    if (value === undefined || value === "bun" || value === "npm" || value === "pnpm" || value === "yarn")
-        return value;
-    throw new Error(`--package-manager must be bun, npm, pnpm, or yarn; received "${value}"`);
+function attached(name, summary, detail, mode) {
+    describe(program.command(name)
+        .description(summary)
+        .argument("[run-options...]", "--run-option-<name>=<value> values passed to the Program")
+        .allowUnknownOption()
+        .action(async function (args) {
+        await launch(mode, process.cwd(), runOptions(name, args));
+    }), detail);
 }
-function usage() {
-    heading(`phresh ${version}`, "create and manage Programs");
-    for (const command of commands)
-        console.log(`  ${bold(command.name.padEnd(12))}${command.summary}`);
-    console.log("");
-    console.log(`  ${dim("phresh <command> --help".padEnd(32))}${dim("show one command in detail")}`);
-    console.log("");
+function describe(command, paragraphs) {
+    command.addHelpText("after", `\n${paragraphs.map(line => line ? `  ${line}` : "").join("\n")}\n`);
+    return command;
 }
-function about(command) {
-    const positionals = command.positionals?.map(positional => positional.required ? `<${positional.name}>` : `[${positional.name}]`).join(" ");
-    const signature = [`phresh ${command.name}`, positionals, command.options?.length || command.runOptions ? "[options]" : ""].filter(Boolean).join(" ");
-    heading(signature, command.summary);
-    for (const said of command.detail)
-        console.log(said ? `  ${said}` : "");
-    if (command.options?.length || command.runOptions) {
-        console.log("");
-        console.log(`  ${bold("Options")}`);
-        console.log("");
-        const signatures = (command.options ?? []).map(option => `--${option.name}${option.value ? ` <${option.value}>` : ""}`);
-        if (command.runOptions)
-            signatures.push(runOptionPrefix + "<name>=<value>");
-        const width = Math.max(34, ...signatures.map(signature => signature.length + 2));
-        for (const option of command.options ?? []) {
-            const signature = `--${option.name}${option.value ? ` <${option.value}>` : ""}`;
-            console.log(`  ${signature.padEnd(width)}${dim(option.summary)}`);
-        }
-        if (command.runOptions)
-            console.log(`  ${(runOptionPrefix + "<name>=<value>").padEnd(width)}${dim("pass text to the launched Program")}`);
+function runOptions(command, args) {
+    const options = {};
+    for (const argument of args) {
+        if (!argument.startsWith(runOptionPrefix))
+            throw new Error(`${command} accepts Program options only as ${runOptionPrefix}<name>=<value>; received "${argument}"`);
+        const said = argument.slice(runOptionPrefix.length);
+        const at = said.indexOf("=");
+        if (at < 1)
+            throw new Error(`"${argument}" says no value — write ${runOptionPrefix}<name>=<value>, and end with = for an empty value`);
+        const name = said.slice(0, at);
+        if (Object.hasOwn(options, name))
+            throw new Error(`The run option "${name}" was given more than once`);
+        options[name] = said.slice(at + 1);
     }
-    console.log("");
+    return options;
 }

package/dist/create.js

@@ -1,83 +1,88 @@
-import { projectDependency, installProjectDependencies, projectPackageManager } from "./project-dependency.js";
-import questions from "./questions.js";
-import { dim, heading, line } from "./style.js";
+import { installProjectDependencies, projectPackageManager, projectScript } from "./project-dependency.js";
+import prompts from "./prompts.js";
+import { accent, bold } from "./style.js";
 import { cpSync, existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import { basename, dirname, extname, relative, resolve } from "node:path";
-/** Creates a complete Program from the bundled Get Started snapshot. */
+/** Creates a complete Program from the bundled Phresh Program snapshot. */
 export default async function create(options = {}, directory = process.cwd()) {
-    const prompts = questions();
+    const interaction = prompts();
+    interaction.begin("Create Program", "Phresh Program");
+    const requested = options.directory ?? (interaction.interactive
+        ? await interaction.ask("A new directory will contain the complete Server and Client project.", "Where should the Program be created?", "my-program")
+        : undefined);
+    if (!requested)
+        throw new Error("create needs a <directory> when no terminal is attached");
+    const target = resolve(directory, requested);
+    const identity = basename(target);
+    if (!programIdentity.test(identity))
+        throw new Error(`The directory name must be a kebab-case Program identity; received "${identity}"`);
+    if (existsSync(target))
+        throw new Error(`The destination already exists: ${target}`);
+    const name = options.name ?? (interaction.interactive
+        ? await interaction.ask("This name is shown to people; the directory name remains the Program identity.", "What name should people see?", title(identity))
+        : title(identity));
+    if (!name.trim())
+        throw new Error("--name must not be empty");
+    const install = options.install !== false;
+    const detected = projectPackageManager(directory).name;
+    const manager = options.packageManager ?? (install && interaction.interactive
+        ? packageManager(await interaction.choose("The generated project remains portable; this choice installs its dependencies now.", "Which package manager should be used?", packageManagers, detected))
+        : detected);
+    const parent = dirname(target);
+    mkdirSync(parent, { recursive: true });
+    const staging = mkdtempSync(resolve(parent, `.${identity}-`));
+    const bundled = template();
+    let placed = false;
     try {
-        const requested = options.directory ?? (prompts.interactive
-            ? await prompts.ask("A new directory will contain the complete Server and Client project.", "Where should the Program be created?", "my-program")
-            : undefined);
-        if (!requested)
-            throw new Error("create needs a <directory> when no terminal is attached");
-        const target = resolve(directory, requested);
-        const identity = basename(target);
-        if (!programIdentity.test(identity))
-            throw new Error(`The directory name must be a kebab-case Program identity; received "${identity}"`);
-        if (existsSync(target))
-            throw new Error(`The destination already exists: ${target}`);
-        const name = options.name ?? (prompts.interactive
-            ? await prompts.ask("This name is shown to people; the directory name remains the Program identity.", "What name should people see?", title(identity))
-            : title(identity));
-        if (!name.trim())
-            throw new Error("--name must not be empty");
-        const install = options.install !== false;
-        const detected = projectPackageManager(directory).name;
-        const manager = options.packageManager ?? (install && prompts.interactive
-            ? packageManager(await prompts.ask("The generated project remains portable; this choice installs its dependencies now.", "Which package manager should be used?", detected))
-            : detected);
-        heading("Create Program", name);
-        line("identity", identity);
-        line("directory", target);
-        line("template", "Get Started");
+        cpSync(bundled.directory, staging, { recursive: true });
+        renameSync(resolve(staging, "gitignore"), resolve(staging, ".gitignore"));
+        customize(staging, identity, name, manager);
+        renameSync(staging, target);
+        placed = true;
+        // A project inside this repository becomes a real workspace member
+        // only at its final path. Install there so package selection sees the
+        // same project boundary that subsequent commands will see.
         if (install)
-            line("packages", manager);
-        console.log("");
-        const parent = dirname(target);
-        mkdirSync(parent, { recursive: true });
-        const staging = mkdtempSync(resolve(parent, `.${identity}-`));
-        try {
-            cpSync(template(), staging, { recursive: true });
-            renameSync(resolve(staging, "gitignore"), resolve(staging, ".gitignore"));
-            customize(staging, target, identity, name, manager);
-            if (install)
-                await installProjectDependencies(staging, manager);
-            renameSync(staging, target);
-        }
-        catch (error) {
-            rmSync(staging, { recursive: true, force: true });
-            throw error;
-        }
-        heading(name, "created");
-        line("directory", target);
-        line("packages", install ? "installed" : "not installed");
-        console.log("");
-        console.log(`  ${dim("Next:")} cd ${relative(directory, target) || "."}`);
-        if (!install)
-            console.log(`        ${manager} install`);
-        console.log("        phresh dev");
-        console.log("");
+            await interaction.progress("Installing dependencies", "Dependencies installed", () => installProjectDependencies(target, manager, interaction.interactive ? "capture" : "inherit"));
+    }
+    catch (error) {
+        rmSync(placed ? target : staging, { recursive: true, force: true });
+        throw error;
     }
-    finally {
-        prompts.close();
+    interaction.finish("Done");
+    console.log(bold("\nOpen the project"));
+    console.log(accent(`cd ${relative(directory, target) || "."}`));
+    if (!install) {
+        console.log(bold("\nInstall dependencies"));
+        console.log(accent(installCommand(manager)));
     }
+    const script = projectScript(target, manager, bundled.development ? "dev" : "start");
+    console.log(bold(`\n${bundled.development ? "Run Development Program" : "Run Program"}`));
+    console.log(accent(script));
+    console.log(bold("\nYou can now open the project and start building your Program"));
 }
 function template() {
     const candidates = [
         resolve(import.meta.dirname, "template"),
         resolve(import.meta.dirname, "..", "dist", "template")
     ];
-    const found = candidates.find(existsSync);
-    if (!found)
-        throw new Error("The CLI template has not been built — run its build command and try again");
-    return found;
+    for (const directory of candidates) {
+        if (!existsSync(directory))
+            continue;
+        const descriptionPath = resolve(dirname(directory), "template.json");
+        if (!existsSync(descriptionPath))
+            throw new Error("The CLI template description has not been built — run its build command and try again");
+        const description = JSON.parse(readFileSync(descriptionPath, "utf-8"));
+        if (typeof description.development !== "boolean")
+            throw new Error("The CLI template description is invalid — run its build command and try again");
+        return { directory, development: description.development };
+    }
+    throw new Error("The CLI template has not been built — run its build command and try again");
 }
-function customize(directory, finalDirectory, identity, name, manager) {
+function customize(directory, identity, name, manager) {
     for (const path of textFiles(directory)) {
         let content = readFileSync(path, "utf-8");
-        content = content.replaceAll("get-started", identity).replaceAll("Get Started", name);
+        content = content.replaceAll("phresh-program", identity).replaceAll("Phresh Program", name);
         if (basename(path) === "README.md") {
             content = content
                 .replaceAll("bun install", `${manager} install`)
@@ -88,15 +93,6 @@ function customize(directory, finalDirectory, identity, name, manager) {
     const manifestPath = resolve(directory, "package.json");
     const manifest = JSON.parse(readFileSync(manifestPath, "utf-8"));
     manifest.name = identity;
-    for (const dependencies of [manifest.dependencies, manifest.devDependencies]) {
-        if (!dependencies)
-            continue;
-        for (const [dependency, range] of Object.entries(dependencies)) {
-            if (!isProjectPackage(dependency))
-                continue;
-            dependencies[dependency] = projectDependency(dependency, range, finalDirectory).manifestSpecifier;
-        }
-    }
     writeFileSync(manifestPath, JSON.stringify(manifest, null, 4) + "\n");
 }
 function textFiles(directory) {
@@ -115,16 +111,13 @@ function packageManager(value) {
         return value;
     throw new Error(`The package manager must be bun, npm, pnpm, or yarn; received "${value}"`);
 }
-function isProjectPackage(value) {
-    return value === "@phreshos/core"
-        || value === "@phreshos/client"
-        || value === "@phreshos/server"
-        || value === "@phreshos/react"
-        || value === "@phreshos/cli";
-}
 function title(identity) {
     return identity.split("-").map(word => word[0].toUpperCase() + word.slice(1)).join(" ");
 }
+function installCommand(manager) {
+    return `${manager} install`;
+}
 const programIdentity = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
 const textExtensions = new Set([".css", ".html", ".json", ".md", ".ts", ".tsx"]);
 const textNames = new Set([".gitignore", "gitignore"]);
+const packageManagers = ["bun", "npm", "pnpm", "yarn"];

package/dist/derive.js

@@ -27,14 +27,14 @@ export default function derive(config, directory, which) {
         name: config.name,
         version: config.version,
         description: config.description,
-        // Like icons, the document stays where the author put it for an
+        // Like the icon, the document stays where the author put it for an
         // attached run. Installation and packaging give it its canonical
         // name; the runtime receives an absolute source path here because a
         // derived description has no file beside which to resolve it.
         apiDocs: config.apiDocs && resolve(directory, config.apiDocs),
-        // Where they already are. Unlike pack, which stages them, this
-        // points into the authoring tree and leaves it alone.
-        icons: config.icons && resolve(directory, config.icons),
+        // Where it already is. Unlike pack, which gives it its canonical
+        // name, this points into the authoring tree and leaves it alone.
+        icon: config.icon && resolve(directory, config.icon),
         // Beside the source, and said out loud. A program built from an
         // object resolves what it leaves unsaid against the *system's*
         // working directory — so silence here means a program keeps what