@askrjs/cli 0.0.2 → 0.0.4

package/dist/skills/askr-dashboard-charts/SKILL.md

@@ -1,79 +1,96 @@
 ---
 name: askr-dashboard-charts
-description: Use when building askr dashboards, stat cards, activity feeds, product metrics, tables, async feedback, and @askrjs/charts visualizations such as area, bar, line, donut, heatmap, timeline, gauges, and chart chrome.
+description: Build product dashboards and metric-heavy Askr routes with route-owned async state, shared formatting, and typed @askrjs/charts plots. Use for stat cards, mixed charts, live or follow-latest data, zoom, brush, selection, accessible summaries, and chart exports.
 ---
 
 # Askr Dashboard Charts
 
-Use this for product dashboards and metric-heavy screens. The goal is route-owned data, deterministic metric formatting, and charts that answer product questions without inventing parallel UI systems.
-
-## Use This When
-
-- You are building a dashboard, metrics screen, stat-card surface, or chart-heavy route.
-- The page needs resource-owned async loading plus chart composition.
-- Charts and tables must share the same formatter logic.
-- You need loading, empty, and error truth on a dense metrics screen.
+Build dashboards that answer product questions without inventing parallel data, UI, or formatting systems.
 
 ## Inspect First
 
-- `templates/startkit/src/pages/workspace/dashboard.tsx`
-- Existing stat card, table, empty state, and chart styles
-- Existing format helpers in `src/shared`
-- Existing route or feature owners for the metrics you need
+- Inspect the route or feature that owns the data.
+- Inspect existing cards, tables, empty states, chart tokens, and format helpers.
+- Inspect the nearest existing typed plot. In a generated SPA, start with `src/pages/app/admin-home.tsx`; in the CLI source, use `templates/spa/src/pages/app/admin-home.tsx`.
 
-## Choose The Owner
+## Keep Ownership Clear
 
-- The route or page owns high-level loading and composition.
+- Keep loading, empty, error, refresh, and composition state in the route or feature container.
 - `src/components/shared` owns reusable stat cards, page headers, tables, and empty states.
-- `src/features/<domain>` owns domain-specific dashboard panels and metric workflows.
+- `src/features/<domain>` owns metric workflows and transforms.
 - `src/shared` owns formatting helpers so cards, tables, and charts stay consistent.
+- Keep row types app-owned; do not import package-owned datum types.
 
-## Do This In Order
+## Work In Order
 
-1. Load dashboard data in the route or feature container with `resource()` unless the data must be shared across screens.
-2. Keep metric formatting in shared helpers.
-3. Use `@askrjs/charts` components for chart visuals and keep CSS imported at the app boundary.
-4. Pair charts with labels, summaries, or tables when precision matters.
-5. Keep loading, empty, error, and refresh states explicit.
+1. Load dashboard data with `resource()` unless a wider owner already exists.
+2. Model stable row keys and missing values before choosing marks.
+3. Create each typed plot namespace once at module scope.
+4. Compose the smallest plot that answers the product question.
+5. Import `@askrjs/charts/styles` once at the app boundary.
+6. Pair plots with summaries or on-demand data tables when precision matters.
 
-## Copy This Shape
+## Compose A Typed Plot
 
 ```tsx
-import { resource } from "@askrjs/askr/resources";
-import { AreaChart, ChartPanel, ChartShell } from "@askrjs/charts/components";
-
-const dashboard = resource(({ signal }) => loadDashboard({ signal }), []);
+import { createPlot } from "@askrjs/charts";
+
+type ThroughputRow = {
+  id: string;
+  timestamp: Date;
+  completed: number;
+  movingAverage: number;
+};
+
+const ThroughputPlot = createPlot<ThroughputRow>();
+
+<ThroughputPlot.Root
+  data={rows}
+  rowKey="id"
+  label="Completed runs over time"
+  title="Run throughput"
+  description="Completed runs with a moving average."
+>
+  <ThroughputPlot.Bar x="timestamp" y="completed" />
+  <ThroughputPlot.Line x="timestamp" y="movingAverage" />
+  <ThroughputPlot.Point x="timestamp" y="movingAverage" />
+  <ThroughputPlot.Zoom axes="x" />
+  <ThroughputPlot.Brush axis="x" modifier="shift" />
+</ThroughputPlot.Root>;
+```
 
-if (dashboard.pending && !dashboard.value) return <p>Loading dashboard...</p>;
-if (dashboard.error) return <p role="alert">Unable to load dashboard.</p>;
+## Handle Mixed, Live, And Interactive Data
 
-<ChartShell title="Revenue" description="Last 7 days">
-  <ChartPanel title="Trend">
-    <AreaChart label="Revenue trend" data={dashboard.value.revenue} />
-  </ChartPanel>
-</ChartShell>;
-```
+- Use named scales and dual axes only when a mixed plot compares different units.
+- Pass a reactive data getter for changing rows and update arrays with `appendPlotRows`, `upsertPlotRows`, `removePlotRows`, or `trimPlotRows`.
+- Configure follow-latest by row count or time; let user pan or zoom pause following and provide an explicit `resumeLive()` action.
+- Keep `view` and `selection` controlled when route or shared state owns them; otherwise use plot-local state.
+- Add zoom, brush, legend filtering, or `onActivate` only when the workflow needs that interaction.
+- Keep source and transformed exports distinguishable, and preserve access to visible or selected rows.
 
-## Never Do These
+## Avoid
 
 - Inline mock metrics inside page JSX.
 - Hardcoded chart colors in runtime code.
 - Decorative charts that do not answer a product question.
+- Calling `createPlot()` inside a component or using unstable row keys.
+- Treating missing or non-finite values as zero.
 - Dense dashboards without loading, empty, and error states.
 
 ## Validate
 
-- Cards and charts share formatter logic.
-- The page scans cleanly at mobile, tablet, and desktop widths.
-- Chart data has stable labels and keys.
-- Loading, empty, error, and refresh states are visible.
+- Verify cards, tables, tooltips, and exports share formatter logic; keep summaries and tooltip formatters valid for empty or missing rows.
+- Verify mobile and desktop layouts in light and dark themes.
+- Verify keyboard inspection, selection, zoom, brush, and the on-demand data table when used.
+- Verify live updates retain stable selections and pause follow-latest after user navigation.
+- Run the app's targeted tests and typecheck before its full acceptance command.
 
 ## Done When
 
-- Route-owned loading and chart composition are clear.
-- Metric formatting is shared and deterministic.
-- Charts support the page's product question instead of decorating it.
-- Async states remain explicit on the dashboard surface.
+- Route-owned async states remain explicit.
+- Typed rows and stable keys drive the plot.
+- The plot supports the product question without becoming a component gallery.
+- Accessible summaries and precise data remain available without relying on canvas pixels.
 
 ## Handoff
 

package/dist/skills/askr-dashboard-charts/agents/openai.yaml

@@ -1,4 +1,4 @@
 interface:
   display_name: "Askr Dashboard Charts"
-  short_description: "Build dashboards and charts"
-  default_prompt: "Use $askr-dashboard-charts to build dashboard metrics and charts."
+  short_description: "Compose typed Askr dashboard plots"
+  default_prompt: "Use $askr-dashboard-charts to build an accessible typed dashboard plot."

package/dist/skills/askr-ssr-ssg/SKILL.md

@@ -28,7 +28,8 @@ Use this when the app renders outside the browser or produces static output. The
 2. Register routes at module load before boot or render.
 3. Keep render paths deterministic and environment-safe.
 4. Use route `entries` or the template's static config for parameterized SSG paths.
-5. Build and preview after changes that cross the render boundary.
+5. Set the canonical `siteUrl` and explicitly exclude non-indexable routes in `sitemap.routes`.
+6. Build and preview after changes that cross the render boundary.
 
 ## Copy This Shape
 
@@ -61,6 +62,7 @@ npx @askrjs/cli ssg --config ./ssg.config.ts --output ./dist/static
 - SSR or SSG build output is deterministic for the same inputs.
 - Hydration has no structural mismatch warnings.
 - Generated static routes cover expected params.
+- `sitemap.xml` contains every intended canonical route and excludes runtime-only or non-indexable routes.
 - Browser preview still navigates correctly after hydration.
 
 ## Done When

package/dist/{skills-Bh0mEhIx.js → skills-B7CbWur9.js}

@@ -1,6 +1,8 @@
 import { t as isDirectExecution } from "./is-direct-execution-Cdlr-ZUl.js";
+import { n as publishStagedDirectory, t as createSiblingStage } from "./directory-swap-DWoHtx7C.js";
 import fs from "node:fs/promises";
 import path from "node:path";
+import { constants } from "node:fs";
 import { fileURLToPath } from "node:url";
 //#region src/bin/skill-review.ts
 const TEXT_FILE_EXTENSIONS = /* @__PURE__ */ new Set([
@@ -312,29 +314,41 @@ const REVIEW_PROMPTS = [
 async function pathExists$1(filePath) {
 	return Boolean(await fs.stat(filePath).catch(() => null));
 }
+const MAX_REVIEW_FILES = 1e4;
+const MAX_REVIEW_FILE_BYTES = 2 * 1024 * 1024;
+const MAX_REVIEW_TOTAL_BYTES = 20 * 1024 * 1024;
 function shouldReadFile(filePath) {
 	return TEXT_FILE_EXTENSIONS.has(path.extname(filePath).toLowerCase());
 }
-async function collectReviewFiles(targetPath, files) {
+async function collectReviewFiles(targetPath, state) {
 	const stat = await fs.lstat(targetPath);
 	if (stat.isSymbolicLink()) return;
 	if (stat.isDirectory()) {
 		const entries = await fs.readdir(targetPath, { withFileTypes: true });
 		for (const entry of entries) {
 			if (entry.isDirectory() && IGNORED_DIRECTORIES.has(entry.name)) continue;
-			await collectReviewFiles(path.join(targetPath, entry.name), files);
+			await collectReviewFiles(path.join(targetPath, entry.name), state);
 		}
 		return;
 	}
-	if (stat.isFile() && shouldReadFile(targetPath)) files.push(targetPath);
+	if (stat.isFile() && shouldReadFile(targetPath)) {
+		if (stat.size > MAX_REVIEW_FILE_BYTES) throw new Error(`Review file exceeds ${MAX_REVIEW_FILE_BYTES} bytes: ${targetPath}`);
+		if (state.files.length >= MAX_REVIEW_FILES) throw new Error(`Review target exceeds ${MAX_REVIEW_FILES} text files`);
+		state.totalBytes += stat.size;
+		if (state.totalBytes > MAX_REVIEW_TOTAL_BYTES) throw new Error(`Review target exceeds ${MAX_REVIEW_TOTAL_BYTES} text bytes`);
+		state.files.push(targetPath);
+	}
 }
 async function loadReviewFiles(targetPath) {
 	const resolvedTarget = path.resolve(targetPath);
 	if (!await pathExists$1(resolvedTarget)) throw new Error(`Review target not found: ${resolvedTarget}`);
 	const baseDirectory = (await fs.stat(resolvedTarget)).isDirectory() ? resolvedTarget : path.dirname(resolvedTarget);
-	const absoluteFiles = [];
-	await collectReviewFiles(resolvedTarget, absoluteFiles);
-	const files = await Promise.all(absoluteFiles.map(async (filePath) => ({
+	const collection = {
+		files: [],
+		totalBytes: 0
+	};
+	await collectReviewFiles(resolvedTarget, collection);
+	const files = await Promise.all(collection.files.map(async (filePath) => ({
 		path: path.relative(baseDirectory, filePath) || path.basename(filePath),
 		content: await fs.readFile(filePath, "utf8")
 	})));
@@ -496,17 +510,23 @@ function parseArgs(args) {
 		cwd: process.cwd(),
 		force: false,
 		help: false,
-		json: false
+		json: false,
+		errors: []
 	};
 	for (let i = 0; i < args.length; i += 1) {
 		const arg = args[i];
 		if (arg === "--help" || arg === "-h") parsed.help = true;
 		else if (arg === "--json") parsed.json = true;
 		else if (arg === "--force") parsed.force = true;
-		else if (arg === "--cwd" && i + 1 < args.length) {
-			parsed.cwd = args[i + 1];
-			i += 1;
-		} else positional.push(arg);
+		else if (arg === "--cwd") {
+			const value = args[i + 1];
+			if (!value || value.startsWith("-")) parsed.errors.push("Missing value for --cwd");
+			else {
+				parsed.cwd = value;
+				i += 1;
+			}
+		} else if (arg.startsWith("-")) parsed.errors.push(`Unknown option: ${arg}`);
+		else positional.push(arg);
 	}
 	return {
 		...parsed,
@@ -572,16 +592,36 @@ async function copyBundledSkills(targetSkillsDir, bundledNames) {
 		await copyDir(src, dest);
 	}
 }
+async function stageSkillsDirectory(targetSkillsDir) {
+	const stage = await createSiblingStage(targetSkillsDir, "askr-skills");
+	if (await pathExists(targetSkillsDir)) await fs.cp(targetSkillsDir, stage, {
+		recursive: true,
+		mode: constants.COPYFILE_FICLONE
+	});
+	return stage;
+}
+async function replaceBundledSkills(targetSkillsDir, bundledNames) {
+	const stage = await stageSkillsDirectory(targetSkillsDir);
+	try {
+		await removeManagedSkillArtifacts(stage, bundledNames);
+		await copyBundledSkills(stage, bundledNames);
+		await publishStagedDirectory(stage, targetSkillsDir);
+	} catch (error) {
+		await fs.rm(stage, {
+			recursive: true,
+			force: true
+		});
+		throw error;
+	}
+}
 async function installBundledSkills(options = {}) {
 	const targetRoot = path.resolve(options.cwd ?? process.cwd());
 	const targetSkillsDir = path.join(targetRoot, PROJECT_SKILLS_DIR);
 	const bundledNames = await listBundledSkills();
+	const targetStat = await fs.stat(targetSkillsDir).catch(() => null);
+	if (targetStat && !targetStat.isDirectory()) throw new Error(`Skills target exists and is not a directory: ${targetSkillsDir}`);
 	if ((await fs.readdir(targetSkillsDir).catch(() => [])).length > 0 && !options.force) throw new Error(`Refusing to install into non-empty ${targetSkillsDir}.`);
-	if (options.force) {
-		await fs.mkdir(targetSkillsDir, { recursive: true });
-		await removeManagedSkillArtifacts(targetSkillsDir, bundledNames);
-	}
-	await copyBundledSkills(targetSkillsDir, bundledNames);
+	await replaceBundledSkills(targetSkillsDir, bundledNames);
 	return {
 		bundledNames,
 		targetSkillsDir
@@ -591,9 +631,9 @@ async function syncBundledSkills(options = {}) {
 	const targetRoot = path.resolve(options.cwd ?? process.cwd());
 	const targetSkillsDir = path.join(targetRoot, PROJECT_SKILLS_DIR);
 	const bundledNames = await listBundledSkills();
-	await fs.mkdir(targetSkillsDir, { recursive: true });
-	await removeManagedSkillArtifacts(targetSkillsDir, bundledNames);
-	await copyBundledSkills(targetSkillsDir, bundledNames);
+	const targetStat = await fs.stat(targetSkillsDir).catch(() => null);
+	if (targetStat && !targetStat.isDirectory()) throw new Error(`Skills target exists and is not a directory: ${targetSkillsDir}`);
+	await replaceBundledSkills(targetSkillsDir, bundledNames);
 	return {
 		bundledNames,
 		targetSkillsDir
@@ -615,9 +655,14 @@ async function installSkills(parsed, io) {
 	}
 }
 async function syncSkills(parsed, io) {
-	const { bundledNames, targetSkillsDir } = await syncBundledSkills({ cwd: parsed.cwd });
-	io.log(`Synced ${bundledNames.length} Askr skills to ${targetSkillsDir}`);
-	return 0;
+	try {
+		const { bundledNames, targetSkillsDir } = await syncBundledSkills({ cwd: parsed.cwd });
+		io.log(`Synced ${bundledNames.length} Askr skills to ${targetSkillsDir}`);
+		return 0;
+	} catch (error) {
+		io.error(error instanceof Error ? error.message : String(error));
+		return 1;
+	}
 }
 async function reviewSkills(parsed, io) {
 	if (parsed.help && parsed.command === "review") {
@@ -646,6 +691,10 @@ async function reviewSkills(parsed, io) {
 }
 async function runSkillsCli(args = process.argv.slice(2), io = console) {
 	const parsed = parseArgs(args);
+	if (parsed.errors.length > 0) {
+		for (const error of parsed.errors) io.error(error);
+		return 1;
+	}
 	if (parsed.command === "review" && parsed.help) {
 		io.log(reviewHelpText());
 		return 0;
@@ -660,12 +709,28 @@ async function runSkillsCli(args = process.argv.slice(2), io = console) {
 		return 1;
 	}
 	if (parsed.command === "list") {
+		if (parsed.positionals.length !== 1) {
+			io.error("Usage: askr skills list");
+			return 1;
+		}
 		const names = await listBundledSkills();
 		for (const name of names) io.log(name);
 		return 0;
 	}
-	if (parsed.command === "install") return installSkills(parsed, io);
-	if (parsed.command === "sync") return syncSkills(parsed, io);
+	if (parsed.command === "install") {
+		if (parsed.positionals.length !== 1) {
+			io.error("Usage: askr skills install [--cwd <dir>] [--force]");
+			return 1;
+		}
+		return installSkills(parsed, io);
+	}
+	if (parsed.command === "sync") {
+		if (parsed.positionals.length !== 1) {
+			io.error("Usage: askr skills sync [--cwd <dir>]");
+			return 1;
+		}
+		return syncSkills(parsed, io);
+	}
 	if (parsed.command === "review") return reviewSkills(parsed, io);
 	io.error(`Unknown skills command: ${parsed.command}`);
 	io.error("Run `askr skills --help` to see available commands.");
@@ -678,5 +743,3 @@ async function main() {
 if (isDirectExecution(import.meta.url)) main();
 //#endregion
 export { runSkillsCli as n, syncBundledSkills as r, installBundledSkills as t };
-
-//# sourceMappingURL=skills-Bh0mEhIx.js.map

package/dist/skills.d.ts

@@ -0,0 +1,18 @@
+//#region src/bin/skills.d.ts
+type CliIo = Pick<Console, "error" | "log">;
+declare function installBundledSkills(options?: {
+  cwd?: string;
+  force?: boolean;
+}): Promise<{
+  bundledNames: string[];
+  targetSkillsDir: string;
+}>;
+declare function syncBundledSkills(options?: {
+  cwd?: string;
+}): Promise<{
+  bundledNames: string[];
+  targetSkillsDir: string;
+}>;
+declare function runSkillsCli(args?: string[], io?: CliIo): Promise<number>;
+//#endregion
+export { installBundledSkills, runSkillsCli, syncBundledSkills };

package/dist/skills.js

@@ -1,3 +1,3 @@
 #!/usr/bin/env node
-import { n as runSkillsCli, r as syncBundledSkills, t as installBundledSkills } from "./skills-Bh0mEhIx.js";
+import { n as runSkillsCli, r as syncBundledSkills, t as installBundledSkills } from "./skills-B7CbWur9.js";
 export { installBundledSkills, runSkillsCli, syncBundledSkills };

package/dist/specification-DXnDOC-0.js

@@ -0,0 +1,49 @@
+import semver from "semver";
+//#region src/update/specification.ts
+const WINDOWS_PATH = /^[A-Za-z]:[\\/]/;
+const HOSTED_GIT = /^(?:bitbucket|gist|github|gitlab):/i;
+const GIT_URL = /^(?:git(?:\+[^:]+)?:|git@|ssh:)/i;
+const GIT_SHORTHAND = /^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+(?:#.*)?$/;
+const REGISTRY_TAG = /^[A-Za-z][A-Za-z0-9._-]*$/;
+const SCOPED_PATH = /^@[^/]+\/[^/]+$/;
+function parseDependencySpecification(specification) {
+	const rawSpec = specification.trim();
+	if (!rawSpec) return {
+		type: "unsupported",
+		rawSpec
+	};
+	if (/^npm:/i.test(rawSpec)) return {
+		type: "alias",
+		rawSpec
+	};
+	if (/^(?:file|link|workspace):/i.test(rawSpec) || rawSpec.startsWith("./") || rawSpec.startsWith("../") || rawSpec.startsWith("/") || rawSpec.startsWith("~/") || /\.(?:tar\.gz|tgz)$/i.test(rawSpec) || WINDOWS_PATH.test(rawSpec) || /^[A-Za-z]:/.test(rawSpec) || SCOPED_PATH.test(rawSpec)) return {
+		type: "file",
+		rawSpec
+	};
+	if (HOSTED_GIT.test(rawSpec) || GIT_URL.test(rawSpec) || GIT_SHORTHAND.test(rawSpec)) return {
+		type: "git",
+		rawSpec
+	};
+	if (/^https?:/i.test(rawSpec) || /^[a-z][a-z0-9+.-]*:\/\//i.test(rawSpec)) return {
+		type: "remote",
+		rawSpec
+	};
+	if (semver.valid(rawSpec)) return {
+		type: "version",
+		rawSpec
+	};
+	if (semver.validRange(rawSpec)) return {
+		type: "range",
+		rawSpec
+	};
+	if (REGISTRY_TAG.test(rawSpec)) return {
+		type: "tag",
+		rawSpec
+	};
+	return {
+		type: "unsupported",
+		rawSpec
+	};
+}
+//#endregion
+export { parseDependencySpecification as t };

package/dist/ssg-config.d.ts

@@ -0,0 +1,41 @@
+//#region src/ssg/sitemap.d.ts
+type SitemapChangeFrequency = "always" | "hourly" | "daily" | "weekly" | "monthly" | "yearly" | "never";
+interface SitemapRouteConfig {
+  /** Canonical URL. Relative values resolve against siteUrl. */
+  url?: string;
+  /** W3C date/datetime or Date describing the last meaningful page update. */
+  lastModified?: string | Date;
+  changeFrequency?: SitemapChangeFrequency;
+  /** Relative crawl priority from 0 through 1. */
+  priority?: number;
+  /** hreflang to canonical URL mapping, including optional x-default. */
+  alternates?: Readonly<Record<string, string>>;
+}
+interface SitemapRouteContext {
+  path: string;
+  filePath: string;
+  status: string;
+}
+interface SitemapConfig {
+  /** Site-wide values inherited by included routes. */
+  defaults?: Omit<SitemapRouteConfig, "url" | "alternates">;
+  /** Exact concrete route overrides. Set a route to false to exclude it. */
+  routes?: Readonly<Record<string, SitemapRouteConfig | false>>;
+  /** Compute or override sitemap data. Returning false excludes the route. */
+  resolve?: (route: SitemapRouteContext) => SitemapRouteConfig | false | null | undefined | Promise<SitemapRouteConfig | false | null | undefined>;
+  /** Output path relative to the SSG output directory. */
+  output?: string;
+  /** Maintain a Sitemap directive in robots.txt. Defaults to true. */
+  robots?: boolean | {
+    output?: string;
+  };
+  /** Optional lower limits for deterministic partitioning and tests. */
+  limits?: {
+    urlsPerFile?: number;
+    bytesPerFile?: number;
+  };
+  /** Maximum concurrent async route metadata resolvers. Defaults to 16. */
+  resolverConcurrency?: number;
+}
+//#endregion
+export type { SitemapChangeFrequency, SitemapConfig, SitemapRouteConfig, SitemapRouteContext };

package/dist/ssg-config.js

@@ -0,0 +1 @@
+export {};

package/dist/ssg.d.ts

@@ -0,0 +1,61 @@
+import { existsSync } from "node:fs";
+//#region src/bin/ssg.d.ts
+type CliIo = Pick<Console, "error" | "log">;
+interface ParsedSsgArgs {
+  configPath: string;
+  outputDir: string;
+  workers: number | "auto";
+  incremental: boolean;
+  changedKeys: string[];
+  changedRoutes: string[];
+  forceFull: boolean;
+  help: boolean;
+  errors: string[];
+}
+interface RouteResult {
+  path: string;
+  filePath: string;
+  status: string;
+  error?: string;
+}
+interface GenerateResult {
+  mode: string;
+  successful: number;
+  totalRoutes: number;
+  failed: number;
+  rebuilt: number;
+  skipped: number;
+  removed: number;
+  cacheHits: number;
+  routes: RouteResult[];
+}
+interface StaticGen {
+  generate(options: ReturnType<typeof toGenerateOptions>): Promise<GenerateResult>;
+}
+interface SsgDeps {
+  cwd?: () => string;
+  now?: () => number;
+  existsSync?: typeof existsSync;
+  importConfig?: (filePath: string) => Promise<unknown>;
+  createStaticGen?: (options: {
+    routes?: unknown[];
+    registry?: unknown;
+    outputDir: string;
+    seed?: unknown;
+    dataOverrides?: unknown;
+    concurrency?: number;
+    parallelism: number | "auto";
+    document?: unknown;
+    assets?: unknown[];
+  }) => StaticGen;
+}
+declare function parseCliArgs(args: string[]): ParsedSsgArgs;
+declare function toGenerateOptions(args: ParsedSsgArgs): {
+  mode: string;
+  changedKeys: string[];
+  changedRoutes: string[];
+  forceFull: boolean;
+};
+declare function runSsgCli(args?: string[], deps?: SsgDeps, io?: CliIo): Promise<number>;
+//#endregion
+export { parseCliArgs, runSsgCli };