konpeki 0.3.0 → 0.4.0

package/runtime/konpeki.mjs

@@ -1,1434 +1,114 @@
 #!/usr/bin/env node
-import { createHash, randomBytes, randomUUID } from "node:crypto";
-import { basename, dirname, join, resolve } from "node:path";
+import { spawnSync } from "node:child_process";
+import { dirname, resolve } from "node:path";
+import { writeFile } from "node:fs/promises";
 import { fileURLToPath } from "node:url";
-import { createServer } from "vite";
-import { readFile, rename, rm, writeFile } from "node:fs/promises";
-import { Ajv2020 } from "ajv/dist/2020.js";
-import "@xmldom/xmldom";
-import lockfile from "proper-lockfile";
-//#region composition/types.ts
-var compositionSchema = "konpeki-composition/v1";
-var canvasSize = {
-	width: 1920,
-	height: 1080
-};
-var canvasPadding = {
-	top: 72,
-	right: 112,
-	bottom: 0,
-	left: 112
-};
-var authoringModes = ["default", "dynamic"];
-var themeIds = [
-	"plex",
-	"precision",
-	"editorial",
-	"blue-cyan",
-	"orange-coral",
-	"yellow",
-	"green",
-	"graphite"
-];
-var themeModes = ["paper", "night"];
-var typographyIds = [
-	"plex-sans",
-	"noto-sans",
-	"plex-serif",
-	"hanken-grotesk"
-];
-var vectorElementKinds = [
-	"g",
-	"rect",
-	"circle",
-	"ellipse",
-	"line",
-	"polyline",
-	"polygon",
-	"path",
-	"text",
-	"tspan"
-];
-var componentKinds = [
-	"text-block",
-	"chart",
-	"diagram",
-	"image",
-	"table"
-];
-//#endregion
-//#region composition/visualizations.ts
-var diagramDefinitions = {
-	architecture: {
-		label: "Architecture",
-		category: "Systems & technical structure",
-		layout: "hub-and-spoke",
-		slotRole: "entity",
-		expression: "Show system boundaries, responsibilities, interfaces, and directional communication without implying physical deployment."
-	},
-	"it-current-state": {
-		label: "IT current state",
-		category: "Systems & technical structure",
-		layout: "hub-and-spoke",
-		slotRole: "entity",
-		expression: "Show the systems that exist today, their ownership, integration paths, friction, duplication, and known constraints."
-	},
-	"high-level": {
-		label: "High-level overview",
-		category: "Systems & technical structure",
-		layout: "layered",
-		slotRole: "entity",
-		expression: "Reduce the system to a small number of named capabilities and major relationships; suppress implementation detail."
-	},
-	deployment: {
-		label: "Deployment",
-		category: "Systems & technical structure",
-		layout: "layered",
-		slotRole: "entity",
-		expression: "Place software artifacts inside the environments, hosts, zones, or runtimes where they execute and show cross-zone communication."
-	},
-	flowchart: {
-		label: "Flowchart",
-		category: "Flow, interaction & behavior",
-		layout: "branching",
-		slotRole: "process-step",
-		expression: "Distinguish actions, decisions, merge points, and start or end states; label decision branches explicitly."
-	},
-	sequence: {
-		label: "Sequence",
-		category: "Flow, interaction & behavior",
-		layout: "request-flow",
-		slotRole: "entity",
-		expression: "Order actors horizontally and messages vertically through time; distinguish calls, returns, asynchronous messages, and branches."
-	},
-	"state-machine": {
-		label: "State machine",
-		category: "Flow, interaction & behavior",
-		layout: "branching",
-		slotRole: "entity",
-		expression: "Treat nodes as legal states and edges as guarded transitions; preserve initial, terminal, retry, and invalid transition semantics."
-	},
-	swimlane: {
-		label: "Swimlane",
-		category: "Flow, interaction & behavior",
-		layout: "layered",
-		slotRole: "process-step",
-		expression: "Partition steps by responsible actor or team and make every cross-lane handoff visible."
-	},
-	process: {
-		label: "Process",
-		category: "Flow, interaction & behavior",
-		layout: "linear",
-		slotRole: "process-step",
-		expression: "Show ordered work from trigger to outcome, including branches, loops, owners, and exceptional paths when supplied."
-	},
-	"data-flow": {
-		label: "Data flow",
-		category: "Flow, interaction & behavior",
-		layout: "hub-and-spoke",
-		slotRole: "entity",
-		expression: "Show data producers, transformations, stores, and consumers; label payloads and direction independently from control flow."
-	},
-	"dp-integration": {
-		label: "Data-product integration",
-		category: "Flow, interaction & behavior",
-		layout: "request-flow",
-		slotRole: "entity",
-		expression: "Show producer and consumer responsibilities, contracts, integration boundaries, and exchange direction for each data product."
-	},
-	"er-data-model": {
-		label: "ER / data model",
-		category: "Data & software modeling",
-		layout: "hub-and-spoke",
-		slotRole: "entity",
-		expression: "Represent entities with key attributes and label relationship cardinality and optionality at both endpoints."
-	},
-	medallion: {
-		label: "Medallion",
-		category: "Data & software modeling",
-		layout: "layered",
-		slotRole: "entity",
-		expression: "Arrange data products by progressive quality tier and show transformations from raw through refined to consumption-ready data."
-	},
-	"dp-security-matrix": {
-		label: "Data-product security matrix",
-		category: "Data & software modeling",
-		layout: "layered",
-		slotRole: "entity",
-		expression: "Use rows and columns as explicit subject and resource axes; encode permissions or controls at their intersections."
-	},
-	"dependency-graph": {
-		label: "Dependency graph",
-		category: "Data & software modeling",
-		layout: "branching",
-		slotRole: "entity",
-		expression: "Preserve many-parent fan-in, shared dependencies, and cycles; orient every dependency edge consistently."
-	},
-	"uml-class": {
-		label: "UML class",
-		category: "Data & software modeling",
-		layout: "hub-and-spoke",
-		slotRole: "entity",
-		expression: "Keep class names, attributes, and operations in separate compartments and preserve inheritance, aggregation, and composition notation."
-	},
-	"database-schema": {
-		label: "Database schema",
-		category: "Data & software modeling",
-		layout: "hub-and-spoke",
-		slotRole: "entity",
-		expression: "Show tables with typed columns, keys, constraints, and column-level foreign-key endpoints."
-	},
-	nested: {
-		label: "Nested containment",
-		category: "Hierarchy, containment & organization",
-		layout: "layered",
-		slotRole: "entity",
-		expression: "Use enclosure to express scope and ownership; containment must not be replaced by proximity alone."
-	},
-	tree: {
-		label: "Tree",
-		category: "Hierarchy, containment & organization",
-		layout: "branching",
-		slotRole: "entity",
-		expression: "Show a strict one-parent hierarchy with consistent depth and sibling ordering."
-	},
-	"org-chart": {
-		label: "Org chart",
-		category: "Hierarchy, containment & organization",
-		layout: "branching",
-		slotRole: "entity",
-		expression: "Show reporting structure, role ownership, and escalation paths; do not imply technical dependency."
-	},
-	"layer-stack": {
-		label: "Layer stack",
-		category: "Hierarchy, containment & organization",
-		layout: "layered",
-		slotRole: "entity",
-		expression: "Order abstraction or responsibility layers consistently and show only legitimate cross-layer dependencies."
-	},
-	"pyramid-funnel": {
-		label: "Pyramid / funnel",
-		category: "Hierarchy, containment & organization",
-		layout: "layered",
-		slotRole: "entity",
-		expression: "Use width and vertical order to encode rank, concentration, or drop-off; state which meaning applies."
-	},
-	timeline: {
-		label: "Timeline",
-		category: "Time & work",
-		layout: "linear",
-		slotRole: "process-step",
-		expression: "Place dated events on an honest temporal axis and preserve meaningful interval differences."
-	},
-	gantt: {
-		label: "Gantt",
-		category: "Time & work",
-		layout: "layered",
-		slotRole: "process-step",
-		expression: "Encode task start, duration, overlap, milestones, dependencies, and ownership against a shared time scale."
-	},
-	kanban: {
-		label: "Kanban",
-		category: "Time & work",
-		layout: "layered",
-		slotRole: "entity",
-		expression: "Use columns as workflow states, preserve card ownership and priority, and show WIP limits when supplied."
-	},
-	"user-journey": {
-		label: "User journey",
-		category: "Time & work",
-		layout: "linear",
-		slotRole: "process-step",
-		expression: "Order experience stages and align actions, touchpoints, pain points, and sentiment to each stage."
-	},
-	"story-map": {
-		label: "Story map",
-		category: "Time & work",
-		layout: "layered",
-		slotRole: "entity",
-		expression: "Use columns for narrative activity order and rows for release slices; preserve the release-cut line."
-	},
-	quadrant: {
-		label: "Quadrant",
-		category: "Quantitative & analytical",
-		layout: "layered",
-		slotRole: "entity",
-		expression: "Position items against two named axes with meaningful scales and make quadrant interpretation explicit."
-	},
-	"loop-flywheel": {
-		label: "Loop / flywheel",
-		category: "Conceptual & strategic",
-		layout: "cyclical",
-		slotRole: "process-step",
-		expression: "Show a reinforcing cycle with explicit direction and explain how each stage increases momentum or feeds the next."
-	},
-	venn: {
-		label: "Venn",
-		category: "Conceptual & strategic",
-		layout: "hub-and-spoke",
-		slotRole: "entity",
-		expression: "Use overlapping regions to encode set membership and label every meaningful intersection."
-	},
-	fishbone: {
-		label: "Fishbone",
-		category: "Conceptual & strategic",
-		layout: "branching",
-		slotRole: "entity",
-		expression: "Group candidate causes by category along branches that converge on one clearly stated effect."
-	},
-	"wardley-map": {
-		label: "Wardley map",
-		category: "Conceptual & strategic",
-		layout: "layered",
-		slotRole: "entity",
-		expression: "Position components by user visibility and evolution, then show value-chain dependencies and movement without treating the map as runtime architecture."
-	}
-};
-var diagramTypes = Object.keys(diagramDefinitions);
-var chartTemplates = Object.keys({
-	"grouped-bar": {
-		label: "Grouped bar",
-		expression: "Compare quantitative values across categories with a shared zero baseline; use grouped series only when each category has comparable values.",
-		source: "diagram-design"
-	},
-	line: {
-		label: "Line",
-		expression: "Encode values on a shared scale and connect observations in meaningful order, usually time; preserve intervals and do not imply missing measurements.",
-		source: "diagram-design"
-	},
-	pie: {
-		label: "Pie",
-		expression: "Show a small set of mutually exclusive parts of one whole; preserve the total and label values directly when comparison by angle is difficult.",
-		source: "konpeki"
-	},
-	"annotated-detail": {
-		label: "Annotated detail",
-		expression: "Focus on one visual detail and connect concise annotations to exact evidence without obscuring the underlying image or chart.",
-		source: "konpeki"
-	},
-	radar: {
-		label: "Radar",
-		expression: "Compare multivariate profiles on consistently normalized radial axes; preserve axis order, scale, and direction across every series.",
-		source: "diagram-design"
-	},
-	treemap: {
-		label: "Treemap",
-		expression: "Encode part-to-whole magnitude by rectangle area within explicit hierarchy; preserve parent totals and avoid implying rank from position.",
-		source: "diagram-design"
-	},
-	scatter: {
-		label: "Scatter",
-		expression: "Position observations by two measured quantitative variables; preserve axis scales, units, outliers, and uncertainty about correlation.",
-		source: "diagram-design"
-	},
-	sankey: {
-		label: "Sankey",
-		expression: "Encode conserved quantity through splits and merges using proportional ribbon width; preserve node totals, flow direction, and units.",
-		source: "diagram-design"
-	}
-});
-Array.from(new Set(Object.values(diagramDefinitions).map((definition) => definition.category)));
-//#endregion
-//#region composition/theme-tokens.ts
-/** Explicit opt-in bindings. Literal SVG attributes always remain fixed. */
-var colorTokens = [
-	"ink",
-	"muted",
-	"background",
-	"surface",
-	"divider",
-	"accent",
-	"on-accent",
-	"wash"
-];
-var fontTokens = ["heading-font", "body-font"];
-function tokensForAttribute(name) {
-	return name === "font-family" ? fontTokens : [
-		"fill",
-		"stroke",
-		"color"
-	].includes(name) ? colorTokens : [];
-}
-function validThemeBinding(name, value) {
-	return typeof value !== "string" || !value.startsWith("theme:") || tokensForAttribute(name).some((token) => value === `theme:${token}`);
-}
-//#endregion
-//#region composition/schema.ts
-var literalVectorAttribute = { oneOf: [{
-	type: "string",
-	maxLength: 1e4,
-	pattern: "^(?!theme:)"
-}, { type: "number" }] };
-var alignment = [
-	"start",
-	"center",
-	"end"
-];
-var titleStyle = ["plain", "prominent"];
-var border = [
-	"none",
-	"outline",
-	"filled"
-];
-var colorScheme = [
-	"monochrome",
-	"accent-with-muted-context",
-	"categorical",
-	"sequential",
-	"status"
-];
-var emphasis = [
-	"none",
-	"primary",
-	"latest-series",
-	"exception"
-];
-var density = ["sparse", "standard"];
-var appearanceOptions = {
-	"text-block": {
-		role: [
-			"title",
-			"subtitle",
-			"body",
-			"caption",
-			"footnote"
-		],
-		alignment,
-		border,
-		layout: [
-			"single",
-			"two-column",
-			"three-column",
-			"two-plus-two",
-			"four-column",
-			"one-plus-three",
-			"three-plus-one"
-		],
-		orientation: ["horizontal", "vertical"],
-		purpose: [
-			"narrative",
-			"comparison",
-			"emphasis"
-		],
-		treatment: [
-			"plain",
-			"subtle",
-			"strong"
-		],
-		logicalOrder: [
-			"none",
-			"parallel",
-			"progressive",
-			"cyclical",
-			"general-to-specific",
-			"hierarchical"
-		],
-		titleStyle,
-		rule: [
-			"none",
-			"top",
-			"bottom"
-		]
-	},
-	chart: {
-		template: chartTemplates,
-		selection: ["auto", "explicit"],
-		border,
-		colorScheme,
-		orientation: ["horizontal", "vertical"],
-		emphasis,
-		density,
-		legend: [
-			"none",
-			"top",
-			"right",
-			"bottom"
-		]
-	},
-	diagram: {
-		type: diagramTypes,
-		selection: ["auto", "explicit"],
-		border,
-		colorScheme,
-		emphasis,
-		density
-	},
-	image: {
-		border,
-		fit: ["cover", "contain"]
-	},
-	table: {
-		header: [
-			"row",
-			"none",
-			"column",
-			"both"
-		],
-		grid: [
-			"none",
-			"rows",
-			"all"
-		],
-		border,
-		colorScheme,
-		density
-	}
-};
-var text = {
-	type: "string",
-	minLength: 1,
-	pattern: "\\S"
-};
-var string = { type: "string" };
-var enumeration = (values) => ({
-	type: "string",
-	enum: values
-});
-var object = (properties, required = Object.keys(properties)) => ({
-	type: "object",
-	properties,
-	required,
-	additionalProperties: false
-});
-var array = (items, minItems = 0) => ({
-	type: "array",
-	items,
-	minItems
-});
-var ids = {
-	...array(text, 1),
-	uniqueItems: true
-};
-var endpoint = object({
-	nodeId: text,
-	slotId: text
-}, ["nodeId"]);
-var rect = object({
-	x: {
-		type: "number",
-		minimum: 0,
-		maximum: 4096
-	},
-	y: {
-		type: "number",
-		minimum: 0,
-		maximum: 4096
-	},
-	width: {
-		type: "number",
-		exclusiveMinimum: 0,
-		maximum: 4096
-	},
-	height: {
-		type: "number",
-		exclusiveMinimum: 0,
-		maximum: 4096
-	}
-});
-var visualBase = {
-	viewBox: object({
-		x: { type: "number" },
-		y: { type: "number" },
-		width: {
-			type: "number",
-			exclusiveMinimum: 0,
-			maximum: 1e5
-		},
-		height: {
-			type: "number",
-			exclusiveMinimum: 0,
-			maximum: 1e5
-		}
-	}),
-	description: {
-		...text,
-		maxLength: 1e3
-	},
-	fit: enumeration([
-		"contain",
-		"cover",
-		"stretch"
-	])
-};
-var customVisual = { oneOf: [object({
-	format: { const: "vector" },
-	elements: {
-		...array(object({
-			id: text,
-			kind: enumeration(vectorElementKinds),
-			parentId: text,
-			attributes: {
-				type: "object",
-				maxProperties: 40,
-				properties: Object.fromEntries([
-					"fill",
-					"stroke",
-					"color",
-					"font-family"
-				].map((name) => [name, { anyOf: [literalVectorAttribute, { enum: tokensForAttribute(name).map((token) => `theme:${token}`) }] }])),
-				additionalProperties: literalVectorAttribute
-			},
-			text: {
-				type: "string",
-				maxLength: 1e4
-			}
-		}, [
-			"id",
-			"kind",
-			"attributes"
-		]), 0),
-		maxItems: 2e3
-	},
-	...visualBase
-}, [
-	"format",
-	"elements",
-	"viewBox",
-	"description"
-]), object({
-	format: { const: "svg" },
-	source: {
-		type: "string",
-		minLength: 1,
-		maxLength: 5e5,
-		pattern: "^\\s*<svg(?:\\s|>)"
-	},
-	...visualBase
-}, [
-	"format",
-	"source",
-	"viewBox",
-	"description"
-])] };
-var topology = object({
-	kind: { const: "explicit" },
-	nodes: {
-		...array(object({
-			id: text,
-			slotId: text,
-			visible: { type: "boolean" },
-			preferredRect: rect,
-			primitive: { oneOf: [object({
-				kind: { const: "shape" },
-				shape: enumeration([
-					"rectangle",
-					"rounded-rectangle",
-					"circle",
-					"line"
-				]),
-				color: enumeration([
-					"ink",
-					"muted",
-					"accent"
-				]),
-				fill: enumeration([
-					"none",
-					"solid",
-					"wash"
-				])
-			}, ["kind", "shape"]), object({
-				kind: { const: "icon" },
-				name: text,
-				style: enumeration(["outline", "filled"]),
-				color: enumeration([
-					"ink",
-					"muted",
-					"accent"
-				])
-			}, ["kind"])] }
-		}, ["id", "slotId"]), 1),
-		maxItems: 24
-	},
-	edges: {
-		...array(object({
-			from: text,
-			to: text,
-			label: {
-				...text,
-				maxLength: 120
-			}
-		}, ["from", "to"]), 0),
-		maxItems: 48
-	}
-});
-var components = componentKinds.map((kind) => {
-	const options = appearanceOptions[kind];
-	const requiredAppearance = [
-		...kind === "chart" ? ["template"] : [],
-		...kind === "text-block" ? ["role"] : [],
-		...kind === "diagram" ? ["type"] : []
-	];
-	const component = object({
-		id: text,
-		kind: { const: kind },
-		preferredRect: rect,
-		slotIds: ids,
-		intent: string,
-		customVisual,
-		...kind === "text-block" ? {
-			content: {
-				type: "string",
-				maxLength: 5e4
-			},
-			textStyle: object({
-				size: {
-					type: "number",
-					minimum: 8,
-					maximum: 240
-				},
-				weight: { enum: [
-					400,
-					500,
-					600
-				] },
-				lineHeight: {
-					type: "number",
-					minimum: 1,
-					maximum: 3
-				},
-				color: enumeration([
-					"ink",
-					"muted",
-					"accent"
-				]),
-				font: enumeration(["heading", "body"])
-			}, [])
-		} : {},
-		appearance: object(Object.fromEntries(Object.entries(options).map(([key, values]) => [key, enumeration(values)])), requiredAppearance),
-		...kind === "diagram" || kind === "chart" ? { topology } : {}
-	}, [
-		"id",
-		"kind",
-		"preferredRect",
-		"slotIds",
-		...requiredAppearance.length ? ["appearance"] : []
-	]);
-	return kind === "chart" ? {
-		...component,
-		allOf: [{
-			if: { required: ["topology"] },
-			then: { properties: { appearance: { properties: { template: { const: "sankey" } } } } }
-		}]
-	} : component;
-});
-var schema = {
-	$schema: "https://json-schema.org/draft/2020-12/schema",
-	$id: "https://vcfgdev.github.io/konpeki/composition/v1/schema.json",
-	title: compositionSchema,
-	...object({
-		schema: { const: compositionSchema },
-		title: text,
-		authoringMode: enumeration(authoringModes),
-		theme: object({
-			id: enumeration(themeIds),
-			mode: enumeration(themeModes),
-			typography: enumeration(typographyIds)
-		}, ["id", "mode"]),
-		slides: array(object({
-			id: text,
-			name: text,
-			canvas: object({
-				width: {
-					type: "integer",
-					minimum: 256,
-					maximum: 4096
-				},
-				height: {
-					type: "integer",
-					minimum: 256,
-					maximum: 4096
-				}
-			}),
-			innerPadding: object({
-				top: {
-					type: "number",
-					minimum: 0
-				},
-				right: {
-					type: "number",
-					minimum: 0
-				},
-				bottom: {
-					type: "number",
-					minimum: 0
-				},
-				left: {
-					type: "number",
-					minimum: 0
-				}
-			}),
-			pageNumber: object({
-				style: enumeration([
-					"none",
-					"01",
-					"01/02"
-				]),
-				color: enumeration([
-					"ink",
-					"muted",
-					"accent"
-				])
-			}),
-			audience: text,
-			question: text,
-			intendedViewingSize: enumeration([
-				"presentation",
-				"social",
-				"article",
-				"custom"
-			]),
-			contentSlots: array({ oneOf: [object({
-				id: text,
-				label: text,
-				required: { type: "boolean" },
-				instruction: text,
-				role: enumeration([
-					"takeaway",
-					"body",
-					"evidence",
-					"comparison-item",
-					"process-step",
-					"entity",
-					"image",
-					"table"
-				])
-			}), object({
-				id: text,
-				label: text,
-				required: { type: "boolean" },
-				instruction: text,
-				role: enumeration(["qualification", "source"]),
-				targets: ids
-			})] }, 0),
-			components: array({ oneOf: components }, 0),
-			groups: array(object({
-				id: text,
-				label: string,
-				childIds: ids
-			}, ["id", "childIds"])),
-			readingOrder: {
-				...array(object({
-					kind: enumeration(["component", "group"]),
-					id: text
-				}), 0),
-				uniqueItems: true
-			},
-			paintOrder: {
-				...array(text, 0),
-				uniqueItems: true
-			},
-			relationships: array(object({
-				id: text,
-				kind: enumeration([
-					"flows-to",
-					"qualifies",
-					"compares-with",
-					"depends-on",
-					"connects-to"
-				]),
-				direction: enumeration([
-					"forward",
-					"bidirectional",
-					"undirected"
-				]),
-				from: endpoint,
-				to: endpoint,
-				label: string
-			}, [
-				"id",
-				"kind",
-				"direction",
-				"from",
-				"to"
-			]))
-		}, [
-			"id",
-			"name",
-			"canvas",
-			"audience",
-			"question",
-			"intendedViewingSize",
-			"contentSlots",
-			"components",
-			"groups",
-			"readingOrder",
-			"paintOrder",
-			"relationships"
-		]), 1)
-	}, [
-		"schema",
-		"title",
-		"slides"
-	])
-};
-//#endregion
-//#region composition/vector.ts
-var vectorAttributeNames = /* @__PURE__ */ new Set([
-	"x",
-	"y",
-	"dx",
-	"dy",
-	"x1",
-	"y1",
-	"x2",
-	"y2",
-	"width",
-	"height",
-	"rx",
-	"ry",
-	"cx",
-	"cy",
-	"r",
-	"d",
-	"points",
-	"transform",
-	"fill",
-	"fill-opacity",
-	"stroke",
-	"stroke-width",
-	"stroke-opacity",
-	"stroke-linecap",
-	"stroke-linejoin",
-	"stroke-dasharray",
-	"opacity",
-	"font-family",
-	"font-size",
-	"font-weight",
-	"font-style",
-	"text-anchor",
-	"dominant-baseline",
-	"vector-effect"
-]);
-//#endregion
-//#region composition/validate.ts
-var structural = new Ajv2020({
-	allErrors: true,
-	strict: false
-}).compile(schema);
-function validateComposition(input) {
-	if (!structural(input)) return {
-		ok: false,
-		issues: (structural.errors ?? []).map((error) => ({
-			path: error.instancePath,
-			message: error.message ?? "Invalid value"
-		}))
-	};
-	const candidate = input;
-	const issues = [];
-	const fail = (path, message) => issues.push({
-		path,
-		message
-	});
-	const unique = (ids, path) => {
-		if (new Set(ids).size !== ids.length) fail(path, "IDs must be unique");
-	};
-	unique(candidate.slides.map((slide) => slide.id), "/slides");
-	candidate.slides.forEach((slide, slideIndex) => {
-		const base = `/slides/${slideIndex}`;
-		const padding = slide.innerPadding;
-		if (padding && (padding.left + padding.right >= slide.canvas.width || padding.top + padding.bottom >= slide.canvas.height)) fail(`${base}/innerPadding`, "Padding leaves no page content area");
-		const components = new Map(slide.components.map((item) => [item.id, item]));
-		const slots = new Set(slide.contentSlots.map((item) => item.id));
-		const groups = new Map(slide.groups.map((item) => [item.id, item]));
-		unique([...components.keys(), ...groups.keys()], `${base}/groups`);
-		unique(slide.components.map((item) => item.id), `${base}/components`);
-		unique(slide.contentSlots.map((item) => item.id), `${base}/contentSlots`);
-		unique(slide.groups.map((item) => item.id), `${base}/groups`);
-		unique(slide.relationships.map((item) => item.id), `${base}/relationships`);
-		const assigned = [];
-		for (const component of slide.components) {
-			const path = `${base}/components/${component.id}`;
-			const r = component.preferredRect;
-			if (r.x + r.width > slide.canvas.width || r.y + r.height > slide.canvas.height) fail(path, "Rectangle exceeds canvas");
-			assigned.push(...component.slotIds);
-			for (const id of component.slotIds) if (!slots.has(id)) fail(path, `Unknown slot: ${id}`);
-			if (component.customVisual) {
-				if (component.customVisual.format === "svg") {
-					const source = component.customVisual.source;
-					if (/<script\b|<foreignObject\b|<\?xml-stylesheet\b|<!DOCTYPE\b|\son[a-z]+\s*=|(?:href|src)\s*=\s*["'](?!data:|#)|url\(\s*["']?(?!data:|#)/i.test(source)) fail(path, "Custom SVG must be self-contained and cannot include scripts, foreign objects, event handlers, document declarations, or external resources");
-					const sourceViewBox = source.match(/<svg\b[^>]*\bviewBox\s*=\s*(["'])([^"']+)\1/i)?.[2]?.trim().split(/[\s,]+/).map(Number);
-					const declaredViewBox = component.customVisual.viewBox;
-					if (sourceViewBox?.length !== 4 || sourceViewBox.some((value) => !Number.isFinite(value)) || sourceViewBox[0] !== declaredViewBox.x || sourceViewBox[1] !== declaredViewBox.y || sourceViewBox[2] !== declaredViewBox.width || sourceViewBox[3] !== declaredViewBox.height) fail(path, "Custom SVG root viewBox must match the declared local viewport");
-				} else {
-					const known = /* @__PURE__ */ new Set();
-					const kinds = new Map(component.customVisual.elements.map((element) => [element.id, element.kind]));
-					for (const element of component.customVisual.elements) {
-						if (known.has(element.id)) fail(path, `Duplicate vector element ID: ${element.id}`);
-						if (element.parentId && !known.has(element.parentId)) fail(path, `Vector parent must precede its child: ${element.parentId}`);
-						const parentKind = element.parentId ? kinds.get(element.parentId) : void 0;
-						if (element.parentId && parentKind !== "g" && !(element.kind === "tspan" && (parentKind === "text" || parentKind === "tspan"))) fail(path, "Vector children require a group or a text/tspan parent for tspans");
-						if (element.kind === "tspan" && parentKind !== "text" && parentKind !== "tspan") fail(path, "Vector tspans require a text or tspan parent");
-						if (element.text !== void 0 && element.kind !== "text" && element.kind !== "tspan") fail(path, "Only vector text and tspans may contain text");
-						known.add(element.id);
-						for (const [name, value] of Object.entries(element.attributes)) {
-							if (!validThemeBinding(name, value)) fail(path, `Invalid theme binding for vector attribute: ${name}`);
-							if (!vectorAttributeNames.has(name)) fail(path, `Unsupported vector attribute: ${name}`);
-							if (typeof value === "string" && /url\s*\(|javascript:|data:/i.test(value)) fail(path, `Unsafe vector attribute value: ${name}`);
-						}
-					}
-				}
-			}
-			if (component.kind === "chart" && component.topology && component.appearance.template !== "sankey") fail(path, "Only Sankey charts may define topology");
-			if ((component.kind === "diagram" || component.kind === "chart") && component.topology) {
-				const { nodes, edges } = component.topology;
-				unique(nodes.map((node) => node.id), path);
-				unique(nodes.map((node) => node.slotId), path);
-				unique(edges.map((edge) => JSON.stringify([
-					edge.from,
-					edge.to,
-					edge.label ?? ""
-				])), path);
-				const known = new Set(nodes.map((node) => node.id));
-				if (nodes.length !== component.slotIds.length) fail(path, "Topology must represent every component slot");
-				for (const node of nodes) {
-					if (!component.slotIds.includes(node.slotId)) fail(path, "Topology slot must belong to its component");
-					const nodeRect = node.preferredRect;
-					if (nodeRect && (nodeRect.x < r.x || nodeRect.y < r.y || nodeRect.x + nodeRect.width > r.x + r.width || nodeRect.y + nodeRect.height > r.y + r.height)) fail(path, "Topology node rectangle must stay within its component");
-				}
-				for (const edge of edges) {
-					if (!known.has(edge.from) || !known.has(edge.to)) fail(path, "Unknown topology endpoint");
-					if (edge.from === edge.to) fail(path, "Topology self-edges are not supported");
-				}
-			}
-		}
-		for (const id of slots) if (!assigned.includes(id)) fail(`${base}/contentSlots`, `Unassigned content slot: ${id}`);
-		const grouped = [];
-		for (const group of slide.groups) for (const id of group.childIds) {
-			grouped.push(id);
-			if (!components.has(id)) fail(`${base}/groups`, "Groups may contain only components");
-		}
-		unique(grouped, `${base}/groups`);
-		const reading = slide.readingOrder.flatMap((entry) => {
-			if (entry.kind === "component") {
-				if (!components.has(entry.id)) fail(`${base}/readingOrder`, "Unknown component");
-				return [entry.id];
-			}
-			const group = groups.get(entry.id);
-			if (!group) fail(`${base}/readingOrder`, "Unknown group");
-			return group?.childIds ?? [];
-		});
-		for (const [path, order] of [["readingOrder", reading], ["paintOrder", slide.paintOrder]]) if (order.length !== components.size || new Set(order).size !== components.size || order.some((id) => !components.has(id))) fail(`${base}/${path}`, "Must contain every component exactly once");
-		for (const slot of slide.contentSlots) if ("targets" in slot) {
-			for (const id of slot.targets) if (!components.has(id) && !slots.has(id)) fail(`${base}/contentSlots`, "Unknown qualification/source target");
-		}
-		for (const relationship of slide.relationships) for (const endpoint of [relationship.from, relationship.to]) {
-			const component = components.get(endpoint.nodeId);
-			if (!component) fail(`${base}/relationships`, "Unknown relationship node");
-			if (endpoint.slotId && !component?.slotIds.includes(endpoint.slotId)) fail(`${base}/relationships`, "Relationship slot must belong to its endpoint");
-		}
-	});
-	return issues.length ? {
-		ok: false,
-		issues
-	} : {
-		ok: true,
-		document: input
-	};
-}
-//#endregion
-//#region composition/compile.ts
-function canonicalJSON(input) {
-	const sort = (value) => Array.isArray(value) ? value.map(sort) : value && typeof value === "object" ? Object.fromEntries(Object.entries(value).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([key, item]) => [key, sort(item)])) : value;
-	return JSON.stringify(sort(input), null, 2);
-}
-canvasPadding.left, canvasPadding.left, canvasPadding.left, canvasSize.width - canvasPadding.left - canvasPadding.right, canvasPadding.left, canvasPadding.left;
-function parseCompositionJSON(raw) {
-	try {
-		const result = validateComposition(JSON.parse(raw));
-		if (result.ok) return {
-			ok: true,
-			document: result.document
-		};
-		const issue = result.issues[0];
-		return {
-			ok: false,
-			message: `${issue?.path || "Document"}: ${issue?.message || "Invalid composition"}`
-		};
-	} catch {
-		return {
-			ok: false,
-			message: "The selected file is not valid JSON."
-		};
-	}
-}
-//#endregion
-//#region bin/session-store.ts
-function revisionFor(value) {
-	return createHash("sha256").update(value).digest("hex");
-}
-async function readCompositionFile(compositionPath) {
-	const raw = await readFile(compositionPath, "utf8");
-	const parsed = parseCompositionJSON(raw);
-	if (!parsed.ok) throw new Error(parsed.message);
-	return {
-		document: parsed.document,
-		revision: revisionFor(raw),
-		name: basename(compositionPath)
-	};
-}
-async function saveCompositionFile(compositionPath, expectedRevision, document) {
-	const validation = validateComposition(document);
-	if (!validation.ok) {
-		const issue = validation.issues[0];
-		throw Object.assign(/* @__PURE__ */ new Error(`${issue?.path || "document"} ${issue?.message || "is invalid"}`), { code: "INVALID_COMPOSITION" });
-	}
-	const currentRevision = revisionFor(await readFile(compositionPath, "utf8"));
-	if (currentRevision !== expectedRevision) throw Object.assign(/* @__PURE__ */ new Error("The composition changed outside this browser."), {
-		code: "REVISION_CONFLICT",
-		revision: currentRevision
-	});
-	const value = `${canonicalJSON(document)}\n`;
-	const temporary = join(dirname(compositionPath), `.${basename(compositionPath)}.${process.pid}.${randomBytes(6).toString("hex")}.tmp`);
-	await writeFile(temporary, value, {
-		encoding: "utf8",
-		flag: "wx"
-	});
-	try {
-		await rename(temporary, compositionPath);
-	} catch (error) {
-		await rm(temporary, { force: true });
-		throw error;
-	}
-	return { revision: revisionFor(value) };
-}
-//#endregion
-//#region src/lib/review.ts
-var emptyReview = () => ({
-	schema: "konpeki-review/v1",
-	version: 0,
-	notes: []
-});
-var activeRequest = (request) => request?.status === "submitted" || request?.status === "working";
-//#endregion
-//#region bin/review-store.ts
-var reviewFileFor = (path) => `${resolve(path)}.review.json`;
-var conflict = (message) => Object.assign(new Error(message), { code: "REVISION_CONFLICT" });
-var invalid = (message) => Object.assign(new Error(message), { code: "INVALID_REVIEW" });
-async function readReview(path) {
-	try {
-		const state = JSON.parse(await readFile(reviewFileFor(path), "utf8"));
-		if (state.schema !== "konpeki-review/v1") throw invalid("Unsupported revision-note format.");
-		return state;
-	} catch (error) {
-		if (error.code === "ENOENT") return emptyReview();
-		throw error;
-	}
-}
-async function mutate(path, change) {
-	const file = reviewFileFor(path);
-	const release = await lockfile.lock(file, {
-		realpath: false,
-		retries: {
-			retries: 60,
-			minTimeout: 100,
-			maxTimeout: 250
-		}
-	});
-	const temporary = `${file}.${randomUUID()}.tmp`;
-	try {
-		const state = await readReview(path);
-		await change(state);
-		state.version++;
-		await writeFile(temporary, `${JSON.stringify(state, null, 2)}\n`);
-		await rename(temporary, file);
-		return state;
-	} finally {
-		await rm(temporary, { force: true });
-		await release();
-	}
-}
-function validateTarget(document, target) {
-	const slide = document.slides.find((s) => s.id === target.slideId);
-	if (!slide) throw invalid("The note's page no longer exists. Remove the note and select a new target.");
-	const component = slide.components.find((c) => c.id === target.componentId);
-	if (target.componentId !== void 0 && !component) throw invalid("The note's component no longer exists. Remove the note and select a new target.");
-	if (target.elementId !== void 0 && !(component?.customVisual?.format === "vector" && component.customVisual.elements.some((e) => e.id === target.elementId))) throw invalid("The note's vector element no longer exists. Remove the note and select a new target.");
-}
-async function addRevisionNote(path, target, text) {
-	if (typeof text !== "string" || !text.trim() || text.length > 4e3) throw invalid("Write a revision note of 1–4000 characters.");
-	return mutate(path, async (state) => {
-		if (activeRequest(state.request)) throw conflict("Wait for the current request before adding notes.");
-		validateTarget((await readCompositionFile(path)).document, target);
-		state.notes.push({
-			id: randomUUID(),
-			slideId: target.slideId,
-			...target.componentId ? { componentId: target.componentId } : {},
-			...target.elementId ? { elementId: target.elementId } : {},
-			text: text.trim(),
-			resolved: false
-		});
-	});
-}
-async function removeRevisionNote(path, id) {
-	return mutate(path, (state) => {
-		if (activeRequest(state.request)) throw conflict("Wait for the current request before removing notes.");
-		state.notes = state.notes.filter((note) => note.id !== id);
-	});
-}
-async function writeBuildRequest(path, request) {
-	return mutate(path, async (state) => {
-		if (activeRequest(state.request)) throw conflict("A build request is already waiting or working.");
-		const current = await readCompositionFile(path);
-		if (current.revision !== request.revision) throw conflict("Save the latest composition before requesting a build.");
-		validateTarget(current.document, request);
-		const notes = state.notes.filter((note) => !note.resolved);
-		for (const note of notes) validateTarget(current.document, note);
-		if (typeof request.instruction !== "string" || !request.instruction.trim()) throw invalid("Describe what the agent should build.");
-		state.request = {
-			schema: "konpeki-build-request/v2",
-			id: randomUUID(),
-			compositionPath: resolve(path),
-			revision: current.revision,
-			instruction: request.instruction.trim(),
-			slideId: request.slideId,
-			...request.componentId ? { componentId: request.componentId } : {},
-			...request.elementId ? { elementId: request.elementId } : {},
-			notes,
-			status: "submitted"
-		};
-	});
-}
-async function claimBuildRequest(path) {
-	if ((await readReview(path)).request?.status !== "submitted") return;
-	let claimed;
-	await mutate(path, (state) => {
-		if (state.request?.status !== "submitted") return;
-		state.request.status = "working";
-		claimed = state.request;
-	});
-	return claimed;
-}
-async function finishBuildRequest(path, id, status, message) {
-	if (![
-		"done",
-		"needs-clarification",
-		"failed"
-	].includes(status)) throw invalid("Status must be done, needs-clarification or failed.");
-	if (status !== "done" && !message?.trim()) throw invalid("Explain what failed or needs clarification.");
-	return mutate(path, async (state) => {
-		if (state.request?.id !== id || !activeRequest(state.request)) throw conflict("This request is no longer active.");
-		if (status === "done" && state.request.status !== "working") throw conflict("Claim the request with konpeki wait before completing it.");
-		if (status === "done") {
-			state.request.resultRevision = (await readCompositionFile(path)).revision;
-			const completed = new Set(state.request.notes.map((note) => note.id));
-			state.notes = state.notes.map((note) => completed.has(note.id) ? {
-				...note,
-				resolved: true
-			} : note);
-		}
-		state.request.status = status;
-		state.request.message = message?.trim();
-	});
-}
-//#endregion
-//#region bin/session-plugin.ts
-var maximumBodyBytes = 16777216;
-var route = "/__konpeki/session";
-function sendJSON(response, status, value) {
-	response.writeHead(status, {
-		"content-type": "application/json; charset=utf-8",
-		"cache-control": "no-store"
-	});
-	response.end(JSON.stringify(value));
-}
-async function readJSON(request) {
-	let size = 0;
-	const chunks = [];
-	for await (const chunk of request) {
-		size += chunk.length;
-		if (size > maximumBodyBytes) throw Object.assign(/* @__PURE__ */ new Error("Request body is too large."), { code: "BODY_TOO_LARGE" });
-		chunks.push(chunk);
-	}
-	return JSON.parse(Buffer.concat(chunks).toString("utf8"));
-}
-function errorResponse(error) {
-	const code = error instanceof Error && "code" in error ? error.code : void 0;
-	return {
-		status: code === "REVISION_CONFLICT" ? 409 : code === "INVALID_COMPOSITION" || code === "INVALID_REVIEW" ? 422 : code === "BODY_TOO_LARGE" ? 413 : error instanceof SyntaxError ? 400 : 500,
-		body: {
-			error: error instanceof Error ? error.message : "File-session request failed.",
-			...error && typeof error === "object" && "revision" in error ? { revision: error.revision } : {}
-		}
-	};
-}
-function fileSessionPlugin({ compositionPath, token, onBuildRequest }) {
-	return {
-		name: "konpeki-file-session",
-		enforce: "pre",
-		config(config) {
-			return { server: { fs: { deny: [
-				".env",
-				".env.*",
-				"*.{crt,pem,key,p12,pfx,cer,der}",
-				".npmrc",
-				".yarnrc.yml",
-				"**/.git/**",
-				...config.server?.fs?.deny ?? [],
-				"**/*.review.json",
-				"**/*.review.json.*"
-			] } } };
-		},
-		configureServer(server) {
-			server.middlewares.use(async (request, response, next) => {
-				const url = new URL(request.url || "/", "http://localhost");
-				if (!url.pathname.startsWith(route)) return next();
-				if (request.headers["x-konpeki-session"] !== token) {
-					sendJSON(response, 403, { error: "Invalid session token." });
-					return;
-				}
-				try {
-					if (url.pathname === route && request.method === "GET") {
-						const review = await readReview(compositionPath);
-						sendJSON(response, 200, {
-							...await readCompositionFile(compositionPath),
-							review
-						});
-						return;
-					}
-					if (url.pathname === route && request.method === "PUT") {
-						const body = await readJSON(request);
-						sendJSON(response, 200, await saveCompositionFile(compositionPath, body.revision, body.document));
-						return;
-					}
-					if (url.pathname === `${route}/build` && request.method === "POST") {
-						const body = await readJSON(request);
-						if (typeof body.instruction !== "string" || !body.instruction.trim()) {
-							sendJSON(response, 400, { error: "Describe what the agent should build." });
-							return;
-						}
-						const result = await writeBuildRequest(compositionPath, body);
-						onBuildRequest?.(result);
-						sendJSON(response, 201, result);
-						return;
-					}
-					if (url.pathname === `${route}/notes` && request.method === "POST") {
-						const body = await readJSON(request);
-						sendJSON(response, 201, await addRevisionNote(compositionPath, body, body.text));
-						return;
-					}
-					if (url.pathname === `${route}/notes` && request.method === "DELETE") {
-						sendJSON(response, 200, await removeRevisionNote(compositionPath, (await readJSON(request)).id));
-						return;
-					}
-					if (url.pathname === `${route}/cancel` && request.method === "POST") {
-						sendJSON(response, 200, await finishBuildRequest(compositionPath, (await readJSON(request)).id, "failed", "Cancelled by user. Stop the agent before starting another request."));
-						return;
-					}
-					sendJSON(response, 404, { error: "Unknown file-session endpoint." });
-				} catch (error) {
-					const responseError = errorResponse(error);
-					sendJSON(response, responseError.status, responseError.body);
-				}
-			});
-		}
-	};
-}
-//#endregion
 //#region bin/konpeki.mjs
 var root = resolve(dirname(fileURLToPath(import.meta.url)), "..");
 function usage() {
 	console.error(`Usage:
-  konpeki preview <composition.json> [--host <host>] [--port <port>] [--json]
-  konpeki validate <composition.json>
-  konpeki wait <composition.json>
-  konpeki request <composition.json>
-  konpeki finish <composition.json> <request-id> [--status done|needs-clarification|failed] [--message <text>]`);
+  konpeki browser install
+  konpeki preview <document.html> [--host <host>] [--port <port>] [--json]
+  konpeki validate <document.html>
+  konpeki check <document.html>
+  konpeki inspect <document.html> [--page N] [--details]
+  konpeki render <document.html> [--page N] [--format png|pdf] [--scale 2] [--output file]
+
+Pages are one-based. Inspect and PDF include all pages unless --page is supplied.
+Scale affects PNG only. Outputs must not already exist.`);
 }
 function option(name, fallback) {
 	const index = process.argv.indexOf(name);
 	return index === -1 ? fallback : process.argv[index + 1];
 }
-async function preview(input) {
-	const compositionPath = resolve(input);
-	await readCompositionFile(compositionPath);
-	const token = randomBytes(24).toString("base64url");
-	const host = option("--host", "127.0.0.1");
-	const port = Number(option("--port", "4318"));
-	const json = process.argv.includes("--json");
-	if (!Number.isInteger(port) || port < 0 || port > 65535) throw new Error("Port must be an integer from 0 to 65535 (0 chooses a free port).");
-	const server = await createServer({
-		root,
-		configFile: resolve(root, "vite.config.ts"),
-		logLevel: json ? "silent" : "info",
-		server: {
-			host,
-			port,
-			strictPort: process.argv.includes("--port"),
-			fs: { allow: [root, ...[
-				"ibm-plex-sans",
-				"ibm-plex-serif",
-				"noto-sans",
-				"hanken-grotesk"
-			].map((font) => dirname(fileURLToPath(import.meta.resolve(`@fontsource/${font}/package.json`))))] }
-		},
-		plugins: [fileSessionPlugin({
-			compositionPath,
-			token,
-			onBuildRequest: ({ request }) => {
-				if (!request) return;
-				console.error(`\nBuild requested for ${request.compositionPath}`);
-				console.error(`Revision: ${request.revision}`);
-				console.error(`Instruction: ${request.instruction}`);
-				console.error(`Run: konpeki wait ${JSON.stringify(request.compositionPath)}\n`);
-			}
-		})]
-	});
-	try {
-		await server.listen();
-	} catch (error) {
-		await server.close();
-		throw error;
+async function html(command, input) {
+	if (!/\.html?$/i.test(input)) throw new Error("Konpeki accepts HTML documents only.");
+	if (command === "preview") {
+		const port = Number(option("--port", "4318"));
+		if (!Number.isInteger(port) || port < 0 || port > 65535) throw new Error("Port must be an integer from 0 to 65535.");
+		const { previewHTML } = await import("./server-BAqC_5WD.mjs");
+		const documentPath = resolve(input);
+		const { url } = await previewHTML(documentPath, option("--host", "127.0.0.1"), port, root, process.argv.includes("--port"));
+		console.log(process.argv.includes("--json") ? JSON.stringify({
+			type: "ready",
+			documentPath,
+			url
+		}) : `Konpeki is reviewing ${documentPath}\n${url}\nPress Ctrl+C to stop.`);
+		return;
 	}
-	const address = server.httpServer?.address();
-	const actualPort = address && typeof address === "object" ? address.port : port;
-	const displayHost = host === "0.0.0.0" || host === "::" ? "localhost" : host;
-	const url = `http://${displayHost.includes(":") ? `[${displayHost}]` : displayHost}:${actualPort}/?session=${encodeURIComponent(token)}`;
-	if (json) console.log(JSON.stringify({
-		type: "ready",
-		compositionPath,
-		url
-	}));
-	else {
-		console.log(`Konpeki is editing ${compositionPath}`);
-		console.log(url);
-		console.log(`Waiting for edits and Build it requests. Press Ctrl+C to stop.`);
+	if (command === "validate") {
+		const { fileSource } = await import("./source-CZQq9GUO.mjs");
+		const snapshot = await fileSource(resolve(input)).read();
+		console.log(`${snapshot.name}: valid (${snapshot.revision})`);
+		return;
 	}
-}
-async function validate(input) {
-	const result = await readCompositionFile(resolve(input));
-	console.log(`${result.name}: valid (${result.revision})`);
-}
-async function waitForRequest(input) {
-	console.error(`Waiting for a Build it request for ${resolve(input)}…`);
-	for (;;) {
-		const request = await claimBuildRequest(resolve(input));
-		if (request) {
-			console.log(JSON.stringify(request, null, 2));
-			return;
-		}
-		await new Promise((resolveWait) => setTimeout(resolveWait, 250));
+	if (![
+		"inspect",
+		"check",
+		"render"
+	].includes(command)) throw new Error(`Unknown command: ${command}`);
+	const { browserDocument } = await import("./browser-B-29TH1a.mjs");
+	const page = option("--page"), format = option("--format", "png");
+	const { bytes, report } = await browserDocument(resolve(input), {
+		page: page === void 0 ? void 0 : Number(page),
+		details: process.argv.includes("--details"),
+		...command === "render" ? {
+			format,
+			scale: Number(option("--scale", "2"))
+		} : {}
+	});
+	if (command === "render") {
+		for (const diagnostic of report.diagnostics) console.error(`${diagnostic.severity} ${diagnostic.code}: ${diagnostic.page}/${diagnostic.target}: ${diagnostic.message}`);
+		if (!report.ok) throw new Error("Render refused because the document has errors.");
+		const output = resolve(option("--output", input.replace(/\.html?$/i, "") + (page ? `-page-${page}` : "") + `.${format}`));
+		await writeFile(output, bytes, { flag: "wx" });
+		console.log(output);
+		const { reviewChecklist } = await import("./floor-Cmk7G3pU.mjs");
+		console.error(`Review ${output} at its viewing size and enlarged, against skills/konpeki/floor.md:\n${reviewChecklist().map((rule) => `- ${rule}`).join("\n")}`);
+	} else {
+		console.log(JSON.stringify(command === "check" ? {
+			ok: report.ok,
+			diagnostics: report.diagnostics
+		} : report, null, 2));
+		if (!report.ok) process.exitCode = 1;
 	}
 }
 var command = process.argv[2];
 var input = process.argv[3];
-if (!command || !input) {
+if (command === "browser" && input === "install") {
+	const cli = resolve(dirname(fileURLToPath(import.meta.resolve("playwright/package.json"))), "cli.js");
+	const result = spawnSync(process.execPath, [
+		cli,
+		"install",
+		"chromium"
+	], { stdio: "inherit" });
+	if (result.error) throw result.error;
+	process.exitCode = result.status ?? 1;
+} else if (!command || !input) {
 	usage();
 	process.exitCode = 1;
 } else try {
-	if (command === "preview") await preview(input);
-	else if (command === "validate") await validate(input);
-	else if (command === "wait") await waitForRequest(input);
-	else if (command === "request") console.log(JSON.stringify((await readReview(input)).request ?? null, null, 2));
-	else if (command === "finish") {
-		if (!process.argv[4]) throw new Error("Provide the request ID returned by konpeki wait.");
-		const result = await finishBuildRequest(input, process.argv[4], option("--status", "done"), option("--message"));
-		console.log(JSON.stringify(result.request, null, 2));
-	} else {
-		usage();
-		process.exitCode = 1;
-	}
+	await html(command, input);
 } catch (error) {
-	console.error(error instanceof Error ? error.message : error);
+	if (command === "check") console.log(JSON.stringify({
+		ok: false,
+		diagnostics: [{
+			code: "invalid-document",
+			severity: "error",
+			message: error instanceof Error ? error.message : String(error)
+		}]
+	}, null, 2));
+	else if (command === "inspect") console.log(JSON.stringify({
+		schema: "konpeki-html-inspection/v1",
+		ok: false,
+		pages: [],
+		diagnostics: [{
+			code: "inspection-failed",
+			severity: "error",
+			message: error instanceof Error ? error.message : String(error)
+		}]
+	}, null, 2));
+	else console.error(error instanceof Error ? error.message : error);
 	process.exitCode = 1;
 }
 //#endregion