@metamesh/cli 0.0.0-stage → 0.13.0

package/dist/docs/reference/authoring/CapturedGeometry.md

@@ -0,0 +1,13 @@
+# CapturedGeometry
+
+CapturedGeometry exported from @metamesh/cli/authoring.
+
+Import from `@metamesh/cli/authoring` (@metamesh/cli@0.13.0).
+
+```ts
+export interface CapturedGeometry {
+    readonly id: string;
+    readonly positions: Float32Array;
+    readonly indices: Uint32Array;
+}
+```

package/dist/docs/reference/authoring/CapturedPart.md

@@ -0,0 +1,16 @@
+# CapturedPart
+
+CapturedPart exported from @metamesh/cli/authoring.
+
+Import from `@metamesh/cli/authoring` (@metamesh/cli@0.13.0).
+
+```ts
+export interface CapturedPart {
+    readonly id: string;
+    readonly resourceId: string;
+    readonly position: Vector3;
+    readonly rotation: Vector3;
+    readonly color?: string;
+    readonly measurements: SnapshotPart["measurements"];
+}
+```

package/dist/docs/reference/authoring/CapturedResource.md

@@ -0,0 +1,14 @@
+# CapturedResource
+
+CapturedResource exported from @metamesh/cli/authoring.
+
+Import from `@metamesh/cli/authoring` (@metamesh/cli@0.13.0).
+
+```ts
+export interface CapturedResource {
+    readonly id: string;
+    readonly positions: CapturedBuffer;
+    readonly indices: CapturedBuffer;
+    readonly measurements: SnapshotPart["measurements"];
+}
+```

package/dist/docs/reference/authoring/CapturedRun.md

@@ -0,0 +1,13 @@
+# CapturedRun
+
+CapturedRun exported from @metamesh/cli/authoring.
+
+Import from `@metamesh/cli/authoring` (@metamesh/cli@0.13.0).
+
+```ts
+export interface CapturedRun {
+    readonly directory: string;
+    readonly manifest: CapturedRunManifest;
+    readonly resources: readonly CapturedGeometry[];
+}
+```

package/dist/docs/reference/authoring/CapturedRunManifest.md

@@ -0,0 +1,38 @@
+# CapturedRunManifest
+
+CapturedRunManifest exported from @metamesh/cli/authoring.
+
+Import from `@metamesh/cli/authoring` (@metamesh/cli@0.13.0).
+
+```ts
+export interface CapturedRunManifest {
+    readonly formatVersion: 1;
+    readonly status: "complete";
+    readonly runId: string;
+    readonly createdAt: string;
+    readonly kind: AuthoringKind;
+    readonly source: {
+        readonly entry: string;
+        readonly fingerprint: string;
+    };
+    readonly packages: Readonly<Record<string, string>>;
+    readonly parameters: Readonly<Record<string, unknown>>;
+    /** Effective Generator font selections, or declared and byte-verified standalone fixture revisions. */
+    readonly assets: readonly {
+        readonly faceId: string;
+        readonly revision: string;
+        readonly weight: number;
+    }[];
+    readonly policy: {
+        readonly timeoutMs: number;
+        readonly limits: ModelingLimits;
+    };
+    readonly diagnostics: readonly GenerationDiagnostic[];
+    readonly bounds: Bounds3;
+    readonly stats: FinalizedModel["stats"];
+    readonly dependencies: ModelDependencies;
+    readonly resources: readonly CapturedResource[];
+    readonly parts: readonly CapturedPart[];
+    readonly export3mf?: CapturedBuffer;
+}
+```

package/dist/docs/reference/authoring/CheckOptions.md

@@ -0,0 +1,14 @@
+# CheckOptions
+
+CheckOptions exported from @metamesh/cli/authoring.
+
+Import from `@metamesh/cli/authoring` (@metamesh/cli@0.13.0).
+
+```ts
+export interface CheckOptions {
+    readonly entry: string;
+    readonly kind: AuthoringKind;
+    readonly project?: string;
+    readonly tsconfig?: string;
+}
+```

package/dist/docs/reference/authoring/CheckSuccess.md

@@ -0,0 +1,15 @@
+# CheckSuccess
+
+CheckSuccess exported from @metamesh/cli/authoring.
+
+Import from `@metamesh/cli/authoring` (@metamesh/cli@0.13.0).
+
+```ts
+export interface CheckSuccess {
+    readonly success: true;
+    readonly entry: string;
+    readonly kind: AuthoringKind;
+    readonly tsconfig?: string;
+    readonly diagnostics: readonly AuthoringDiagnostic[];
+}
+```

package/dist/docs/reference/authoring/DocumentationEntry.md

@@ -0,0 +1,18 @@
+# DocumentationEntry
+
+DocumentationEntry exported from @metamesh/cli/authoring.
+
+Import from `@metamesh/cli/authoring` (@metamesh/cli@0.13.0).
+
+```ts
+export interface DocumentationEntry {
+    readonly id: string;
+    readonly title: string;
+    readonly summary: string;
+    readonly path: string;
+    readonly importPath: string;
+    readonly availability: string;
+    readonly canonical: string;
+    readonly keywords: readonly string[];
+}
+```

package/dist/docs/reference/authoring/DocumentationManifest.md

@@ -0,0 +1,14 @@
+# DocumentationManifest
+
+DocumentationManifest exported from @metamesh/cli/authoring.
+
+Import from `@metamesh/cli/authoring` (@metamesh/cli@0.13.0).
+
+```ts
+export interface DocumentationManifest {
+    readonly formatVersion: 1;
+    readonly packageName: string;
+    readonly packageVersion: string;
+    readonly documents: readonly DocumentationEntry[];
+}
+```

package/dist/docs/reference/authoring/DocumentationSearchResult.md

@@ -0,0 +1,12 @@
+# DocumentationSearchResult
+
+DocumentationSearchResult exported from @metamesh/cli/authoring.
+
+Import from `@metamesh/cli/authoring` (@metamesh/cli@0.13.0).
+
+```ts
+export interface DocumentationSearchResult extends DocumentationEntry {
+    readonly packageName: string;
+    readonly packageVersion: string;
+}
+```

package/dist/docs/reference/authoring/InstalledAuthoringPackage.md

@@ -0,0 +1,14 @@
+# InstalledAuthoringPackage
+
+InstalledAuthoringPackage exported from @metamesh/cli/authoring.
+
+Import from `@metamesh/cli/authoring` (@metamesh/cli@0.13.0).
+
+```ts
+export interface InstalledAuthoringPackage {
+    readonly name: string;
+    readonly version: string;
+    readonly manifestPath: string;
+    readonly documentCount: number;
+}
+```

package/dist/docs/reference/authoring/RenderCamera.md

@@ -0,0 +1,22 @@
+# RenderCamera
+
+Recorded orthographic camera, expressed in millimetres and world coordinates.
+
+Import from `@metamesh/cli/authoring` (@metamesh/cli@0.13.0).
+
+```ts
+/** Recorded orthographic camera, expressed in millimetres and world coordinates. */
+export interface RenderCamera {
+    readonly position: readonly [number, number, number];
+    readonly target: readonly [number, number, number];
+    readonly up: readonly [number, number, number];
+    readonly frustum: {
+        readonly left: number;
+        readonly right: number;
+        readonly top: number;
+        readonly bottom: number;
+        readonly near: number;
+        readonly far: number;
+    };
+}
+```

package/dist/docs/reference/authoring/RenderFormat.md

@@ -0,0 +1,10 @@
+# RenderFormat
+
+Image encodings; WebP is always lossless.
+
+Import from `@metamesh/cli/authoring` (@metamesh/cli@0.13.0).
+
+```ts
+/** Image encodings; WebP is always lossless. */
+export type RenderFormat = "png" | "webp";
+```

package/dist/docs/reference/authoring/RenderOptions.md

@@ -0,0 +1,20 @@
+# RenderOptions
+
+Options for rendering a previously captured model, without executing author code.
+
+Import from `@metamesh/cli/authoring` (@metamesh/cli@0.13.0).
+
+```ts
+/** Options for rendering a previously captured model, without executing author code. */
+export interface RenderOptions {
+    readonly views?: readonly RenderView[];
+    readonly width?: number;
+    readonly height?: number;
+    readonly format?: RenderFormat;
+    readonly background?: "transparent" | `#${string}`;
+    /** Parent for a new unique capture directory; defaults to the run's renders directory. */
+    readonly outputDirectory?: string;
+    /** Browser startup, page readiness, and capture deadline; defaults to 30 seconds. */
+    readonly timeoutMs?: number;
+}
+```

package/dist/docs/reference/authoring/RenderResult.md

@@ -0,0 +1,15 @@
+# RenderResult
+
+Images always belong to one captured run and one unique output directory.
+
+Import from `@metamesh/cli/authoring` (@metamesh/cli@0.13.0).
+
+```ts
+/** Images always belong to one captured run and one unique output directory. */
+export interface RenderResult {
+    readonly runId: string;
+    readonly sourceFingerprint: string;
+    readonly directory: string;
+    readonly images: readonly RenderedImage[];
+}
+```

package/dist/docs/reference/authoring/RenderView.md

@@ -0,0 +1,10 @@
+# RenderView
+
+Standard orthographic views in MetaMesh's Z-up coordinate system.
+
+Import from `@metamesh/cli/authoring` (@metamesh/cli@0.13.0).
+
+```ts
+/** Standard orthographic views in MetaMesh's Z-up coordinate system. */
+export type RenderView = "isometric" | "front" | "top" | "right";
+```

package/dist/docs/reference/authoring/RenderedImage.md

@@ -0,0 +1,23 @@
+# RenderedImage
+
+A view and its provenance, also written beside the image as JSON.
+
+Import from `@metamesh/cli/authoring` (@metamesh/cli@0.13.0).
+
+```ts
+/** A view and its provenance, also written beside the image as JSON. */
+export interface RenderedImage {
+    readonly path: string;
+    readonly metadataPath: string;
+    readonly runId: string;
+    readonly sourceFingerprint: string;
+    readonly view: RenderView;
+    readonly width: number;
+    readonly height: number;
+    readonly format: RenderFormat;
+    readonly background: string;
+    readonly camera: RenderCamera;
+    readonly rendererRevision: string;
+    readonly browserVersion: string;
+}
+```

package/dist/docs/reference/authoring/RunOptions.md

@@ -0,0 +1,17 @@
+# RunOptions
+
+RunOptions exported from @metamesh/cli/authoring.
+
+Import from `@metamesh/cli/authoring` (@metamesh/cli@0.13.0).
+
+```ts
+export interface RunOptions extends CheckOptions {
+    readonly params?: Readonly<Record<string, unknown>>;
+    readonly fontFixtures?: string;
+    readonly output?: string;
+    readonly timeoutMs?: number;
+    readonly limits?: Partial<ModelingLimits>;
+    readonly export3mf?: boolean;
+    readonly onLog?: (text: string) => void;
+}
+```

package/dist/docs/reference/authoring/RunSuccess.md

@@ -0,0 +1,13 @@
+# RunSuccess
+
+RunSuccess exported from @metamesh/cli/authoring.
+
+Import from `@metamesh/cli/authoring` (@metamesh/cli@0.13.0).
+
+```ts
+export interface RunSuccess {
+    readonly success: true;
+    readonly runDirectory: string;
+    readonly manifest: CapturedRunManifest;
+}
+```

package/dist/docs/reference/authoring/authoringFailure-value.md

@@ -0,0 +1,9 @@
+# authoringFailure
+
+authoringFailure exported from @metamesh/cli/authoring.
+
+Import from `@metamesh/cli/authoring` (@metamesh/cli@0.13.0).
+
+```ts
+export declare function authoringFailure(error: unknown, fallbackPhase?: AuthoringPhase): AuthoringFailure;
+```

package/dist/docs/reference/authoring/checkAuthoringSource.md

@@ -0,0 +1,9 @@
+# checkAuthoringSource
+
+checkAuthoringSource exported from @metamesh/cli/authoring.
+
+Import from `@metamesh/cli/authoring` (@metamesh/cli@0.13.0).
+
+```ts
+export declare function checkAuthoringSource(options: CheckOptions): Promise<CheckSuccess | AuthoringFailure>;
+```

package/dist/docs/reference/authoring/discoverAuthoringEnvironment.md

@@ -0,0 +1,9 @@
+# discoverAuthoringEnvironment
+
+discoverAuthoringEnvironment exported from @metamesh/cli/authoring.
+
+Import from `@metamesh/cli/authoring` (@metamesh/cli@0.13.0).
+
+```ts
+export declare function discoverAuthoringEnvironment(project?: string): Promise<AuthoringEnvironment>;
+```

package/dist/docs/reference/authoring/inspectCapturedRun.md

@@ -0,0 +1,11 @@
+# inspectCapturedRun
+
+inspectCapturedRun exported from @metamesh/cli/authoring.
+
+Import from `@metamesh/cli/authoring` (@metamesh/cli@0.13.0).
+
+```ts
+export declare function inspectCapturedRun(directory: string, partId?: string): Promise<Omit<CapturedRun, "resources"> & {
+    readonly selectedPart?: CapturedPart;
+}>;
+```

package/dist/docs/reference/authoring/installAuthoringBrowser.md

@@ -0,0 +1,13 @@
+# installAuthoringBrowser
+
+Explicit installation of this package's pinned Chromium. Never called by render.
+
+Import from `@metamesh/cli/authoring` (@metamesh/cli@0.13.0).
+
+```ts
+/** Explicit installation of this package's pinned Chromium. Never called by render. */
+export declare function installAuthoringBrowser(): Promise<{
+    browser: "chromium";
+    executablePath: string;
+}>;
+```

package/dist/docs/reference/authoring/readCapturedRun.md

@@ -0,0 +1,10 @@
+# readCapturedRun
+
+Reads only immutable captured files. It never imports or executes original author source.
+
+Import from `@metamesh/cli/authoring` (@metamesh/cli@0.13.0).
+
+```ts
+/** Reads only immutable captured files. It never imports or executes original author source. */
+export declare function readCapturedRun(directory: string): Promise<CapturedRun>;
+```

package/dist/docs/reference/authoring/renderCapturedRun.md

@@ -0,0 +1,13 @@
+# renderCapturedRun
+
+Render validated persisted local geometry and placements. Source code is never imported, and a fresh capture directory prevents overlapping calls from overwriting evidence.
+
+Import from `@metamesh/cli/authoring` (@metamesh/cli@0.13.0).
+
+```ts
+/**
+ * Render validated persisted local geometry and placements. Source code is never imported,
+ * and a fresh capture directory prevents overlapping calls from overwriting evidence.
+ */
+export declare function renderCapturedRun(directory: string, options?: RenderOptions): Promise<RenderResult>;
+```

package/dist/docs/reference/authoring/runAuthoringSource.md

@@ -0,0 +1,9 @@
+# runAuthoringSource
+
+runAuthoringSource exported from @metamesh/cli/authoring.
+
+Import from `@metamesh/cli/authoring` (@metamesh/cli@0.13.0).
+
+```ts
+export declare function runAuthoringSource(options: RunOptions): Promise<RunSuccess | AuthoringFailure>;
+```

package/dist/docs/reference/authoring/searchAuthoringDocumentation.md

@@ -0,0 +1,12 @@
+# searchAuthoringDocumentation
+
+searchAuthoringDocumentation exported from @metamesh/cli/authoring.
+
+Import from `@metamesh/cli/authoring` (@metamesh/cli@0.13.0).
+
+```ts
+export declare function searchAuthoringDocumentation(query: string, options?: {
+    readonly project?: string;
+    readonly limit?: number;
+}): Promise<readonly DocumentationSearchResult[]>;
+```

package/dist/docs/reference/authoring/showAuthoringDocumentation.md

@@ -0,0 +1,11 @@
+# showAuthoringDocumentation
+
+showAuthoringDocumentation exported from @metamesh/cli/authoring.
+
+Import from `@metamesh/cli/authoring` (@metamesh/cli@0.13.0).
+
+```ts
+export declare function showAuthoringDocumentation(id: string, project?: string): Promise<DocumentationSearchResult & {
+    readonly markdown: string;
+}>;
+```

package/dist/metamesh.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=metamesh.d.ts.map

package/dist/metamesh.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metamesh.d.ts","sourceRoot":"","sources":["../src/metamesh.ts"],"names":[],"mappings":""}

package/dist/metamesh.js

@@ -0,0 +1,183 @@
+#!/usr/bin/env node
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { Command, CommanderError, InvalidArgumentError, Option } from "commander";
+import { AuthoringError, authoringFailure, isRecord } from "./authoring/errors.js";
+import { AUTHORING_PROTOCOL_VERSION, } from "./authoring/types.js";
+/** Keep the repository's strict scalar-option policy without importing unpublished tools. */
+function valueOption(flags, description, choices) {
+    const option = new Option(flags, description);
+    if (choices)
+        option.choices([...choices]);
+    const parse = option.parseArg;
+    return option.argParser((value, previous) => {
+        if (previous !== undefined)
+            throw new InvalidArgumentError("option may only be provided once");
+        return parse ? parse(value, previous) : value;
+    });
+}
+const projectFor = (options) => resolve(options.project ?? process.cwd());
+const entryOptions = (options, entry) => ({
+    entry,
+    kind: options.kind, // Commander requires and validates this option before the action.
+    project: projectFor(options),
+    ...(options.tsconfig === undefined ? {} : { tsconfig: options.tsconfig }),
+});
+async function readObject(project, file) {
+    if (file === undefined)
+        return undefined;
+    const value = JSON.parse(await readFile(resolve(project, file), "utf8"));
+    if (!isRecord(value))
+        throw new AuthoringError("invocation", "INVALID_JSON_INPUT", "Parameter and limit files must contain JSON objects.");
+    return value;
+}
+function humanResult(command, result) {
+    if (isRecord(result) && result.success === false && Array.isArray(result.diagnostics))
+        return `${result.diagnostics.map((issue) => `${issue.code}: ${issue.message}`).join("\n")}${typeof result.runDirectory === "string" ? `\nAttempt: ${result.runDirectory}` : ""}\n`;
+    if (command === "environment") {
+        const environment = result;
+        return `MetaMesh authoring protocol ${environment.authoringProtocolVersion}\nProject: ${environment.project}\n${environment.packages.map((pkg) => `${pkg.name} ${pkg.version} (${pkg.documentCount} topics)\n  ${pkg.manifestPath}`).join("\n")}\n`;
+    }
+    if (command === "docs" && Array.isArray(result))
+        return `${result.map(({ id, summary }) => `${id}\n  ${summary}`).join("\n")}\n`;
+    if (isRecord(result) && typeof result.markdown === "string")
+        return `${result.markdown}\n`;
+    if (command === "check" && isRecord(result) && result.success === true)
+        return `TypeScript check passed: ${String(result.entry)}\n`;
+    if ((command === "run" || command === "inspect") &&
+        isRecord(result) &&
+        isRecord(result.manifest)) {
+        const manifest = result.manifest;
+        return `${manifest.parts.length} parts; ${manifest.stats.vertices} vertices; ${manifest.stats.triangles} triangles; ${manifest.stats.volumeMm3.toFixed(3)} mm³\nCaptured: ${String(result.runDirectory ?? result.directory)}\n${manifest.diagnostics.map(({ severity, message }) => `${severity}: ${message}\n`).join("")}${isRecord(result.selectedPart) ? `Part: ${JSON.stringify(result.selectedPart)}\n` : ""}`;
+    }
+    return `${JSON.stringify(result, null, 2)}\n`;
+}
+async function main() {
+    const args = process.argv.slice(2);
+    const json = args.includes("--json");
+    let help = "";
+    const program = new Command("metamesh")
+        .description("Check, generate, inspect, and render local MetaMesh models.")
+        .option("--json", "emit one structured result on stdout")
+        .addOption(valueOption("--project <directory>", "resolve packages and paths from this project"))
+        .allowExcessArguments(false)
+        .configureHelp({ showGlobalOptions: true })
+        .configureOutput({
+        writeOut: (text) => {
+            help += text;
+        },
+        writeErr: () => { },
+    })
+        .addHelpText("after", "\nLocal author source executes with your account's permissions; this is not a sandbox.")
+        .exitOverride();
+    program.action(() => {
+        program.help();
+    });
+    const command = (parent, name, description) => parent.command(name).description(description).allowExcessArguments(false);
+    const action = (target, handler, format = target.name()) => {
+        target.action(async () => {
+            const result = await handler(target.optsWithGlobals(), target.args);
+            if (isRecord(result) && result.success === false)
+                process.exitCode = typeof result.exitCode === "number" ? result.exitCode : 2;
+            process.stdout.write(json ? `${JSON.stringify(result)}\n` : humanResult(format, result));
+        });
+    };
+    const entryCommand = (name, description) => command(program, name, description)
+        .argument("<entry>", "local TypeScript module")
+        .addOption(valueOption("--kind <kind>", "entry module contract", [
+        "model",
+        "generator",
+    ]).makeOptionMandatory())
+        .addOption(valueOption("--tsconfig <file>", "override the nearest TypeScript configuration"));
+    action(command(program, "environment", "discover installed packages and documentation"), async (options) => (await import("./authoring/environment.js")).discoverAuthoringEnvironment(projectFor(options)));
+    const docs = command(program, "docs", "search and read installed version-matched documentation");
+    docs.action(() => {
+        docs.help();
+    });
+    action(command(docs, "search", "search bounded topic and symbol metadata")
+        .argument("<query...>")
+        .addOption(valueOption("--limit <count>", "maximum results, 1–50 (default: 10)")), async (options, query) => (await import("./authoring/environment.js")).searchAuthoringDocumentation(query.join(" "), {
+        project: projectFor(options),
+        ...(options.limit === undefined ? {} : { limit: Number(options.limit) }),
+    }), "docs");
+    action(command(docs, "show", "read one installed topic").argument("<id>"), async (options, [id]) => (await import("./authoring/environment.js")).showAuthoringDocumentation(id, projectFor(options)));
+    action(entryCommand("check", "check TypeScript without evaluating source"), async (options, [entry]) => (await import("./authoring/check.js")).checkAuthoringSource(entryOptions(options, entry)));
+    action(entryCommand("run", "check, execute, and capture a fresh result")
+        .addOption(valueOption("--params <file>", "JSON parameter overrides (default: {})"))
+        .addOption(valueOption("--font-fixtures <file>", "local immutable font descriptors"))
+        .addOption(valueOption("--output <parent>", "parent for a unique run directory"))
+        .addOption(valueOption("--timeout <milliseconds>", "execution deadline (default: 30000)"))
+        .addOption(valueOption("--limits <file>", "JSON overrides lowering engine resource limits"))
+        .option("--export-3mf", "export this captured snapshot as 3MF"), async (options, [entry]) => {
+        const project = projectFor(options);
+        const limits = await readObject(project, options.limits);
+        return (await import("./authoring/run.js")).runAuthoringSource({
+            ...entryOptions(options, entry),
+            params: (await readObject(project, options.params)) ?? {},
+            ...(limits === undefined ? {} : { limits }),
+            ...(options.fontFixtures === undefined ? {} : { fontFixtures: options.fontFixtures }),
+            ...(options.output === undefined ? {} : { output: options.output }),
+            ...(options.timeout === undefined ? {} : { timeoutMs: Number(options.timeout) }),
+            export3mf: options.export3mf ?? false,
+            onLog: (text) => process.stderr.write(text),
+        });
+    });
+    action(command(program, "inspect", "read captured measurements and provenance")
+        .argument("<run-directory>")
+        .addOption(valueOption("--part <id>", "select a semantic part ID")), async (options, [directory]) => (await import("./authoring/artifacts.js")).inspectCapturedRun(resolve(projectFor(options), directory), options.part));
+    action(command(program, "render", "render captured geometry without executing author code")
+        .argument("<run-directory>")
+        .addOption(valueOption("--views <views>", "comma-separated isometric,front,top,right (default: isometric)"))
+        .addOption(valueOption("--width <pixels>", "image width (default: 1024)"))
+        .addOption(valueOption("--height <pixels>", "image height (default: 1024)"))
+        .addOption(valueOption("--format <format>", "image encoding (default: png)", ["png", "webp"]))
+        .option("--transparent", "use a transparent background")
+        .addOption(valueOption("--background <hex-color>", "six-digit RGB background").conflicts("transparent"))
+        .addOption(valueOption("--output <parent>", "parent for a unique capture directory")), async (options, [directory]) => (await import("./authoring/render.js")).renderCapturedRun(resolve(projectFor(options), directory), {
+        ...(options.views === undefined
+            ? {}
+            : { views: options.views.split(",") }),
+        ...(options.width === undefined ? {} : { width: Number(options.width) }),
+        ...(options.height === undefined ? {} : { height: Number(options.height) }),
+        ...(options.format === undefined ? {} : { format: options.format }),
+        ...(options.transparent
+            ? { background: "transparent" }
+            : options.background === undefined
+                ? {}
+                : { background: options.background }),
+        ...(options.output === undefined
+            ? {}
+            : { outputDirectory: resolve(projectFor(options), options.output) }),
+    }));
+    const browser = command(program, "browser", "set up the optional pinned capture browser");
+    browser.action(() => {
+        browser.help();
+    });
+    action(command(browser, "install", "explicitly install pinned Chromium"), async () => (await import("./authoring/render.js")).installAuthoringBrowser());
+    action(command(program, "setup", "print skill installation and project-instruction guidance"), () => ({
+        success: true,
+        authoringProtocolVersion: AUTHORING_PROTOCOL_VERSION,
+        installation: "pnpm dlx skills@1.5.22 add https://github.com/metamesh-studio/metamesh-skills --skill metamesh-developer",
+        publication: "The operator must publish the canonical skills repository before this GitHub installation command is available.",
+        instructions: "Use the metamesh-developer skill. Run metamesh environment --json in this project, consult installed docs with metamesh docs search/show, then check, run, and inspect the captured result. Render relevant views before declaring geometry work complete.",
+    }));
+    try {
+        await program.parseAsync(args, { from: "user" });
+    }
+    catch (error) {
+        if (error instanceof CommanderError && error.exitCode === 0) {
+            process.stdout.write(json ? `${JSON.stringify({ success: true, help })}\n` : help);
+            return;
+        }
+        const failure = authoringFailure(error instanceof CommanderError
+            ? new AuthoringError("invocation", "INVALID_ARGUMENTS", error.message.replace(/^error:\s*/i, ""))
+            : error, "invocation");
+        process.exitCode = failure.exitCode;
+        if (json)
+            process.stdout.write(`${JSON.stringify(failure)}\n`);
+        else
+            process.stderr.write(`${failure.diagnostics.map(({ code, message }) => `${code}: ${message}`).join("\n")}\n`);
+    }
+}
+await main();
+//# sourceMappingURL=metamesh.js.map