@valancex/cli 0.11.0 → 0.13.0

package/dist/config.js

@@ -4,8 +4,10 @@
 import { existsSync, readFileSync, realpathSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { AppError, diagnostic, lineOf } from "./diagnostics.js";
+import { DEFAULT_TITLE } from "@valancex/common/internal";
 export const PROJECT_FILE = "valance.json";
 export const WEB_FILE = "valance.web.json";
+export const DESKTOP_FILE = "valance.desktop.json";
 /** The only version of both files there is. */
 export const CONFIG_VERSION = 1;
 const read = (root, file) => {
@@ -60,6 +62,35 @@ const url = (value) => {
         return "must be an absolute address such as https://example.com";
     }
 };
+const title = (value) => typeof value === "string" && value.includes("{page}") && value.length <= 120 && !/[{}]/.test(value.replaceAll("{page}", "").replaceAll("{site}", ""))
+    ? undefined
+    : 'must contain "{page}" and may use "{site}", for example "{page} · {site}" (at most 120 characters)';
+const flag = (value) => (typeof value === "boolean" ? undefined : "must be true or false");
+const api = (value) => {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return 'must be an object such as { "base": "/api" }';
+    }
+    const given = value;
+    const unknown = Object.keys(given).filter((key) => key !== "base" && key !== "proxy");
+    if (unknown.length > 0) {
+        return `has unknown settings ${unknown.map((key) => `"${key}"`).join(", ")} (known: base, proxy)`;
+    }
+    if (typeof given["base"] !== "string" || !/^(\/([\w.~-]+\/?)*|https:\/\/[^\s/]+(\/[^\s]*)?)$/.test(given["base"]) || given["base"].endsWith("//")) {
+        return '"base" must be a path on the site ("/api") or an absolute https address ("https://api.example.com")';
+    }
+    if (given["proxy"] !== undefined) {
+        try {
+            const target = new URL(String(given["proxy"]));
+            if (!target.protocol.startsWith("http") || !given["base"].startsWith("/")) {
+                return '"proxy" is an http(s) address that a path "base" is forwarded to while you run vlx dev';
+            }
+        }
+        catch {
+            return '"proxy" must be an absolute address such as http://localhost:3000';
+        }
+    }
+    return undefined;
+};
 /** Reads and validates the project's configuration. Every problem in both files is reported together. */
 export const loadConfig = (root) => {
     const project = read(root, PROJECT_FILE);
@@ -67,17 +98,33 @@ export const loadConfig = (root) => {
         throw new AppError([diagnostic(PROJECT_FILE, 0, "config-missing", `there is no ${PROJECT_FILE} in ${root}`)]);
     }
     const web = read(root, WEB_FILE);
+    const desktop = read(root, DESKTOP_FILE);
     const problems = [
-        ...check(PROJECT_FILE, project.text, project.value, { $schema: schema, version, name: text }, ["name"]),
-        ...(web === undefined ? [] : check(WEB_FILE, web.text, web.value, { $schema: schema, version, base, url }, [])),
+        ...(desktop === undefined ? [] : check(DESKTOP_FILE, desktop.text, desktop.value, { $schema: schema, version }, [])),
+        ...check(PROJECT_FILE, project.text, project.value, { $schema: schema, version, name: text, title }, ["name"]),
+        ...(web === undefined ? [] : check(WEB_FILE, web.text, web.value, { $schema: schema, version, base, url, headers: flag, announce: flag, api }, [])),
     ];
     if (problems.length > 0) {
         throw new AppError(problems);
     }
     const given = (web?.value ?? {});
-    return { name: project.value.name, web: { base: given.base ?? "/", url: given.url ?? "" } };
+    const named = project.value;
+    return {
+        name: named.name,
+        targets: desktop === undefined ? ["web"] : web === undefined ? ["desktop"] : ["web", "desktop"],
+        title: named.title ?? DEFAULT_TITLE,
+        web: { base: given.base ?? "/", url: given.url ?? "", headers: given.headers ?? true, announce: given.announce ?? true },
+        api: { base: given.api?.base ?? "", proxy: given.api?.proxy ?? "" },
+    };
 };
-export const siteInfo = (config) => ({ name: config.name, base: config.web.base, url: config.web.url });
+export const siteInfo = (config) => ({
+    name: config.name,
+    base: config.web.base,
+    url: config.web.url,
+    title: config.title,
+    api: config.api.base,
+    announce: config.web.announce,
+});
 /**
  * The nearest directory at or above `from` that holds a `valance.json`, as its real path. The bundler names a file by its real path, so a project reached through a symlink, or by a short
  * Windows name (`RUNNER~1`), must be called the same thing here or a file is not the file the bundler means.

package/dist/content.js

@@ -2,6 +2,7 @@
 // discovery, front matter, Markdown, navigation order, and a check of every link and image against the pages and `public/` that exist.
 import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
 import { join, posix } from "node:path";
+import { siteInfo } from "./config.js";
 import { AppError, diagnostic } from "./diagnostics.js";
 import { parseMarkdown, plain } from "./markdown.js";
 export const CONTENT_DIR = "content";
@@ -188,6 +189,6 @@ export const readContent = (root, config) => {
         throw new AppError(problems);
     }
     const ordered = [...pages].sort((a, b) => (a.section === "" ? 0 : 1) - (b.section === "" ? 0 : 1) || a.section.localeCompare(b.section) || a.order - b.order || a.path.localeCompare(b.path));
-    return { site: { name: config.name, base: config.web.base, url: config.web.url }, pages: ordered, ...(fallback === undefined ? {} : { notFound: fallback }) };
+    return { site: siteInfo(config), pages: ordered, ...(fallback === undefined ? {} : { notFound: fallback }) };
 };
 export const sectionTitle = titleCase;

package/dist/dev-desktop.d.ts

@@ -0,0 +1,8 @@
+import type { Dev, DevOptions } from "./dev.js";
+/** Whether a changed file (relative to the project) is one the application is made of. */
+export declare const mattersToTheEngine: (file: string) => boolean;
+export interface DesktopDev extends Dev {
+    /** Resolves when the window is closed by the person (not by a rebuild). */
+    readonly closed: Promise<void>;
+}
+export declare const devDesktop: (root: string, options?: DevOptions) => Promise<DesktopDev>;

package/dist/dev-desktop.js

@@ -0,0 +1,114 @@
+import { spawn } from "node:child_process";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { watch } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { build } from "./build.js";
+import { AppError, format } from "./diagnostics.js";
+/** How long files must be quiet before a change is built (ms). */
+const QUIET = 150;
+/** Whether a changed file (relative to the project) is one the application is made of. */
+export const mattersToTheEngine = (file) => {
+    const name = file.split("\\").join("/");
+    return /^(content|src|public)\//.test(name) || /^valance(\.\w+)?\.json$/.test(name);
+};
+export const devDesktop = async (root, options = {}) => {
+    const log = options.log ?? ((line) => void console.log(line));
+    const program = process.env["VLX_WINDOW"] ?? "vlx-window";
+    let window;
+    let stopping = false;
+    let working = Promise.resolve();
+    let timer;
+    let leave = () => undefined;
+    const closed = new Promise((resolve) => {
+        leave = resolve;
+    });
+    const reloadDir = mkdtempSync(join(tmpdir(), "vlx-reload-"));
+    const reloadFile = join(reloadDir, "reload");
+    let reloads = 0;
+    writeFileSync(reloadFile, "0");
+    /** Tells a running window the engine was rebuilt: a new modification time on the file it watches. */
+    const touch = () => {
+        reloads += 1;
+        writeFileSync(reloadFile, String(reloads));
+    };
+    const stopWindow = async () => {
+        const running = window;
+        window = undefined;
+        if (running !== undefined && running.exitCode === null) {
+            const exited = new Promise((resolve) => running.once("exit", () => resolve()));
+            running.kill();
+            await exited;
+        }
+    };
+    const openWindow = (engine) => {
+        const child = spawn(program, [], { stdio: "inherit", env: { ...process.env, VLX_ENGINE: `${process.execPath} ${engine}`, VLX_RELOAD: reloadFile } });
+        window = child;
+        child.once("error", (error) => {
+            window = undefined;
+            log(error.code === "ENOENT"
+                ? `vlx: no window program "${program}": install it with \`cargo install --git https://github.com/ValanceX/Port valancex-port-desktop --bin vlx-window\`, or name it in VLX_WINDOW`
+                : `vlx: the window could not start: ${error.message}`);
+        });
+        child.once("exit", () => {
+            if (window === child && !stopping) {
+                window = undefined;
+                log("vlx: the window was closed");
+                leave();
+            }
+        });
+    };
+    const rebuild = async () => {
+        try {
+            const built = await build(root, { targets: ["desktop"] });
+            options.onStatus?.([]);
+            if (stopping) {
+                return;
+            }
+            if (window !== undefined && window.exitCode === null) {
+                touch();
+                log("vlx: built; the window restarts the engine");
+            }
+            else {
+                openWindow(join(built.dir, "desktop", "engine.mjs"));
+                log("vlx: built; the window is open");
+            }
+        }
+        catch (error) {
+            if (error instanceof AppError) {
+                options.onStatus?.(error.diagnostics);
+                error.diagnostics.forEach((each) => log(format(each)));
+            }
+            else {
+                log(`vlx: the build failed: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+    };
+    const queue = () => {
+        working = working.then(rebuild);
+    };
+    const watcher = watch(root, { recursive: true }, (_event, file) => {
+        if (file !== null && mattersToTheEngine(file)) {
+            clearTimeout(timer);
+            timer = setTimeout(queue, QUIET);
+        }
+    });
+    queue();
+    await working;
+    return {
+        url: "window",
+        closed,
+        settled: async () => {
+            await working;
+        },
+        close: async () => {
+            stopping = true;
+            clearTimeout(timer);
+            watcher.close();
+            await working;
+            await stopWindow();
+            rmSync(reloadDir, { recursive: true, force: true });
+            leave();
+        },
+    };
+};

package/dist/dev.d.ts

@@ -1,5 +1,8 @@
 import type { Diagnostic } from "./diagnostics.js";
+import type { TargetId } from "./targets.js";
 export interface DevOptions {
+    /** Which target to serve, for a project of more than one. */
+    readonly target?: TargetId;
     readonly port?: number;
     readonly host?: string;
     /** Called with each report (a rebuild, a mistake); defaults to the console. */

package/dist/dev.js

@@ -3,6 +3,7 @@ import { relative, sep } from "node:path";
 import { loadAuthor } from "./author.js";
 import { loadConfig, PROJECT_FILE, WEB_FILE } from "./config.js";
 import { AppError, format } from "./diagnostics.js";
+import { devDesktop } from "./dev-desktop.js";
 import { generateContent, generateEntries, generateProgram } from "./emit.js";
 import { GENERATED_DIR, OUTPUT_DIR } from "./project.js";
 import { baseConfig, SERVER_ENTRY } from "./vite.js";
@@ -50,11 +51,18 @@ const start = async (root, config, options, restart) => {
         });
     const failed = new Map();
     let pending = Promise.resolve();
-    generateEntries(root);
+    generateEntries(root, config);
     const base = baseConfig(root, config);
     const server = await createServer({
         ...base,
-        server: { port: options.port ?? 5173, host: options.host ?? "127.0.0.1", strictPort: false, fs: { allow: [root] } },
+        server: {
+            port: options.port ?? 5173,
+            host: options.host ?? "127.0.0.1",
+            strictPort: false,
+            fs: { allow: [root] },
+            // The backend, reached through the page's own origin: no CORS settings to write (valance.web.json `api`).
+            ...(config.api.proxy === "" || !config.api.base.startsWith("/") ? {} : { proxy: { [config.api.base.replace(/\/$/, "")]: { target: config.api.proxy, changeOrigin: true } } }),
+        },
         plugins: [
             ...(base.plugins ?? []),
             {
@@ -107,13 +115,13 @@ const start = async (root, config, options, restart) => {
         };
         const wasFailing = failed.size > 0;
         if (stages.includes("entries")) {
-            generateEntries(root);
+            generateEntries(root, config);
         }
         if (stages.includes("content")) {
             await run("content", () => generateContent(root, config));
         }
         if (stages.includes("program")) {
-            await run("templates", async () => generateProgram(root, await loadAuthor(server, root)));
+            await run("templates", async () => generateProgram(root, await loadAuthor(server, root), config, ["web"]));
         }
         const open = [...failed.values()].flat();
         options.onStatus?.(open);
@@ -169,7 +177,7 @@ const start = async (root, config, options, restart) => {
     // First build: a mistake here is reported like any other and the server still starts, so the overlay can show it.
     for (const [name, work] of [
         ["content", () => generateContent(root, config)],
-        ["templates", async () => generateProgram(root, await loadAuthor(server, root))],
+        ["templates", async () => generateProgram(root, await loadAuthor(server, root), config, ["web"])],
     ]) {
         try {
             await work();
@@ -199,6 +207,33 @@ const start = async (root, config, options, restart) => {
 };
 /** Starts the development server for the project at `root`. */
 export const dev = async (root, options = {}) => {
+    const config = loadConfig(root);
+    const target = options.target ?? (config.targets.length === 1 ? config.targets[0] : undefined);
+    if (target !== undefined && !config.targets.includes(target)) {
+        throw new AppError([
+            { file: "valance.json", line: 0, column: 0, code: "dev-target", message: `this project is not built for ${target} (its targets: ${config.targets.join(", ")})` },
+        ]);
+    }
+    // A project of more than one target, and none named: serve the web and open the desktop's window, each as it would be alone.
+    if (target === undefined) {
+        const web = await dev(root, { ...options, target: "web" });
+        const desktop = await devDesktop(root, options);
+        return {
+            url: web.url,
+            closed: desktop.closed,
+            settled: async () => {
+                await web.settled();
+                await desktop.settled();
+            },
+            close: async () => {
+                await desktop.close();
+                await web.close();
+            },
+        };
+    }
+    if (target === "desktop") {
+        return devDesktop(root, options);
+    }
     let current;
     const log = options.log ??
         ((line) => {
@@ -237,7 +272,7 @@ export const dev = async (root, options = {}) => {
         }, 500);
         timer.unref();
     };
-    const config = loadConfig(root);
+    // (the configuration is read above)
     current = await start(root, config, options, restart);
     return {
         get url() {

package/dist/emit.d.ts

@@ -1,13 +1,16 @@
 import type { Config } from "./config.js";
+import type { TargetId } from "./targets.js";
 import type { DefinedApp } from "@valancex/common";
 import type { Content } from "@valancex/common/internal";
 export declare const hasEntry: (root: string) => boolean;
 export declare const writeContent: (root: string, content: Content) => boolean;
 /** The content stage alone: it does not need the author's code. */
 export declare const generateContent: (root: string, config: Config) => Content;
-/** The templates stage: needs the author's definition (the manifest derives from its state and commands). */
-export declare const generateProgram: (root: string, author: DefinedApp | undefined) => Promise<ReadonlyArray<string>>;
+/** The file a target's compiled program is in: `program.json` for a project of one target (as it always was), `program.<target>.json` for one of several. */
+export declare const programFile: (config: Config | undefined, id: TargetId) => string;
+/** The templates stage: needs the author's definition (the manifest derives from its state and commands). One program per target; the state, the commands and the content are shared. */
+export declare const generateProgram: (root: string, author: DefinedApp | undefined, config?: Config, only?: ReadonlyArray<TargetId>) => Promise<ReadonlyArray<string>>;
 /** The declaration of one template's type: its props and events as the names TypeScript checks a contract's keys against. */
 export declare const templateType: (props: ReadonlyArray<string>, events: ReadonlyArray<string>) => string;
-/** The entries; rewritten when `src/main.ts` or a stylesheet is added or removed. */
-export declare const generateEntries: (root: string) => boolean;
+/** The entries; rewritten when `src/main.ts` or a stylesheet is added or removed. Each target has its own: the web's two (`client.ts`, `server.ts`), the desktop's one (`desktop.ts`). */
+export declare const generateEntries: (root: string, config?: Config) => boolean;

package/dist/emit.js

@@ -17,30 +17,67 @@ import { existsSync, readdirSync, readFileSync, rmSync } from "node:fs";
 import { join, relative, sep } from "node:path";
 import { compileViews, PACKAGE_DIR, SOURCE_DIR } from "./compile.js";
 import { readContent } from "./content.js";
+import { targetOf } from "./targets.js";
+import { forTarget } from "@valancex/common/internal";
+import { AppError } from "./diagnostics.js";
 import { ENTRY_FILE, ensureGeneratedDir, GENERATED_DIR, generated, writeIfChanged } from "./project.js";
 import { buildWiring } from "./wiring.js";
+/** The layout of the portable core on the web: `column` and `row` are custom elements, and this is what they are (`@valancex/common`'s web vocabulary). It comes first, so a project's own styles win. */
+const CORE_CSS = `/* Generated by \`valance\`. The web's realization of the portable core's layout components. */
+vlx-column {
+  display: flex;
+  flex-direction: column;
+  gap: 0.5rem;
+}
+
+vlx-row {
+  display: flex;
+  flex-direction: row;
+  align-items: center;
+  gap: 0.5rem;
+}
+`;
+/** The stylesheets the web loads: every one under `src/` except those in another target's directory (`src/desktop/`). */
 const stylesheets = (root) => existsSync(join(root, SOURCE_DIR))
     ? readdirSync(join(root, SOURCE_DIR), { recursive: true, encoding: "utf8" })
-        .filter((file) => file.endsWith(".css"))
+        .map((file) => file.split(sep).join("/"))
+        .filter((file) => file.endsWith(".css") && !file.startsWith("desktop/"))
         .sort()
         .map((file) => `${SOURCE_DIR}/${file}`)
     : [];
 export const hasEntry = (root) => existsSync(join(root, ENTRY_FILE));
-const clientSource = (root) => `// Generated by \`valance\`. Do not edit: it is rewritten whenever the project changes.
+const clientSource = (root, config) => `// Generated by \`valance\`. Do not edit: it is rewritten whenever the project changes.
 // @ts-nocheck
 import { start } from "@valancex/common/client";
 import content from "./content.json";
-import program from "./program.json";
+import program from "./${programFile(config, "web")}";
+import "./core.css";
 ${hasEntry(root) ? `import author from "../${ENTRY_FILE}";\n` : "const author = undefined;\n"}${stylesheets(root)
     .map((file) => `import "../${file}";\n`)
     .join("")}
 await start({ content, program, author });
 `;
-const serverSource = (root) => `// Generated by \`valance\`. Do not edit: it is rewritten whenever the project changes.
+const desktopSource = (root, config) => `// Generated by \`valance\`. Do not edit: it is rewritten whenever the project changes.
+// @ts-nocheck
+import { start } from "@valancex/common/desktop";
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import content from "./content.json";
+import program from "./${programFile(config, "desktop")}";
+${hasEntry(root) ? `import author from "../${ENTRY_FILE}";\n` : "const author = undefined;\n"}
+// the MESH runtime's module sits beside the built engine (vlx build copies it there)
+const wasm = new Uint8Array(readFileSync(new URL("./mesh-runtime.wasm", import.meta.url)));
+// (and the project's public/ files, which images are drawn from)
+const assets = fileURLToPath(new URL("./public/", import.meta.url));
+await start({ content, program, author, wasm, assets });
+// the window is closed: nothing the application left open keeps the engine alive
+process.exit(0);
+`;
+const serverSource = (root, config) => `// Generated by \`valance\`. Do not edit: it is rewritten whenever the project changes.
 // @ts-nocheck
 import { createRenderer, pathsOf } from "@valancex/common/server";
 import content from "./content.json";
-import program from "./program.json";
+import program from "./${programFile(config, "web")}";
 ${hasEntry(root) ? `import author from "../${ENTRY_FILE}";\n` : "const author = undefined;\n"}
 export const render = createRenderer({ content, program, author });
 export const paths = () => pathsOf(content);
@@ -54,20 +91,50 @@ export const generateContent = (root, config) => {
     writeContent(root, content);
     return content;
 };
-/** The templates stage: needs the author's definition (the manifest derives from its state and commands). */
-export const generateProgram = async (root, author) => {
+/** The file a target's compiled program is in: `program.json` for a project of one target (as it always was), `program.<target>.json` for one of several. */
+export const programFile = (config, id) => ((config?.targets.length ?? 1) > 1 ? `program.${id}.json` : "program.json");
+const manifestFile = (config, id) => ((config?.targets.length ?? 1) > 1 ? `manifest.${id}.json` : "manifest.json");
+const wiringFile = (config, id) => ((config?.targets.length ?? 1) > 1 ? `wiring.${id}.json` : "wiring.json");
+/** The templates stage: needs the author's definition (the manifest derives from its state and commands). One program per target; the state, the commands and the content are shared. */
+export const generateProgram = async (root, author, config, only) => {
     ensureGeneratedDir(root);
-    const compiled = await compileViews(root, author);
-    writeIfChanged(generated(root, "program.json"), `${JSON.stringify(compiled.program)}\n`);
-    writeIfChanged(generated(root, "manifest.json"), `${JSON.stringify(compiled.manifest, null, 2)}\n`);
-    // The one file an editor reads to know the project: where the manifest is, and which file is the template of which component. The conventions stay here, not copied into every editor.
-    writeIfChanged(generated(root, "editor.json"), `${JSON.stringify({ version: 1, model: `${GENERATED_DIR}/manifest.json`, components: compiled.files, wiring: `${GENERATED_DIR}/wiring.json` }, null, 2)}\n`);
-    writeTemplateTypes(root, compiled);
-    // Where every name came from and what uses it, at both ends, for the editor. The framework's own names point into the README that ships with the package.
+    const targets = (config?.targets ?? ["web"]).filter((id) => only === undefined || only.includes(id));
+    const compiledAll = [];
+    const problems = [];
+    for (const id of targets) {
+        const target = targetOf(id);
+        try {
+            compiledAll.push({ id, compiled: await compileViews(root, forTarget(author, id), target.vocabulary, target.views) });
+        }
+        catch (error) {
+            if (!(error instanceof AppError)) {
+                throw error;
+            }
+            problems.push(...error.diagnostics);
+        }
+    }
+    if (problems.length > 0) {
+        throw new AppError(problems);
+    }
     const readme = join(PACKAGE_DIR, "README.md");
     const docs = existsSync(readme) ? { file: relative(root, readme).split(sep).join("/"), lines: readFileSync(readme, "utf8").split("\n") } : undefined;
-    writeIfChanged(generated(root, "wiring.json"), `${JSON.stringify(buildWiring(root, author, compiled, docs), null, 2)}\n`);
-    return compiled.components;
+    const editor = [];
+    for (const { id, compiled } of compiledAll) {
+        writeIfChanged(generated(root, programFile(config, id)), `${JSON.stringify(compiled.program)}\n`);
+        writeIfChanged(generated(root, manifestFile(config, id)), `${JSON.stringify(compiled.manifest, null, 2)}\n`);
+        // Where every name came from and what uses it, at both ends, for the editor. The framework's own names point into the README that ships with the package.
+        writeIfChanged(generated(root, wiringFile(config, id)), `${JSON.stringify(buildWiring(root, forTarget(author, id), compiled, docs), null, 2)}\n`);
+        editor.push({ id, model: `${GENERATED_DIR}/${manifestFile(config, id)}`, wiring: `${GENERATED_DIR}/${wiringFile(config, id)}`, components: compiled.files });
+    }
+    // The one file an editor reads to know the project: where the manifest is, and which file is the template of which component. The conventions stay here, not copied into every editor. For a project
+    // of several targets the first one is what the editor reads (`model`, `wiring`), and `targets` lists each.
+    const first = editor[0];
+    // Only a pass over every target writes it (a pass over one, as `vlx dev --web` is, would leave the others out of it).
+    if (first !== undefined && editor.length === (config?.targets ?? ["web"]).length) {
+        writeIfChanged(generated(root, "editor.json"), `${JSON.stringify({ version: 1, model: first.model, components: first.components, wiring: first.wiring, ...(editor.length > 1 ? { targets: Object.fromEntries(editor.map((each) => [each.id, { model: each.model, wiring: each.wiring, components: each.components }])) } : {}) }, null, 2)}\n`);
+    }
+    writeTemplateTypes(root, compiledAll.map((each) => each.compiled));
+    return [...new Set(compiledAll.flatMap((each) => each.compiled.components))];
 };
 const union = (names) => (names.length === 0 ? "never" : names.map((name) => JSON.stringify(name)).join(" | "));
 /** The declaration of one template's type: its props and events as the names TypeScript checks a contract's keys against. */
@@ -81,15 +148,16 @@ export default template;
  */
 const typePath = (file) => `types/${file.replace(new RegExp(`^${SOURCE_DIR}/`), "").replace(/\.mprx$/, ".d.mprx.ts")}`;
 /** Writes the type of each of the author's templates, and removes the type of one that is gone. */
-const writeTemplateTypes = (root, compiled) => {
-    const components = compiled.manifest
-        .components;
+const writeTemplateTypes = (root, all) => {
     const written = new Set();
-    for (const template of compiled.templates.filter((each) => !each.builtIn)) {
-        const entry = components[template.component];
-        const path = typePath(template.file);
-        written.add(path);
-        writeIfChanged(generated(root, path), templateType(Object.keys(entry?.props ?? {}), Object.keys(entry?.events ?? {})));
+    for (const compiled of all) {
+        const components = compiled.manifest.components;
+        for (const template of compiled.templates.filter((each) => !each.builtIn)) {
+            const entry = components[template.component];
+            const path = typePath(template.file);
+            written.add(path);
+            writeIfChanged(generated(root, path), templateType(Object.keys(entry?.props ?? {}), Object.keys(entry?.events ?? {})));
+        }
     }
     const dir = generated(root, "types");
     if (existsSync(dir)) {
@@ -100,8 +168,18 @@ const writeTemplateTypes = (root, compiled) => {
         }
     }
 };
-/** The entries; rewritten when `src/main.ts` or a stylesheet is added or removed. */
-export const generateEntries = (root) => {
+/** The entries; rewritten when `src/main.ts` or a stylesheet is added or removed. Each target has its own: the web's two (`client.ts`, `server.ts`), the desktop's one (`desktop.ts`). */
+export const generateEntries = (root, config) => {
     ensureGeneratedDir(root);
-    return [writeIfChanged(generated(root, "client.ts"), clientSource(root)), writeIfChanged(generated(root, "server.ts"), serverSource(root))].some(Boolean);
+    const targets = config?.targets ?? ["web"];
+    return [
+        ...(targets.includes("web")
+            ? [
+                writeIfChanged(generated(root, "core.css"), CORE_CSS),
+                writeIfChanged(generated(root, "client.ts"), clientSource(root, config)),
+                writeIfChanged(generated(root, "server.ts"), serverSource(root, config)),
+            ]
+            : []),
+        ...(targets.includes("desktop") ? [writeIfChanged(generated(root, "desktop.ts"), desktopSource(root, config))] : []),
+    ].some(Boolean);
 };

package/dist/init.js

@@ -4,7 +4,7 @@ import { spawn } from "node:child_process";
 import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
 import { basename, dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
-import { PROJECT_FILE, WEB_FILE } from "./config.js";
+import { DESKTOP_FILE, PROJECT_FILE, WEB_FILE } from "./config.js";
 export const PACKAGE_MANAGERS = ["npm", "pnpm", "yarn", "bun"];
 const PACKAGE = new URL("../", import.meta.url);
 const TEMPLATES = new URL("../templates/", import.meta.url);
@@ -84,6 +84,7 @@ export const plan = (answers) => {
     const out = new Map();
     const title = titleOf(answers.name);
     const web = answers.targets.includes("web");
+    const desktop = answers.targets.includes("desktop");
     const hasBase = answers.web.base !== "" && answers.web.base !== "/";
     const settings = [hasBase ? `base ${answers.web.base}` : "", answers.web.url !== "" ? `url ${answers.web.url}` : ""].filter((each) => each !== "");
     const tokens = {
@@ -92,14 +93,20 @@ export const plan = (answers) => {
         web_note: web && settings.length > 0 ? `, and \`${WEB_FILE}\` says where the web site is served (${settings.join(", ")})` : "",
     };
     const fill = (text) => text.replace(/\{\{(\w+)\}\}/g, (match, key) => tokens[key] ?? match);
-    if (web) {
-        const root = new URL("web/", TEMPLATES);
+    // A project for more than one target keeps what they share (the content, the state and the commands) and gives each its own templates (`src/web/`, `src/desktop/`): the "multi" template, on
+    // top of the web's files that are not templates.
+    const layers = web && desktop ? ["web", "multi"] : web ? ["web"] : desktop ? ["desktop"] : [];
+    for (const target of layers) {
+        const root = new URL(`${target}/`, TEMPLATES);
         for (const file of files(root)) {
+            if (target === "web" && layers.includes("multi") && (file.startsWith("src/") || file.startsWith("content/") || file === "README.md")) {
+                continue;
+            }
             out.set(written(file), fill(readFileSync(new URL(file, root), "utf8")));
         }
     }
     out.set(PROJECT_FILE, json({ $schema: "./node_modules/@valancex/cli/schemas/valance.schema.json", version: 1, name: title }));
-    if (web && (hasBase || answers.web.url !== "")) {
+    if (web && (hasBase || answers.web.url !== "" || desktop)) {
         out.set(WEB_FILE, json({
             $schema: "./node_modules/@valancex/cli/schemas/valance.web.schema.json",
             version: 1,
@@ -107,6 +114,9 @@ export const plan = (answers) => {
             ...(answers.web.url !== "" ? { url: answers.web.url } : {}),
         }));
     }
+    if (desktop) {
+        out.set(DESKTOP_FILE, json({ $schema: "./node_modules/@valancex/cli/schemas/valance.desktop.schema.json", version: 1 }));
+    }
     out.set("package.json", json({
         name: packageName(basename(answers.dir)),
         version: "0.0.0",

package/dist/markdown.js

@@ -5,7 +5,8 @@ export const slug = (text) => text
     .replace(/[̀-ͯ]/g, "")
     .replace(/[^a-z0-9]+/g, "-")
     .replace(/^-+|-+$/g, "");
-const MARKS = /\*\*([^*]+)\*\*|`([^`]+)`|!\[[^\]]*\]\([^)\s]*\)|\[([^\]]+)\]\(([^)\s]+)\)|\*([^*\s][^*]*)\*|(?<![\w])_([^_\s][^_]*)_(?![\w])/g;
+// A link's address may hold one level of balanced parentheses (`/a_(b)`, `javascript:alert(1)`), so it is read whole: a check that names it quotes all of it.
+const MARKS = /\*\*([^*]+)\*\*|`([^`]+)`|!\[[^\]]*\]\((?:[^()\s]|\([^()\s]*\))*\)|\[([^\]]+)\]\(((?:[^()\s]|\([^()\s]*\))+)\)|\*([^*\s][^*]*)\*|(?<![\w])_([^_\s][^_]*)_(?![\w])/g;
 const empty = { level: 0, anchor: "", spans: [], items: [], ordered: false, lang: "", text: "", src: "", alt: "" };
 export const plain = (spans) => spans.map((span) => span.text).join("");
 /**

package/dist/package.d.ts

@@ -0,0 +1,18 @@
+export declare const PLATFORMS: readonly ["linux-x64", "win32-x64"];
+export type Platform = (typeof PLATFORMS)[number];
+export interface PackageOptions {
+    /** The platform the package is for; by default the one this runs on. */
+    readonly platform?: string;
+    /** The Desktop PORT's window program for that platform (`vlx-window`); by default `VLX_WINDOW`, else `vlx-window` on the PATH. */
+    readonly window?: string;
+    /** A `node` binary of the same version for that platform; by default the one running this, which is only right for the platform this runs on. */
+    readonly node?: string;
+    /** Also write the package as one file: a `.tar.gz` for Linux, a `.zip` for Windows, with its SHA-256 beside it. */
+    readonly archive?: boolean;
+}
+export interface Packaged {
+    readonly dir: string;
+    readonly files: ReadonlyArray<string>;
+    readonly notes: ReadonlyArray<string>;
+}
+export declare const packageDesktop: (root: string, options?: PackageOptions) => Promise<Packaged>;