@pwfabric/cli 0.0.0-stage → 1.0.0-rc.0

package/dist/commands/registry.js

@@ -0,0 +1,16 @@
+import { create } from './create.js';
+import { devCommand } from './dev.js';
+import { buildCommand } from './build.js';
+import { validate } from './validate.js';
+import { pack } from './pack.js';
+import { add } from './add.js';
+import { run } from './run.js';
+/**
+ * Every `pwf` command. Lanes add their command module here and nowhere else.
+ * Order is the order `pwf help` prints.
+ */
+export const COMMANDS = [create, devCommand, buildCommand, validate, pack, add, run];
+export function findCommand(name) {
+    return COMMANDS.find((c) => c.name === name);
+}
+//# sourceMappingURL=registry.js.map

package/dist/commands/registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.js","sourceRoot":"","sources":["../../src/commands/registry.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AACpC,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AACrC,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AACzC,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AACxC,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAA;AAChC,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAA;AAC9B,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAA;AAE9B;;;GAGG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAc,CAAC,MAAM,EAAE,UAAU,EAAE,YAAY,EAAE,QAAQ,EAAE,IAAI,EAAE,GAAG,EAAE,GAAG,CAAC,CAAA;AAE/F,MAAM,UAAU,WAAW,CAAC,IAAY;IACtC,OAAO,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,IAAI,CAAC,CAAA;AAC9C,CAAC"}

package/dist/commands/run.d.ts

@@ -0,0 +1,15 @@
+import type { Command, CommandIO, ParsedArgs } from './types.js';
+import { type StaticServer, type StaticSource } from './lib/static-server.js';
+export declare const DEFAULT_RUN_PORT = 4700;
+/** Resolves when the process is asked to stop (Ctrl-C or SIGTERM). */
+export declare function untilSignal(): Promise<void>;
+export declare function parsePort(value: string | undefined): number;
+/** The source to serve: a folder with an `index.html`, or a `.pwapp` archive opened in memory. */
+export declare function openRunSource(path: string): Promise<StaticSource>;
+export interface RunOptions {
+    /** Resolves when the server should stop. Default: SIGINT or SIGTERM. */
+    readonly until?: (server: StaticServer) => Promise<void>;
+}
+export declare function runRun(args: ParsedArgs, io: CommandIO, options?: RunOptions): Promise<number>;
+export declare const run: Command;
+//# sourceMappingURL=run.d.ts.map

package/dist/commands/run.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../../src/commands/run.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AAGhE,OAAO,EAAqB,KAAK,YAAY,EAAE,KAAK,YAAY,EAAE,MAAM,wBAAwB,CAAA;AAEhG,eAAO,MAAM,gBAAgB,OAAO,CAAA;AAEpC,sEAAsE;AACtE,wBAAgB,WAAW,IAAI,OAAO,CAAC,IAAI,CAAC,CAU3C;AAED,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,CAK3D;AAED,kGAAkG;AAClG,wBAAsB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,CAWvE;AAED,MAAM,WAAW,UAAU;IACzB,wEAAwE;IACxE,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC,MAAM,EAAE,YAAY,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;CACzD;AAED,wBAAsB,MAAM,CAAC,IAAI,EAAE,UAAU,EAAE,EAAE,EAAE,SAAS,EAAE,OAAO,GAAE,UAAe,GAAG,OAAO,CAAC,MAAM,CAAC,CAevG;AAED,eAAO,MAAM,GAAG,EAAE,OAajB,CAAA"}

package/dist/commands/run.js

@@ -0,0 +1,79 @@
+/**
+ * `pwf run <dir|file.pwapp>` — serve a built pwapp locally.
+ */
+import { readFile, stat } from 'node:fs/promises';
+import { join } from 'node:path';
+import { readPwpack } from '@pwfabric/pack';
+import { guard, stringFlag, UsageError } from './lib/flags.js';
+import { resolveFrom } from './lib/project.js';
+import { startStaticServer } from './lib/static-server.js';
+export const DEFAULT_RUN_PORT = 4700;
+/** Resolves when the process is asked to stop (Ctrl-C or SIGTERM). */
+export function untilSignal() {
+    return new Promise((done) => {
+        const stop = () => {
+            process.off('SIGINT', stop);
+            process.off('SIGTERM', stop);
+            done();
+        };
+        process.on('SIGINT', stop);
+        process.on('SIGTERM', stop);
+    });
+}
+export function parsePort(value) {
+    if (value === undefined)
+        return DEFAULT_RUN_PORT;
+    const port = Number(value);
+    if (!/^\d+$/.test(value) || port > 65535)
+        throw new UsageError(`--port "${value}" is not a port number`);
+    return port;
+}
+/** The source to serve: a folder with an `index.html`, or a `.pwapp` archive opened in memory. */
+export async function openRunSource(path) {
+    const st = await stat(path).catch(() => null);
+    if (!st)
+        throw new Error(`no such file or folder: ${path}`);
+    if (st.isDirectory()) {
+        const index = await stat(join(path, 'index.html')).catch(() => null);
+        if (!index?.isFile())
+            throw new Error(`${path} has no index.html; build the app first (pwf build)`);
+        return { dir: path };
+    }
+    const { files } = await readPwpack(new Uint8Array(await readFile(path)));
+    if (!files.has('index.html'))
+        throw new Error(`${path} has no index.html at its root; it is not a built pwapp`);
+    return { files };
+}
+export async function runRun(args, io, options = {}) {
+    const target = args.positionals[0];
+    if (target === undefined)
+        throw new UsageError('missing <dir|file.pwapp>');
+    const port = parsePort(stringFlag(args, 'port'));
+    const hostname = stringFlag(args, 'host') ?? '127.0.0.1';
+    const source = await openRunSource(resolveFrom(io.cwd, target));
+    const server = await startStaticServer({ source, port, hostname });
+    io.out(`Serving ${target} at ${server.url}`);
+    io.out('Press Ctrl-C to stop.');
+    try {
+        await (options.until ?? untilSignal)(server);
+    }
+    finally {
+        await server.close();
+    }
+    return 0;
+}
+export const run = {
+    name: 'run',
+    summary: 'Serve a built pwapp (folder or .pwapp) on a local port',
+    usage: `pwf run <dir|file.pwapp> [--port <n>] [--host <name>]
+
+  <dir>          a built pwapp folder with an index.html (see pwf build)
+  <file.pwapp>   a packaged pwapp (gzipped tar, read like a .pwpack), served from memory
+  --port <n>     port to listen on (default ${DEFAULT_RUN_PORT}; 0 picks a free one)
+  --host <name>  interface to bind (default 127.0.0.1)
+
+Page paths without a file extension are answered with index.html, so
+path-routed apps work; a missing asset is a 404.`,
+    run: (args, io) => guard('run', io, () => runRun(args, io)),
+};
+//# sourceMappingURL=run.js.map

package/dist/commands/run.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"run.js","sourceRoot":"","sources":["../../src/commands/run.ts"],"names":[],"mappings":"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"}

package/dist/commands/types.d.ts

@@ -0,0 +1,35 @@
+/**
+ * The contract every `pwf` command implements.
+ *
+ * A command is a plain object registered in ./registry.ts. It never calls
+ * `process.exit` and never writes to `process.stdout` directly: it writes
+ * through the `io` it is given and returns an exit code. That keeps every
+ * command testable in-process.
+ */
+export interface CommandIO {
+    /** Working directory the command runs in (absolute). */
+    readonly cwd: string;
+    /** Normal output. */
+    out(line: string): void;
+    /** Diagnostics and errors. */
+    err(line: string): void;
+    /** Environment variables visible to the command. */
+    readonly env: Readonly<Record<string, string | undefined>>;
+}
+export interface ParsedArgs {
+    /** Positional arguments after the command name. */
+    readonly positionals: readonly string[];
+    /** `--flag value` and `--flag=value` become strings; bare `--flag` becomes true. */
+    readonly flags: Readonly<Record<string, string | boolean>>;
+}
+export interface Command {
+    /** The word after `pwf`, e.g. `create`. */
+    readonly name: string;
+    /** One line shown by `pwf help`. */
+    readonly summary: string;
+    /** Usage line, e.g. `pwf create <name> [--dir <path>]`. */
+    readonly usage: string;
+    /** Runs the command. Resolves to the process exit code (0 = success). */
+    run(args: ParsedArgs, io: CommandIO): Promise<number>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/commands/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/commands/types.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,MAAM,WAAW,SAAS;IACxB,wDAAwD;IACxD,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,qBAAqB;IACrB,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAA;IACvB,8BAA8B;IAC9B,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAA;IACvB,oDAAoD;IACpD,QAAQ,CAAC,GAAG,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC,CAAA;CAC3D;AAED,MAAM,WAAW,UAAU;IACzB,mDAAmD;IACnD,QAAQ,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,CAAA;IACvC,oFAAoF;IACpF,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,CAAA;CAC3D;AAED,MAAM,WAAW,OAAO;IACtB,2CAA2C;IAC3C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,oCAAoC;IACpC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,2DAA2D;IAC3D,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,yEAAyE;IACzE,GAAG,CAAC,IAAI,EAAE,UAAU,EAAE,EAAE,EAAE,SAAS,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;CACtD"}

package/dist/commands/types.js

@@ -0,0 +1,10 @@
+/**
+ * The contract every `pwf` command implements.
+ *
+ * A command is a plain object registered in ./registry.ts. It never calls
+ * `process.exit` and never writes to `process.stdout` directly: it writes
+ * through the `io` it is given and returns an exit code. That keeps every
+ * command testable in-process.
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/commands/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/commands/types.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG"}

package/dist/commands/validate.d.ts

@@ -0,0 +1,7 @@
+/**
+ * `pwf validate [dir]` — checks a pwpack folder and its pinned packs.
+ */
+import type { Command, CommandIO, ParsedArgs } from './types.js';
+export declare function runValidate(args: ParsedArgs, io: CommandIO): Promise<number>;
+export declare const validate: Command;
+//# sourceMappingURL=validate.d.ts.map

package/dist/commands/validate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../../src/commands/validate.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AAKhE,wBAAsB,WAAW,CAAC,IAAI,EAAE,UAAU,EAAE,EAAE,EAAE,SAAS,GAAG,OAAO,CAAC,MAAM,CAAC,CAalF;AAED,eAAO,MAAM,QAAQ,EAAE,OAYtB,CAAA"}

package/dist/commands/validate.js

@@ -0,0 +1,33 @@
+import { boolFlag, guard } from './lib/flags.js';
+import { readProject, resolveFrom } from './lib/project.js';
+import { countLine, printIssues, validateProject } from './lib/report.js';
+export async function runValidate(args, io) {
+    const root = resolveFrom(io.cwd, args.positionals[0]);
+    const result = await validateProject(root, await readProject(root));
+    if (boolFlag(args, 'json')) {
+        io.out(JSON.stringify(result, null, 2));
+        return result.ok ? 0 : 1;
+    }
+    const who = result.identity ? `${result.identity.id}@${result.identity.version}` : root;
+    printIssues(io, result.issues);
+    const summary = `${who}: ${result.ok ? 'valid' : 'invalid'} (${countLine(result.issues)}; layout ${result.layout}; ${result.atoms.length} atoms)`;
+    if (result.ok)
+        io.out(summary);
+    else
+        io.err(summary);
+    return result.ok ? 0 : 1;
+}
+export const validate = {
+    name: 'validate',
+    summary: 'Check a pwpack folder and the packs it pins',
+    usage: `pwf validate [dir] [--json]
+
+  dir      the pwpack folder (default: the current folder)
+  --json   print the raw result (ok, issues, identity, layout, atoms)
+
+Every packs[] pin is looked up in .pwf/packs/<id>@<version>/: a build that is
+not there is a warning, one whose content hash differs from the pin is an
+error. Exit code 1 when there is any error, 0 otherwise.`,
+    run: (args, io) => guard('validate', io, () => runValidate(args, io)),
+};
+//# sourceMappingURL=validate.js.map

package/dist/commands/validate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.js","sourceRoot":"","sources":["../../src/commands/validate.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAA;AAChD,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAC3D,OAAO,EAAE,SAAS,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAA;AAEzE,MAAM,CAAC,KAAK,UAAU,WAAW,CAAC,IAAgB,EAAE,EAAa;IAC/D,MAAM,IAAI,GAAG,WAAW,CAAC,EAAE,CAAC,GAAG,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAA;IACrD,MAAM,MAAM,GAAG,MAAM,eAAe,CAAC,IAAI,EAAE,MAAM,WAAW,CAAC,IAAI,CAAC,CAAC,CAAA;IACnE,IAAI,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,EAAE,CAAC;QAC3B,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,CAAA;QACvC,OAAO,MAAM,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;IAC1B,CAAC;IACD,MAAM,GAAG,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,QAAQ,CAAC,EAAE,IAAI,MAAM,CAAC,QAAQ,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,IAAI,CAAA;IACvF,WAAW,CAAC,EAAE,EAAE,MAAM,CAAC,MAAM,CAAC,CAAA;IAC9B,MAAM,OAAO,GAAG,GAAG,GAAG,KAAK,MAAM,CAAC,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,SAAS,KAAK,SAAS,CAAC,MAAM,CAAC,MAAM,CAAC,YAAY,MAAM,CAAC,MAAM,KAAK,MAAM,CAAC,KAAK,CAAC,MAAM,SAAS,CAAA;IACjJ,IAAI,MAAM,CAAC,EAAE;QAAE,EAAE,CAAC,GAAG,CAAC,OAAO,CAAC,CAAA;;QACzB,EAAE,CAAC,GAAG,CAAC,OAAO,CAAC,CAAA;IACpB,OAAO,MAAM,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;AAC1B,CAAC;AAED,MAAM,CAAC,MAAM,QAAQ,GAAY;IAC/B,IAAI,EAAE,UAAU;IAChB,OAAO,EAAE,6CAA6C;IACtD,KAAK,EAAE;;;;;;;yDAOgD;IACvD,GAAG,EAAE,CAAC,IAAI,EAAE,EAAE,EAAE,EAAE,CAAC,KAAK,CAAC,UAAU,EAAE,EAAE,EAAE,GAAG,EAAE,CAAC,WAAW,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;CACtE,CAAA"}

package/dist/dev/assemble.d.ts

@@ -0,0 +1,48 @@
+import { type CompileCache, type CompiledAtom } from './compile.js';
+import { type AssembleDiagnostic } from './diagnostics.js';
+import { type RuntimeAssets } from './shell.js';
+import { type PackMemo } from './sources.js';
+export interface AssembleOptions {
+    /** Markup appended to the shell's `<body>` — the dev server's reload client. Absent in a build. */
+    readonly shellExtra?: string;
+    /** Envelope files a local host adds (see `LocalHost.envelopeEntries`). */
+    readonly envelopeEntries?: Readonly<Record<string, unknown>>;
+    /** A compile cache to reuse across builds; default: one on disk under `.pwf/build-cache/`. */
+    readonly cache?: CompileCache;
+    /** Folder of the on-disk compile cache; `null` keeps it in memory only. */
+    readonly cacheDir?: string | null;
+    /** `publish.json`'s `publishedAt`; default now. */
+    readonly publishedAt?: string;
+    /** Runner and renderer bundles; default: the installed engine packages. */
+    readonly runtime?: RuntimeAssets;
+    /** Pack builds read by an earlier build of the same session. */
+    readonly packMemo?: PackMemo;
+}
+export interface AssembleStats {
+    readonly pages: number;
+    /** Entries in `blocks/manifest.json`. */
+    readonly blocks: number;
+    /** Entries in `engines/manifest.json`. */
+    readonly engines: number;
+    /** Atoms of a compiled kind across the app and its packs. */
+    readonly atoms: number;
+    /** Of those, how many have a module (compiled or shipped precompiled). */
+    readonly compiled: number;
+    /** Of the compiled, how many came from the cache. */
+    readonly fromCache: number;
+    readonly failed: number;
+}
+export interface AssembleResult {
+    /** No diagnostic is an error. */
+    readonly ok: boolean;
+    /** The served folder: POSIX path → bytes. Filled as far as the build got, even when not `ok`. */
+    readonly files: Map<string, Uint8Array>;
+    readonly diagnostics: readonly AssembleDiagnostic[];
+    readonly stats: AssembleStats;
+    readonly ms: number;
+}
+/** Every name a block atom answers to in a receipt: its id, its manifest name, and its short forms. */
+export declare function blockNames(atom: Pick<CompiledAtom, 'id' | 'manifest'>): string[];
+/** Assembles the pwapp for the app folder at `root`. */
+export declare function assemblePwapp(root: string, options?: AssembleOptions): Promise<AssembleResult>;
+//# sourceMappingURL=assemble.d.ts.map

package/dist/dev/assemble.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assemble.d.ts","sourceRoot":"","sources":["../../src/dev/assemble.ts"],"names":[],"mappings":"AAgBA,OAAO,EAAsC,KAAK,YAAY,EAAE,KAAK,YAAY,EAAE,MAAM,cAAc,CAAA;AACvG,OAAO,EAA8B,KAAK,kBAAkB,EAAE,MAAM,kBAAkB,CAAA;AAetF,OAAO,EAQL,KAAK,aAAa,EACnB,MAAM,YAAY,CAAA;AACnB,OAAO,EAA0C,KAAK,QAAQ,EAAmB,MAAM,cAAc,CAAA;AAWrG,MAAM,WAAW,eAAe;IAC9B,mGAAmG;IACnG,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAA;IAC5B,0EAA0E;IAC1E,QAAQ,CAAC,eAAe,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;IAC5D,8FAA8F;IAC9F,QAAQ,CAAC,KAAK,CAAC,EAAE,YAAY,CAAA;IAC7B,2EAA2E;IAC3E,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACjC,mDAAmD;IACnD,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAA;IAC7B,2EAA2E;IAC3E,QAAQ,CAAC,OAAO,CAAC,EAAE,aAAa,CAAA;IAChC,gEAAgE;IAChE,QAAQ,CAAC,QAAQ,CAAC,EAAE,QAAQ,CAAA;CAC7B;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,yCAAyC;IACzC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,0CAA0C;IAC1C,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,6DAA6D;IAC7D,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,0EAA0E;IAC1E,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,qDAAqD;IACrD,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CACxB;AAED,MAAM,WAAW,cAAc;IAC7B,iCAAiC;IACjC,QAAQ,CAAC,EAAE,EAAE,OAAO,CAAA;IACpB,iGAAiG;IACjG,QAAQ,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAAA;IACvC,QAAQ,CAAC,WAAW,EAAE,SAAS,kBAAkB,EAAE,CAAA;IACnD,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAA;IAC7B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;CACpB;AAMD,uGAAuG;AACvG,wBAAgB,UAAU,CAAC,IAAI,EAAE,IAAI,CAAC,YAAY,EAAE,IAAI,GAAG,UAAU,CAAC,GAAG,MAAM,EAAE,CAQhF;AAkBD,wDAAwD;AACxD,wBAAsB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE,eAAoB,GAAG,OAAO,CAAC,cAAc,CAAC,CA6RxG"}

package/dist/dev/assemble.js

@@ -0,0 +1,339 @@
+/**
+ * assemblePwapp — a pwpack app folder in, a static pwapp out.
+ *
+ * Reads the app and the pack builds it pins (from the project's cache),
+ * compiles every block, capability and engine atom with the engine's
+ * compiler, resolves the app's theme, builds the envelope the runner reads,
+ * and lays out the served folder of the pwapp format: shell, runner,
+ * renderer, shims, block and engine modules, envelope and `publish.json`.
+ *
+ * Pure in its output: the same folder, cache and runtime bundles give the
+ * same files (only `publish.json`'s `publishedAt` carries a clock, and it can
+ * be pinned). Nothing is fetched; every input is on disk.
+ */
+import { join } from 'node:path';
+import { hashPack } from '@pwfabric/pack';
+import { atomKindMeta } from '@pwfabric/contracts';
+import { compileSources, createCompileCache } from './compile.js';
+import { hasErrors, sortDiagnostics } from './diagnostics.js';
+import { blockTypesOf, buildConnections, buildProjectJson, deriveNavigation, mergeEnvelopeEntries, moduleFileName, publisherOf, } from './envelope.js';
+import { collectMedia, fillMediaSlots } from './media.js';
+import { deriveCsp, headersFile } from './csp.js';
+import { bootScript, buildShellHtml, importMapText, loadRuntimeAssets, runnerLocaleOf, seedScript, shimsFor, } from './shell.js';
+import { isRecord, jsonOf, loadSources, PWF_DIR } from './sources.js';
+import { appearanceConfigOf, buildThemeCss, resolveAppearance, themeAtomOf, themeWebfonts, webfontStylesheetHref, } from './theme.js';
+const enc = new TextEncoder();
+const json = (value) => enc.encode(JSON.stringify(value, null, 2));
+const hexOf = (hash) => hash.replace(/^sha256:/, '');
+/** Every name a block atom answers to in a receipt: its id, its manifest name, and its short forms. */
+export function blockNames(atom) {
+    const names = new Set([atom.id]);
+    const name = atom.manifest?.['name'];
+    if (typeof name === 'string' && name)
+        names.add(name);
+    const dot = atom.id.indexOf('.');
+    if (dot >= 0)
+        names.add(atom.id.slice(dot + 1));
+    names.add(atom.id.slice(atom.id.lastIndexOf('.') + 1));
+    return [...names];
+}
+function titleOf(plan, id) {
+    if (isRecord(plan) && typeof plan['title'] === 'string' && plan['title'].trim())
+        return plan['title'].trim();
+    const last = id.split('/').pop() ?? id;
+    return last
+        .split(/[-_]+/)
+        .filter(Boolean)
+        .map((w) => w[0].toUpperCase() + w.slice(1))
+        .join(' ');
+}
+function atomLabel(atom) {
+    return atom.source.origin === 'app' ? atom.id : `${atom.id} (${atom.source.id}@${atom.source.version})`;
+}
+const EMPTY_STATS = { pages: 0, blocks: 0, engines: 0, atoms: 0, compiled: 0, fromCache: 0, failed: 0 };
+/** Assembles the pwapp for the app folder at `root`. */
+export async function assemblePwapp(root, options = {}) {
+    const started = performance.now();
+    const diagnostics = [];
+    const files = new Map();
+    const done = (stats) => {
+        const sorted = sortDiagnostics(diagnostics);
+        return { ok: !hasErrors(sorted), files, diagnostics: sorted, stats, ms: Math.round(performance.now() - started) };
+    };
+    const sources = await loadSources(root, options.packMemo);
+    diagnostics.push(...sources.diagnostics);
+    const { app, identity } = sources;
+    if (!app || !identity)
+        return done(EMPTY_STATS);
+    if (!identity.app) {
+        diagnostics.push({
+            severity: 'error',
+            code: 'NOT_AN_APP',
+            message: 'pwpack.json declares no "app" member, so this folder is a pack, not an app — there is nothing to run',
+            path: 'pwpack.json',
+        });
+        return done(EMPTY_STATS);
+    }
+    // ── pages ────────────────────────────────────────────────────────
+    const reported = new Set(diagnostics.map((d) => d.path));
+    const pages = [];
+    for (const key of identity.app.surfaceOrder) {
+        const path = `app/surfaces/${key}.receipt.json`;
+        const bytes = app.folder.files.get(path);
+        const value = jsonOf(app.folder, path);
+        if (!bytes) {
+            if (!reported.has(path)) {
+                diagnostics.push({ severity: 'error', code: 'RECEIPT_MISSING', message: `page "${key}" is in app.surfaceOrder but ${path} does not exist`, path });
+            }
+            continue;
+        }
+        if (value instanceof Error || !isRecord(value) || !Array.isArray(value['blocks'])) {
+            diagnostics.push({
+                severity: 'error',
+                code: 'RECEIPT_INVALID',
+                message: value instanceof Error ? `not JSON: ${value.message}` : 'a receipt is an object with a "blocks" array',
+                path,
+            });
+            continue;
+        }
+        pages.push({ key, path, bytes, receipt: value });
+    }
+    const entry = identity.app.entry;
+    if (!identity.app.surfaceOrder.includes(entry)) {
+        diagnostics.push({ severity: 'error', code: 'ENTRY_NOT_A_PAGE', message: `app.entry "${entry}" is not in app.surfaceOrder`, path: 'pwpack.json' });
+    }
+    // ── definitions ──────────────────────────────────────────────────
+    const definition = (name) => {
+        const path = `app/definitions/${name}.json`;
+        const value = jsonOf(app.folder, path);
+        if (value instanceof Error) {
+            diagnostics.push({ severity: 'error', code: 'DEFINITION_INVALID', message: `not JSON: ${value.message}`, path });
+            return undefined;
+        }
+        return value;
+    };
+    const navigationDoc = definition('navigation');
+    const appearanceDoc = definition('appearance');
+    const connectionsDoc = definition('connections');
+    const authDoc = definition('auth');
+    const plan = jsonOf(app.folder, 'app/plan.json');
+    // ── compile ──────────────────────────────────────────────────────
+    const all = [app, ...sources.packs];
+    const cache = options.cache ?? createCompileCache(options.cacheDir === undefined ? join(root, PWF_DIR, 'build-cache') : options.cacheDir);
+    const atoms = await compileSources(all, cache);
+    // ── themes ───────────────────────────────────────────────────────
+    const themes = [];
+    for (const source of all) {
+        for (const ref of source.validation.atoms) {
+            if (ref.kind !== 'ui-appearance')
+                continue;
+            const theme = themeAtomOf(ref.id, jsonOf(source.folder, ref.relPath), source.label || source.id);
+            if (theme)
+                themes.push(theme);
+        }
+    }
+    const appearance = resolveAppearance(appearanceDoc, themes, diagnostics);
+    // ── blocks ───────────────────────────────────────────────────────
+    const byName = new Map();
+    for (const atom of atoms) {
+        if (atom.kind !== 'block')
+            continue;
+        for (const name of blockNames(atom)) {
+            const list = byName.get(name) ?? [];
+            if (!list.includes(atom))
+                list.push(atom);
+            byName.set(name, list);
+        }
+    }
+    const used = new Set();
+    const blockManifest = [];
+    const modules = new Map();
+    const firstUse = new Map();
+    for (const page of pages)
+        for (const t of blockTypesOf(page.receipt))
+            if (!firstUse.has(t))
+                firstUse.set(t, page);
+    for (const [type, page] of [...firstUse].sort((a, b) => (a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0))) {
+        const candidates = byName.get(type) ?? [];
+        const atom = candidates[0];
+        if (!atom) {
+            diagnostics.push({
+                severity: 'error',
+                code: 'UNKNOWN_BLOCK_TYPE',
+                message: `page "${page.key}" places a block of type "${type}", which neither the app nor its pinned packs define`,
+                path: page.path,
+            });
+            continue;
+        }
+        used.add(atom);
+        if (candidates.length > 1) {
+            diagnostics.push({
+                severity: 'info',
+                code: 'BLOCK_TYPE_SHADOWED',
+                message: `block type "${type}" resolves to ${atomLabel(atom)}; also defined by ${candidates.slice(1).map(atomLabel).join(', ')}`,
+                path: page.path,
+            });
+        }
+        if (!atom.code || !atom.hash) {
+            diagnostics.push({
+                severity: 'error',
+                code: 'BLOCK_NOT_COMPILED',
+                message: `block type "${type}" (${atomLabel(atom)}) did not compile (see the compile errors reported for ${atom.relPath})`,
+                path: page.path,
+            });
+            continue;
+        }
+        const file = `blocks/${moduleFileName(type, hexOf(atom.hash))}`;
+        modules.set(file, enc.encode(atom.code));
+        blockManifest.push({
+            blockType: type,
+            moduleUrl: file,
+            integrity: hexOf(atom.hash),
+            publisher: publisherOf(atom.source.id),
+            publisherVerified: false,
+            definition: { name: type },
+        });
+    }
+    // ── engines ──────────────────────────────────────────────────────
+    const connections = buildConnections(connectionsDoc, diagnostics);
+    const engineManifest = [];
+    for (const conn of connections?.connections ?? []) {
+        const name = conn['name'];
+        const wanted = typeof conn['connector'] === 'string' ? conn['connector'] : name;
+        const atom = atoms.find((a) => (a.kind === 'connector' || a.kind === 'provider') && a.manifest?.['connection'] === wanted);
+        if (!atom)
+            continue;
+        used.add(atom);
+        const kind = atom.kind;
+        if (atom.code && atom.hash) {
+            const file = `engines/${moduleFileName(atom.id, hexOf(atom.hash))}`;
+            modules.set(file, enc.encode(atom.code));
+            engineManifest.push({ connection: name, atomId: atom.id, kind, moduleUrl: file, integrity: hexOf(atom.hash) });
+        }
+        else if (atom.manifest?.['engine'] !== undefined) {
+            engineManifest.push({ connection: name, atomId: atom.id, kind, engine: atom.manifest['engine'] });
+        }
+        else if (atom.status === 'failed') {
+            diagnostics.push({
+                severity: 'warning',
+                code: 'ENGINE_NOT_COMPILED',
+                message: `connection "${name}": engine ${atomLabel(atom)} did not compile, so its panels fall back to sample data`,
+                path: 'app/definitions/connections.json',
+            });
+        }
+    }
+    // ── atom diagnostics ─────────────────────────────────────────────
+    // The app's own atoms and the atoms it uses speak at full volume; an unused
+    // atom of a pinned pack cannot break this app, so its errors are warnings.
+    for (const atom of atoms) {
+        const loud = atom.source.origin === 'app' || used.has(atom);
+        for (const d of atom.diagnostics) {
+            const engineDegrades = atomKindMeta(atom.kind).onFailure === 'degrade';
+            diagnostics.push(loud && !engineDegrades ? d : d.severity === 'error' ? { ...d, severity: 'warning' } : d);
+        }
+    }
+    // ── the served folder ────────────────────────────────────────────
+    const runtime = options.runtime ?? (await loadRuntimeAssets());
+    const config = appearanceConfigOf(appearance);
+    const title = titleOf(plan, identity.id);
+    const locale = isRecord(plan) && typeof plan['locale'] === 'string' ? plan['locale'] : undefined;
+    const shell = (csp) => enc.encode(buildShellHtml({
+        title,
+        ...(locale !== undefined ? { lang: locale } : {}),
+        ...(config ? { appearance: config } : {}),
+        ...(options.shellExtra !== undefined ? { bodyExtra: options.shellExtra } : {}),
+        ...(csp !== undefined ? { csp } : {}),
+    }));
+    // Written again with its policy once everything the policy reads is known.
+    files.set('index.html', shell());
+    files.set('assets/seed.js', enc.encode(seedScript()));
+    files.set('assets/boot.js', enc.encode(bootScript(runnerLocaleOf(locale))));
+    files.set('assets/runner.js', enc.encode(runtime.runnerJs));
+    if (runtime.runnerMap !== undefined)
+        files.set('assets/runner.js.map', enc.encode(runtime.runnerMap));
+    files.set('assets/embed.js', enc.encode(runtime.embedJs));
+    files.set('assets/theme.css', enc.encode(buildThemeCss(config)));
+    for (const [name, source] of await shimsFor(runtime.embedJs))
+        files.set(`shims/${name}`, enc.encode(source));
+    for (const [file, bytes] of [...modules].sort((a, b) => (a[0] < b[0] ? -1 : 1)))
+        files.set(file, bytes);
+    files.set('blocks/manifest.json', json(blockManifest));
+    files.set('engines/manifest.json', json(engineManifest));
+    files.set('pwpack/project.json', json(buildProjectJson({ id: identity.id, title, entry, pages, auth: authDoc })));
+    for (const page of pages)
+        files.set(`pwpack/surfaces/${page.key}.receipt.json`, page.bytes);
+    files.set('pwpack/navigation.json', json(isRecord(navigationDoc) ? navigationDoc : deriveNavigation(pages, entry)));
+    if (appearance)
+        files.set('pwpack/appearance.json', json(appearance));
+    // Always written: the runner asks for it on every boot, and an app that
+    // declares no connection should not cost the visitor a 404 in the console.
+    files.set('pwpack/connections.json', json(connections ?? { connections: [] }));
+    const media = collectMedia(app.folder, diagnostics);
+    for (const [file, bytes] of media.files)
+        files.set(`pwpack/${file}`, bytes);
+    mergeEnvelopeEntries(files, options.envelopeEntries, diagnostics);
+    // After the host's entries, so a receipt the host rewrote gets its media too.
+    for (const page of pages) {
+        const path = `pwpack/surfaces/${page.key}.receipt.json`;
+        const filled = fillMediaSlots(files.get(path), media.slots.get(page.key));
+        if (filled)
+            files.set(path, filled);
+    }
+    // ── the Content Security Policy ──────────────────────────────────
+    const servedReceipts = new Map();
+    for (const page of pages) {
+        const bytes = files.get(`pwpack/surfaces/${page.key}.receipt.json`);
+        try {
+            servedReceipts.set(page.key, bytes ? JSON.parse(new TextDecoder().decode(bytes)) : page.receipt);
+        }
+        catch {
+            servedReceipts.set(page.key, page.receipt);
+        }
+    }
+    const envelopeAuthBytes = files.get('pwpack/auth.json');
+    const csp = deriveCsp({
+        importMapText: importMapText(),
+        receipts: servedReceipts,
+        connections,
+        engines: engineManifest,
+        envelopeAuth: envelopeAuthBytes ? JSON.parse(new TextDecoder().decode(envelopeAuthBytes)) : undefined,
+        authDefinition: authDoc,
+        media: media.records,
+        webfontHref: webfontStylesheetHref(themeWebfonts(config)),
+    });
+    files.set('index.html', shell(csp.meta));
+    files.set('_headers', enc.encode(headersFile(csp.header)));
+    const publishedAtoms = atoms
+        .filter((a) => used.has(a))
+        .map((a) => {
+        const module = blockManifest.find((b) => b.integrity === (a.hash ? hexOf(a.hash) : ''))?.moduleUrl ??
+            engineManifest.find((e) => e.atomId === a.id && e.moduleUrl)?.moduleUrl;
+        return {
+            kind: a.kind,
+            id: a.id,
+            hash: a.sourceHash,
+            ...(module && a.hash ? { module, integrity: hexOf(a.hash) } : {}),
+        };
+    });
+    files.set('publish.json', json({
+        formatVersion: '1.0',
+        app: { id: identity.id, version: identity.version },
+        liveVersion: identity.version,
+        publishedAt: options.publishedAt ?? new Date().toISOString(),
+        packs: sources.packs.map((p) => ({ id: p.id, version: p.version, hash: p.pinnedHash ?? hashPack(p.folder) })),
+        atoms: publishedAtoms,
+        ...(media.records.length > 0 ? { media: media.records } : {}),
+        csp: { policy: csp.header, ...(csp.unresolved.length > 0 ? { unresolved: csp.unresolved } : {}) },
+    }));
+    const compiled = atoms.filter((a) => a.status === 'compiled' || a.status === 'precompiled');
+    return done({
+        pages: pages.length,
+        blocks: blockManifest.length,
+        engines: engineManifest.length,
+        atoms: atoms.length,
+        compiled: compiled.length,
+        fromCache: compiled.filter((a) => a.fromCache).length,
+        failed: atoms.filter((a) => a.status === 'failed').length,
+    });
+}
+//# sourceMappingURL=assemble.js.map