konpeki 0.1.0

package/runtime/konpeki.mjs

@@ -0,0 +1,1685 @@
+#!/usr/bin/env node
+import { createHash, randomBytes } from "node:crypto";
+import { access, mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { basename, dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { createServer } from "vite";
+import { tmpdir } from "node:os";
+import { Ajv2020 } from "ajv/dist/2020.js";
+import "@xmldom/xmldom";
+//#region composition/types.ts
+var compositionSchema = "konpeki-composition/v18";
+var legacyCompositionSchemas = [
+	"konpeki-composition/v1",
+	"konpeki-composition/v2",
+	"konpeki-composition/v3",
+	"konpeki-composition/v4",
+	"konpeki-composition/v5",
+	"konpeki-composition/v6",
+	"konpeki-composition/v7",
+	"konpeki-composition/v8",
+	"konpeki-composition/v9",
+	"konpeki-composition/v10",
+	"konpeki-composition/v11",
+	"konpeki-composition/v12",
+	"konpeki-composition/v13",
+	"konpeki-composition/v14",
+	"konpeki-composition/v15",
+	"konpeki-composition/v16",
+	"konpeki-composition/v17"
+];
+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 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)));
+function migrateLegacyDiagramType(type, layout) {
+	if (typeof type !== "string" || typeof layout !== "string") return void 0;
+	return {
+		"process/linear": "process",
+		"process/branching": "flowchart",
+		"process/cyclical": "loop-flywheel",
+		"system/layered": "layer-stack",
+		"system/request-flow": "sequence",
+		"system/hub-and-spoke": "architecture"
+	}[`${type}/${layout}`];
+}
+//#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/v18/schema.json",
+	title: compositionSchema,
+	...object({
+		schema: { const: compositionSchema },
+		title: text,
+		authoringMode: enumeration(authoringModes),
+		theme: object({
+			id: enumeration(themeIds),
+			mode: enumeration(themeModes)
+		}),
+		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 migratePreV5Document(input) {
+	const slide = input.slide;
+	const components = Array.isArray(slide?.components) ? slide.components.map((value) => {
+		if (!value || typeof value !== "object") return value;
+		const component = value;
+		if (component.kind !== "callout" && component.kind !== "comparison" && component.kind !== "text-block") return component;
+		const previous = component.appearance && typeof component.appearance === "object" ? component.appearance : {};
+		const common = Object.fromEntries([
+			"alignment",
+			"border",
+			"titleStyle",
+			"rule"
+		].flatMap((key) => key in previous ? [[key, previous[key]]] : []));
+		const appearance = component.kind === "callout" ? {
+			...common,
+			layout: "single",
+			orientation: "horizontal",
+			purpose: "emphasis",
+			treatment: "strong"
+		} : component.kind === "comparison" ? {
+			...common,
+			layout: "two-column",
+			orientation: "horizontal",
+			purpose: "comparison",
+			treatment: "plain"
+		} : {
+			...previous,
+			purpose: previous.purpose ?? "narrative",
+			treatment: previous.treatment ?? "plain"
+		};
+		return {
+			...component,
+			kind: "text-block",
+			appearance
+		};
+	}) : slide?.components;
+	return {
+		...Object.fromEntries(Object.entries(input).filter(([key]) => key !== "target" && key !== "slide")),
+		schema: "konpeki-composition/v5",
+		...slide ? { slides: [{
+			...slide,
+			name: "Slide 01",
+			components
+		}] } : {}
+	};
+}
+function migrateV5Document(input) {
+	const slides = Array.isArray(input.slides) ? input.slides.map((value) => {
+		if (!value || typeof value !== "object") return value;
+		const slide = value;
+		const previousComponents = Array.isArray(slide.components) ? slide.components : [];
+		const pageNumber = previousComponents.find((component) => component.kind === "page-number");
+		const pageAppearance = pageNumber?.appearance && typeof pageNumber.appearance === "object" ? pageNumber.appearance : {};
+		const removedIds = new Set(previousComponents.filter((component) => component.kind === "page-number").map((component) => String(component.id)));
+		const removedSlots = new Set(previousComponents.filter((component) => component.kind === "page-number").flatMap((component) => Array.isArray(component.slotIds) ? component.slotIds.map(String) : []));
+		const components = previousComponents.flatMap((component) => {
+			const appearance = component.appearance && typeof component.appearance === "object" ? component.appearance : {};
+			if (component.kind === "page-number") return [];
+			if (component.kind === "evidence") return [{
+				...component,
+				kind: "visual"
+			}];
+			if (component.kind === "process") return [{
+				...component,
+				kind: "diagram",
+				appearance: {
+					...appearance,
+					type: "process"
+				}
+			}];
+			if (component.kind === "system-map") return [{
+				...component,
+				kind: "diagram",
+				appearance: {
+					...appearance,
+					type: "system"
+				}
+			}];
+			return [component];
+		});
+		const componentIds = new Set(components.map((component) => String(component.id)));
+		const groups = Array.isArray(slide.groups) ? slide.groups.map((group) => ({
+			...group,
+			childIds: Array.isArray(group.childIds) ? group.childIds.filter((id) => !removedIds.has(String(id))) : group.childIds
+		})).filter((group) => !Array.isArray(group.childIds) || group.childIds.length > 0) : slide.groups;
+		const groupIds = new Set(Array.isArray(groups) ? groups.map((group) => String(group.id)) : []);
+		const contentSlots = Array.isArray(slide.contentSlots) ? slide.contentSlots.filter((slot) => !removedSlots.has(String(slot.id))).map((slot) => {
+			if (!Array.isArray(slot.targets)) return slot;
+			const targets = slot.targets.filter((target) => !removedIds.has(String(target)) && !removedSlots.has(String(target)));
+			return {
+				...slot,
+				targets: targets.length ? targets : [String(components[0]?.id ?? "")]
+			};
+		}) : slide.contentSlots;
+		return {
+			...slide,
+			pageNumber: {
+				style: pageNumber ? pageAppearance.style ?? "01" : "none",
+				color: pageAppearance.color ?? "muted"
+			},
+			components,
+			contentSlots,
+			groups,
+			readingOrder: Array.isArray(slide.readingOrder) ? slide.readingOrder.filter((entry) => entry.kind === "group" ? groupIds.has(String(entry.id)) : componentIds.has(String(entry.id))) : slide.readingOrder,
+			paintOrder: Array.isArray(slide.paintOrder) ? slide.paintOrder.filter((id) => !removedIds.has(String(id))) : slide.paintOrder,
+			relationships: Array.isArray(slide.relationships) ? slide.relationships.filter((relationship) => {
+				const from = relationship.from;
+				const to = relationship.to;
+				return !removedIds.has(String(from?.nodeId)) && !removedIds.has(String(to?.nodeId));
+			}) : slide.relationships
+		};
+	}) : input.slides;
+	return {
+		...input,
+		schema: compositionSchema,
+		slides
+	};
+}
+function migrateV7Document(input) {
+	const slides = Array.isArray(input.slides) ? input.slides.map((value) => {
+		if (!value || typeof value !== "object") return value;
+		const slide = value;
+		const components = Array.isArray(slide.components) ? slide.components.map((value) => {
+			if (!value || typeof value !== "object") return value;
+			const component = value;
+			const appearance = component.appearance && typeof component.appearance === "object" ? component.appearance : {};
+			if (component.kind !== "visual" || appearance.template !== "image") return component;
+			return {
+				...component,
+				kind: "image",
+				appearance: {
+					...appearance.border ? { border: appearance.border } : {},
+					fit: "contain"
+				}
+			};
+		}) : slide.components;
+		return {
+			...slide,
+			components
+		};
+	}) : input.slides;
+	return {
+		...input,
+		schema: compositionSchema,
+		slides
+	};
+}
+function migrateV10Document(input) {
+	const slides = Array.isArray(input.slides) ? input.slides.map((value) => {
+		if (!value || typeof value !== "object") return value;
+		const slide = value;
+		const components = Array.isArray(slide.components) ? slide.components.map((value) => {
+			if (!value || typeof value !== "object") return value;
+			const component = value;
+			const appearance = component.appearance && typeof component.appearance === "object" ? component.appearance : {};
+			if (component.kind === "headline") return {
+				...component,
+				kind: "text-block",
+				appearance: {
+					...appearance,
+					role: "title",
+					layout: "single",
+					orientation: "horizontal",
+					purpose: "narrative",
+					treatment: "plain",
+					logicalOrder: "none"
+				}
+			};
+			if (component.kind === "footnote") return {
+				...component,
+				kind: "text-block",
+				appearance: {
+					...appearance,
+					role: "footnote",
+					layout: "single",
+					orientation: "horizontal",
+					purpose: "narrative",
+					treatment: "plain",
+					logicalOrder: "none",
+					titleStyle: "plain"
+				}
+			};
+			if (component.kind === "text-block") return {
+				...component,
+				appearance: {
+					role: "body",
+					...appearance
+				}
+			};
+			if (component.kind === "visual") return {
+				...component,
+				kind: "chart"
+			};
+			if (component.kind === "diagram") {
+				const { template, ...rest } = appearance;
+				return {
+					...component,
+					appearance: {
+						...rest,
+						layout: template ?? appearance.layout ?? "linear"
+					}
+				};
+			}
+			if (component.kind === "icon" || component.kind === "shape") {
+				const slotIds = Array.isArray(component.slotIds) ? component.slotIds.map(String) : [];
+				const slotId = slotIds[0] ?? `${String(component.id)}-content`;
+				const primitive = component.kind === "icon" ? {
+					kind: "icon",
+					...typeof component.intent === "string" && component.intent.trim() ? { name: component.intent.trim() } : {},
+					...appearance.style ? { style: appearance.style } : {},
+					...appearance.color ? { color: appearance.color } : {}
+				} : {
+					kind: "shape",
+					shape: appearance.shape ?? "rectangle",
+					...appearance.color ? { color: appearance.color } : {},
+					...appearance.fill ? { fill: appearance.fill } : {}
+				};
+				return {
+					...component,
+					kind: "diagram",
+					slotIds: slotIds.length ? slotIds : [slotId],
+					appearance: {
+						type: "system",
+						layout: "hub-and-spoke",
+						border: appearance.border ?? "none",
+						colorScheme: "accent-with-muted-context",
+						emphasis: "primary",
+						density: "sparse"
+					},
+					topology: {
+						kind: "explicit",
+						nodes: (slotIds.length ? slotIds : [slotId]).map((currentSlotId, index) => ({
+							id: index ? `${String(component.id)}-slot-${index + 1}` : String(component.id),
+							slotId: currentSlotId,
+							...index ? { visible: false } : { primitive },
+							...component.preferredRect && typeof component.preferredRect === "object" ? { preferredRect: component.preferredRect } : {}
+						})),
+						edges: []
+					}
+				};
+			}
+			return component;
+		}) : slide.components;
+		const contentSlots = Array.isArray(slide.contentSlots) ? slide.contentSlots.map((value) => {
+			if (!value || typeof value !== "object") return value;
+			const slot = value;
+			return slot.role === "icon" || slot.role === "shape" ? {
+				...slot,
+				role: "entity"
+			} : slot;
+		}) : slide.contentSlots;
+		return {
+			...slide,
+			components,
+			contentSlots
+		};
+	}) : input.slides;
+	return {
+		...input,
+		schema: "konpeki-composition/v11",
+		slides
+	};
+}
+function migrateV11Document(input) {
+	const slides = Array.isArray(input.slides) ? input.slides.map((value) => {
+		if (!value || typeof value !== "object") return value;
+		const slide = value;
+		const components = Array.isArray(slide.components) ? slide.components.map((value) => {
+			if (!value || typeof value !== "object") return value;
+			const component = value;
+			if (component.kind !== "diagram") return component;
+			const appearance = component.appearance && typeof component.appearance === "object" ? component.appearance : {};
+			const migratedType = migrateLegacyDiagramType(appearance.type, appearance.layout);
+			const { layout, ...rest } = appearance;
+			return {
+				...component,
+				appearance: {
+					...rest,
+					type: migratedType ?? null
+				}
+			};
+		}) : slide.components;
+		return {
+			...slide,
+			components
+		};
+	}) : input.slides;
+	return {
+		...input,
+		schema: compositionSchema,
+		slides
+	};
+}
+function migrateInterimV12Sankey(input) {
+	if (!input || typeof input !== "object") return input;
+	const document = input;
+	if (document.schema !== "konpeki-composition/v18" || !Array.isArray(document.slides)) return input;
+	const slides = document.slides.map((value) => {
+		if (!value || typeof value !== "object") return value;
+		const slide = value;
+		if (!Array.isArray(slide.components)) return value;
+		const components = slide.components.map((componentValue) => {
+			if (!componentValue || typeof componentValue !== "object") return componentValue;
+			const component = componentValue;
+			const appearance = component.appearance && typeof component.appearance === "object" ? component.appearance : {};
+			if (component.kind !== "diagram" || appearance.type !== "sankey") return componentValue;
+			const { type: _type, ...sharedAppearance } = appearance;
+			return {
+				...component,
+				kind: "chart",
+				appearance: {
+					...sharedAppearance,
+					template: "sankey"
+				}
+			};
+		});
+		return {
+			...slide,
+			components
+		};
+	});
+	return {
+		...document,
+		slides
+	};
+}
+function preserveLegacyVisualizationChoices(input) {
+	if (!input || typeof input !== "object") return input;
+	const document = input;
+	if (!Array.isArray(document.slides)) return input;
+	return {
+		...document,
+		slides: document.slides.map((value) => {
+			if (!value || typeof value !== "object") return value;
+			const slide = value;
+			if (!Array.isArray(slide.components)) return value;
+			return {
+				...slide,
+				components: slide.components.map((value) => {
+					if (!value || typeof value !== "object") return value;
+					const component = value;
+					if (component.kind !== "diagram" && component.kind !== "chart" || !component.appearance || typeof component.appearance !== "object") return value;
+					return {
+						...component,
+						appearance: {
+							...component.appearance,
+							selection: "explicit"
+						}
+					};
+				})
+			};
+		})
+	};
+}
+function validateComposition(input) {
+	const legacy = Boolean(input && typeof input === "object" && "schema" in input && legacyCompositionSchemas.includes(input.schema));
+	const legacyInput = input;
+	const normalized = migrateInterimV12Sankey(legacy ? [
+		"konpeki-composition/v12",
+		"konpeki-composition/v13",
+		"konpeki-composition/v14",
+		"konpeki-composition/v15",
+		"konpeki-composition/v16",
+		"konpeki-composition/v17"
+	].includes(String(legacyInput.schema)) ? {
+		...legacyInput,
+		schema: compositionSchema
+	} : migrateV11Document(legacyInput.schema === "konpeki-composition/v11" ? legacyInput : migrateV10Document([
+		"konpeki-composition/v6",
+		"konpeki-composition/v7",
+		"konpeki-composition/v8",
+		"konpeki-composition/v9",
+		"konpeki-composition/v10"
+	].includes(String(legacyInput.schema)) ? migrateV7Document(legacyInput) : migrateV7Document(migrateV5Document(legacyInput.schema === "konpeki-composition/v5" ? legacyInput : migratePreV5Document(legacyInput))))) : input);
+	const candidate = legacy ? preserveLegacyVisualizationChoices(normalized) : normalized;
+	if (!structural(candidate)) return {
+		ok: false,
+		issues: (structural.errors ?? []).map((error) => ({
+			path: error.instancePath,
+			message: error.message ?? "Invalid value"
+		}))
+	};
+	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: legacy ? {
+			...candidate,
+			slides: candidate.slides.map((slide) => ({
+				...slide,
+				components: slide.components.map((component) => component.kind === "text-block" && !component.customVisual && component.content === void 0 ? {
+					...component,
+					content: component.intent ?? ""
+				} : component)
+			}))
+		} : candidate
+	};
+}
+//#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");
+}
+function requestFileFor(compositionPath) {
+	const key = revisionFor(resolve(compositionPath));
+	return join(tmpdir(), "konpeki", `${key}.request.json`);
+}
+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) };
+}
+async function writeBuildRequest(compositionPath, request) {
+	const current = await readCompositionFile(compositionPath);
+	if (current.revision !== request.revision) throw Object.assign(/* @__PURE__ */ new Error("Save the latest composition before requesting a build."), {
+		code: "REVISION_CONFLICT",
+		revision: current.revision
+	});
+	const output = requestFileFor(compositionPath);
+	await mkdir(dirname(output), { recursive: true });
+	const value = {
+		schema: "konpeki-build-request/v1",
+		compositionPath: resolve(compositionPath),
+		revision: request.revision,
+		instruction: request.instruction.trim(),
+		slideId: request.slideId,
+		...request.componentId ? { componentId: request.componentId } : {},
+		createdAt: (/* @__PURE__ */ new Date()).toISOString()
+	};
+	await writeFile(output, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+	return {
+		output,
+		request: value
+	};
+}
+//#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" ? 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",
+		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") {
+						sendJSON(response, 200, await readCompositionFile(compositionPath));
+						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, { ok: true });
+						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>]
+  konpeki validate <composition.json>
+  konpeki wait <composition.json>`);
+}
+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"));
+	if (!Number.isInteger(port) || port < 1 || port > 65535) throw new Error("Port must be an integer from 1 to 65535.");
+	await rm(requestFileFor(compositionPath), { force: true });
+	const server = await createServer({
+		root,
+		configFile: resolve(root, "vite.config.ts"),
+		server: {
+			host,
+			port,
+			strictPort: true
+		},
+		plugins: [fileSessionPlugin({
+			compositionPath,
+			token,
+			onBuildRequest: ({ request }) => {
+				console.log(`\nBuild requested for ${request.compositionPath}`);
+				console.log(`Revision: ${request.revision}`);
+				console.log(`Instruction: ${request.instruction}`);
+				console.log(`Run: konpeki wait ${JSON.stringify(request.compositionPath)}\n`);
+			}
+		})]
+	});
+	await server.listen();
+	const address = server.httpServer?.address();
+	const actualPort = address && typeof address === "object" ? address.port : port;
+	const displayHost = host === "0.0.0.0" || host === "::" ? "localhost" : host;
+	console.log(`Konpeki is editing ${compositionPath}`);
+	console.log(`http://${displayHost}:${actualPort}/?session=${encodeURIComponent(token)}`);
+	console.log(`Waiting for edits and Build it requests. Press Ctrl+C to stop.`);
+}
+async function validate(input) {
+	const result = await readCompositionFile(resolve(input));
+	console.log(`${result.name}: valid (${result.revision})`);
+}
+async function waitForRequest(input) {
+	const requestPath = requestFileFor(resolve(input));
+	console.log(`Waiting for a Build it request for ${resolve(input)}…`);
+	for (;;) {
+		try {
+			await access(requestPath);
+			const value = await readFile(requestPath, "utf8");
+			await rm(requestPath, { force: true });
+			process.stdout.write(value);
+			return;
+		} catch (error) {
+			if (!(error instanceof Error) || !("code" in error) || error.code !== "ENOENT") throw error;
+		}
+		await new Promise((resolveWait) => setTimeout(resolveWait, 250));
+	}
+}
+var command = process.argv[2];
+var input = process.argv[3];
+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 {
+		usage();
+		process.exitCode = 1;
+	}
+} catch (error) {
+	console.error(error instanceof Error ? error.message : error);
+	process.exitCode = 1;
+}
+//#endregion
+export {};