@sableui/react 0.0.0-stage → 0.1.1

package/scripts/agent-setup.mjs

@@ -0,0 +1,54 @@
+import { createHash } from "node:crypto"
+import { existsSync, lstatSync, mkdirSync, readFileSync, writeFileSync } from "node:fs"
+import { dirname, join } from "node:path"
+
+const hash = content => createHash("sha256").update(content).digest("hex")
+
+/** Install discoverable loaders; the installed package owns the actual workflow. */
+export function installAgentSkill({ root, packageRoot, target = "all", update = false, dryRun = false }) {
+	const reject = (message) => { throw new Error(message) }
+	if (!["all", "codex", "claude", "cursor"].includes(target)) reject("Choose --target all, codex, claude, or cursor.")
+	if (!existsSync(join(root, "package.json"))) reject("Run setup from a project with a package.json.")
+	const canonical = join(packageRoot, "skills/sable/SKILL.md")
+	const entry = join(packageRoot, "skills/entry/SKILL.md")
+	if (!existsSync(canonical) || !existsSync(entry)) reject("The installed package is missing its skill. Reinstall Sable.")
+	const destinations = target === "all" ? [".agents/skills/sable", ".claude/skills/sable"]
+		: [target === "claude" ? ".claude/skills/sable" : ".agents/skills/sable"]
+	const receiptPath = ".sable/agent-setup.json"
+	function checkPath(path) {
+		let current = root
+		for (const part of path.split("/")) {
+			current = join(current, part)
+			try { if (lstatSync(current).isSymbolicLink()) reject(`Refusing a linked destination: ${path}`) }
+			catch (error) { if (error.code !== "ENOENT") throw error }
+		}
+	}
+	checkPath(receiptPath)
+	let receipt = { schemaVersion: 1, files: {} }
+	if (existsSync(join(root, receiptPath))) {
+		receipt = JSON.parse(readFileSync(join(root, receiptPath), "utf8"))
+		if (receipt.schemaVersion !== 1 || !receipt.files || typeof receipt.files !== "object") reject("Invalid Sable setup receipt.")
+	}
+	const files = destinations.flatMap(destination => [
+		{ path: `${destination}/SKILL.md`, content: readFileSync(entry, "utf8") },
+		...(destination.startsWith(".agents/") ? [{ path: `${destination}/agents/openai.yaml`, content: readFileSync(join(packageRoot, "skills/sable/agents/openai.yaml"), "utf8") }] : []),
+	])
+	// Preflight every host and the receipt before any writes; preserve local edits.
+	for (const file of files) {
+		checkPath(file.path)
+		if (!existsSync(join(root, file.path))) continue
+		const current = readFileSync(join(root, file.path), "utf8")
+		if (current === file.content) continue
+		if (!update || receipt.files[file.path] !== hash(current)) reject(`Existing skill differs at ${file.path}. Use --update for managed files; keep or move local edits before setup.`)
+	}
+	if (!dryRun) {
+		for (const file of files) {
+			mkdirSync(dirname(join(root, file.path)), { recursive: true })
+			writeFileSync(join(root, file.path), file.content)
+			receipt.files[file.path] = hash(file.content)
+		}
+		mkdirSync(dirname(join(root, receiptPath)), { recursive: true })
+		writeFileSync(join(root, receiptPath), JSON.stringify(receipt, null, 2) + "\n")
+	}
+	return { destination: destinations[0], destinations, files: files.map(file => file.path), dryRun, update, next: "Use $sable build <your brief> in Codex or /sable build <your brief> in Claude Code or Cursor." }
+}

package/scripts/design-atlas.mjs

@@ -0,0 +1,221 @@
+#!/usr/bin/env node
+/** Offline, evidence-backed visual references. Retrieval is lexical, not a taste score. */
+import { createHash } from "node:crypto"
+import { existsSync, readFileSync, realpathSync, statSync } from "node:fs"
+import { dirname, isAbsolute, relative, resolve, sep } from "node:path"
+import { fileURLToPath } from "node:url"
+
+const PACKAGE = resolve(dirname(fileURLToPath(import.meta.url)), "..")
+const MODES = ["persuade", "operate", "read", "experience"]
+const DESIGN = ["composition", "typography", "spacing", "color", "imagery", "motion", "interaction", "story", "responsive"]
+const ENTRY = ["id", "title", "url", "discovery", "family", "domains", "modes", "tags", "summary", "design", "appliesWhen", "avoidWhen", "transferPrinciple", "evidence"]
+const text = (value) => typeof value === "string" && value.trim().length > 0
+const object = (value) => value !== null && typeof value === "object" && !Array.isArray(value)
+const slug = (value) => typeof value === "string" && /^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(value)
+const stopwords = new Set("a an and are as at be but by for from has have in into is it of on or our that the their these this to use with website websites design designs inspiration site sites".split(" "))
+const words = (value) => [...new Set((String(value).toLowerCase().match(/[\p{L}\p{N}]+/gu) ?? []).filter((word) => !stopwords.has(word)))]
+const inside = (root, file) => {
+	const path = relative(root, file)
+	return path !== ".." && !path.startsWith(`..${sep}`) && !isAbsolute(path)
+}
+const webUrl = (value) => {
+	try { return typeof value === "string" && ["https:", "http:"].includes(new URL(value).protocol) } catch { return false }
+}
+const keys = (value, allowed, label, errors) => {
+	if (!object(value)) { errors.push(`${label} must be an object.`); return false }
+	for (const key of Object.keys(value)) if (!allowed.includes(key)) errors.push(`${label}.${key} is not a supported field.`)
+	return true
+}
+const strings = (value) => Array.isArray(value) && value.length > 0 && value.every(text) && new Set(value).size === value.length
+const portablePath = (value) => text(value) && !isAbsolute(value) && !/^[a-z]:/i.test(value) && !/[\\:\x00]/.test(value) && value.split("/").every((part) => part !== "" && part !== "." && part !== "..")
+
+/** Schema checks always run; --check additionally verifies every file and its physical containment. */
+export function validateAtlas(atlas, { root = PACKAGE, verifyEvidence = false } = {}) {
+	const errors = []
+	if (!keys(atlas, ["schemaVersion", "entries"], "atlas", errors)) return errors
+	if (atlas.schemaVersion !== 1) errors.push("atlas.schemaVersion must be 1.")
+	if (!Array.isArray(atlas.entries) || !atlas.entries.length) {
+		errors.push("atlas.entries must contain at least one reference.")
+		return errors
+	}
+	const ids = new Set()
+	for (const [index, entry] of atlas.entries.entries()) {
+		const label = `entries[${index}]`
+		if (!keys(entry, ENTRY, label, errors)) continue
+		for (const key of ["id", "family"]) if (!slug(entry[key])) errors.push(`${label}.${key} must be a lowercase hyphenated slug.`)
+		if (ids.has(entry.id)) errors.push(`${label}.id duplicates ${entry.id}.`)
+		ids.add(entry.id)
+		for (const key of ["title", "summary", "appliesWhen", "avoidWhen", "transferPrinciple"]) if (!text(entry[key])) errors.push(`${label}.${key} must describe the reference and its context.`)
+		if (!webUrl(entry.url)) errors.push(`${label}.url must be an http or https URL.`)
+		if (keys(entry.discovery, ["url", "gallery"], `${label}.discovery`, errors)) {
+			if (!webUrl(entry.discovery.url) || !text(entry.discovery.gallery)) errors.push(`${label}.discovery needs a gallery name and http or https URL.`)
+		}
+		for (const key of ["domains", "tags", "modes"]) if (!strings(entry[key])) errors.push(`${label}.${key} must be a nonempty array of unique strings.`)
+		if (Array.isArray(entry.modes) && entry.modes.some((mode) => !MODES.includes(mode))) errors.push(`${label}.modes must use ${MODES.join(", ")}.`)
+		if (keys(entry.design, DESIGN, `${label}.design`, errors)) {
+			for (const key of DESIGN) if (!text(entry.design[key])) errors.push(`${label}.design.${key} must describe an observation or explicitly say it was unobserved.`)
+		}
+		if (!Array.isArray(entry.evidence) || !entry.evidence.length) { errors.push(`${label}.evidence must contain a captured reference.`); continue }
+		const evidencePaths = new Set()
+		for (const [number, evidence] of entry.evidence.entries()) {
+			const item = `${label}.evidence[${number}]`
+			if (!keys(evidence, ["kind", "path", "sha256", "observation", "capturedAt", "viewport", "observed"], item, errors)) continue
+			if (!["desktop", "mobile", "interaction", "gallery"].includes(evidence.kind)) errors.push(`${item}.kind must be desktop, mobile, interaction, or gallery.`)
+			if (!portablePath(evidence.path)) errors.push(`${item}.path must be a portable package-relative path without traversal.`)
+			if (!/^[a-f0-9]{64}$/.test(evidence.sha256 ?? "")) errors.push(`${item}.sha256 must be a lowercase SHA-256 digest.`)
+			if (!text(evidence.observation)) errors.push(`${item}.observation must state what was actually inspected.`)
+			if (evidence.observed !== true) errors.push(`${item}.observed must be true; uninspected captures are not evidence.`)
+			if (!/^\d{4}-\d{2}-\d{2}(?:T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2}))?$/.test(evidence.capturedAt ?? "") || !Number.isFinite(Date.parse(evidence.capturedAt))) errors.push(`${item}.capturedAt must be an ISO date or timestamp.`)
+			if (keys(evidence.viewport, ["width", "height"], `${item}.viewport`, errors)) {
+				for (const dimension of ["width", "height"]) if (!Number.isSafeInteger(evidence.viewport[dimension]) || evidence.viewport[dimension] < 1) errors.push(`${item}.viewport.${dimension} must be a positive integer.`)
+			}
+			if (evidencePaths.has(evidence.path)) errors.push(`${item}.path duplicates a capture in this entry.`)
+			evidencePaths.add(evidence.path)
+			if (!verifyEvidence || !portablePath(evidence.path)) continue
+			try {
+				const physicalRoot = realpathSync(root)
+				const file = resolve(root, evidence.path)
+				if (!inside(root, file) || !inside(physicalRoot, realpathSync(file))) { errors.push(`${item}.path must physically remain inside the package (including symlinks).`); continue }
+				if (!statSync(file).isFile() || statSync(file).size === 0) { errors.push(`${item}.path must name a nonempty file.`); continue }
+				const digest = createHash("sha256").update(readFileSync(file)).digest("hex")
+				if (digest !== evidence.sha256) errors.push(`${item}.sha256 does not match the captured file.`)
+			} catch (error) { errors.push(`${item}.path cannot be read: ${error.code ?? error.message}`) }
+		}
+	}
+	return errors
+}
+
+/*
+ * Where an atlas lives. The published package ships none: its references are
+ * captures of other companies' sites, which are not ours to redistribute. A
+ * project can keep its own at `.sable/atlas/atlas.json` (evidence paths relative
+ * to the project root); a workspace checkout of Sable still has its internal one.
+ */
+export function locateAtlas({ root = PACKAGE, cwd = process.cwd() } = {}) {
+	for (const [base, file] of [[root, "llms/atlas/atlas.json"], [cwd, ".sable/atlas/atlas.json"]]) {
+		if (existsSync(resolve(base, file))) return { root: base, file }
+	}
+	return null
+}
+
+export function readAtlas({ root = PACKAGE, file = "llms/atlas/atlas.json", verifyEvidence = false } = {}) {
+	const atlas = JSON.parse(readFileSync(resolve(root, file), "utf8"))
+	return { entries: atlas.entries, errors: validateAtlas(atlas, { root, verifyEvidence }) }
+}
+
+const jaccard = (a, b) => {
+	const union = new Set([...a, ...b])
+	return union.size ? [...a].filter((term) => b.has(term)).length / union.size : 0
+}
+
+/** Context filters are hard constraints. Contrasting choices must remain positively relevant. */
+export function searchAtlas(entries, { query = "", mode, family, limit = 6, contrast = false } = {}) {
+	const terms = words(query)
+	const candidates = entries.filter((entry) => (!mode || entry.modes.includes(mode)) && (!family || entry.family === family)).map((entry) => {
+		const identity = new Set(words([entry.id, entry.title, entry.family, ...entry.domains, ...entry.modes, ...entry.tags].join(" ")))
+		const context = new Set(words(`${entry.summary} ${entry.appliesWhen} ${entry.transferPrinciple}`))
+		const design = new Set(words(Object.values(entry.design).join(" ")))
+		// Avoid-when text deliberately does not attract a reference to a use it warns against.
+		const matchedTerms = terms.filter((term) => identity.has(term) || context.has(term) || design.has(term))
+		const raw = terms.reduce((sum, term) => sum + (identity.has(term) ? 5 : context.has(term) ? 3 : design.has(term) ? 1 : 0), 0)
+		const relevance = terms.length ? raw * (matchedTerms.length / terms.length) : 1
+		return { ...entry, relevance, matchedTerms }
+	}).filter((entry) => entry.relevance > 0 && (!text(query) || terms.length > 0)).sort((a, b) => b.relevance - a.relevance || a.id.localeCompare(b.id))
+	if (!contrast || !candidates.length) return { entries: candidates.slice(0, limit), total: candidates.length }
+	const maximum = candidates[0].relevance
+	// A weak keyword coincidence is not a useful contrasting direction.
+	const remaining = candidates.filter((entry) => entry.relevance >= maximum * 0.35)
+	const selected = []
+	while (remaining.length && selected.length < limit) {
+		let best = 0
+		let bestScore = -Infinity
+		for (const [index, candidate] of remaining.entries()) {
+			const tags = new Set(candidate.tags)
+			const similarity = selected.length ? Math.max(...selected.map((entry) => (candidate.family === entry.family ? 0.75 : 0) + 0.25 * jaccard(tags, new Set(entry.tags)))) : 0
+			const score = candidate.relevance / maximum - 0.45 * similarity
+			if (score > bestScore) { best = index; bestScore = score }
+		}
+		selected.push(remaining.splice(best, 1)[0])
+	}
+	return { entries: selected, total: candidates.length }
+}
+
+const notice = "References are contextual observations, not templates or proof of usability. View the local evidence; preserve uncertainty about unobserved behavior. Retrieval is lexical and contrast favors different visual families among relevant matches."
+const brief = (entry) => ({ id: entry.id, title: entry.title, url: entry.url, family: entry.family, domains: entry.domains, modes: entry.modes, summary: entry.summary, evidenceKinds: [...new Set(entry.evidence.map((item) => item.kind))], ...(entry.relevance !== undefined ? { relevance: entry.relevance, matchedTerms: entry.matchedTerms } : {}), retrieve: `sable atlas --show ${entry.id} --json` })
+const detail = (entry, root) => ({ ...entry, evidence: entry.evidence.map((item) => ({ ...item, absolutePath: resolve(root, item.path) })) })
+
+export function runAtlas(args, { root = PACKAGE, stdout = process.stdout, stderr = process.stderr } = {}) {
+	const fail = (code, message, suggestions = []) => { stderr.write(`${JSON.stringify({ type: "error", code, message, suggestions })}\n`); return 1 }
+	const flags = new Map()
+	const values = new Set(["--search", "--show", "--mode", "--family", "--limit"])
+	const switches = new Set(["--list", "--check", "--contrast", "--json", "--help"])
+	for (let index = 0; index < args.length; index++) {
+		const flag = args[index]
+		if (!values.has(flag) && !switches.has(flag)) return fail("ERR_BAD_FLAG", `Unknown flag: ${flag}`, ["sable atlas --help"])
+		if (flags.has(flag)) return fail("ERR_BAD_FLAG", `Repeated flag: ${flag}`)
+		if (values.has(flag)) {
+			if (!text(args[index + 1]) || args[index + 1].startsWith("--")) return fail("ERR_MISSING_ARGUMENT", `${flag} needs a value.`)
+			flags.set(flag, args[++index])
+		} else flags.set(flag, true)
+	}
+	const actions = ["--list", "--search", "--show", "--check"].filter((flag) => flags.has(flag))
+	if (actions.length > 1) return fail("ERR_BAD_FLAG", "Choose one of --list, --search, --show, or --check.")
+	const modifiers = ["--mode", "--family", "--limit", "--contrast"]
+	if ((flags.has("--show") || flags.has("--check")) && modifiers.some((flag) => flags.has(flag))) return fail("ERR_BAD_FLAG", "Context filters, --limit, and --contrast apply only to listing or searching.")
+	if (flags.has("--mode") && !MODES.includes(flags.get("--mode"))) return fail("ERR_BAD_ARGUMENT", `--mode must be ${MODES.join(", ")}.`)
+	if (flags.has("--limit") && (!/^[1-9]\d*$/.test(flags.get("--limit")) || Number(flags.get("--limit")) > 100)) return fail("ERR_BAD_ARGUMENT", "--limit must be an integer from 1 to 100.")
+	if (flags.has("--help")) {
+		stdout.write("sable atlas — inspect an offline visual reference atlas\n\n  --list | --search <words> | --show <id> | --check\n  --mode persuade|operate|read|experience   filter by user activity\n  --family <slug>                          filter by visual family\n  --limit <1..100>                         default: search 6, list 100\n  --contrast                              favor relevant, different families\n  --json                                  structured { type, data } output\n\nListings are brief; --show returns all observations and absolute evidence paths.\n--check verifies schema, file hashes, and physical path containment, offline.\nNo reference is forced when a search has no relevant match.\n")
+		return 0
+	}
+	const located = locateAtlas({ root })
+	if (!located) {
+		// Not an error: no atlas is installed, so there is nothing to retrieve.
+		const data = { entries: [], total: 0, count: 0, notice: "No visual atlas is installed. The Sable package ships none; a project can add its own at .sable/atlas/atlas.json.", suggestion: "Work from the brief and the user's own references, or proceed with an original direction." }
+		if (flags.has("--json")) stdout.write(`${JSON.stringify({ type: flags.has("--check") ? "atlas.check" : "atlas.list", data }, null, 2)}
+`)
+		else stdout.write(`${data.notice}
+${data.suggestion}
+`)
+		return 0
+	}
+	root = located.root
+	try {
+		const atlas = readAtlas({ root, file: located.file, verifyEvidence: flags.has("--check") })
+		if (atlas.errors.length) return fail("ERR_ATLAS_INVALID", atlas.errors.join("\n"))
+		const families = [...new Set(atlas.entries.map((entry) => entry.family))].sort()
+		if (flags.has("--family") && !families.includes(flags.get("--family"))) return fail("ERR_UNKNOWN_FAMILY", `No visual family ${flags.get("--family")}.`, families)
+		if (flags.has("--check")) {
+			stdout.write(`${JSON.stringify({ type: "atlas.check", data: { count: atlas.entries.length, evidenceCount: atlas.entries.reduce((sum, entry) => sum + entry.evidence.length, 0), families, notice } }, null, 2)}\n`)
+			return 0
+		}
+		let found
+		if (flags.has("--show")) {
+			const entry = atlas.entries.find((item) => item.id === flags.get("--show"))
+			if (!entry) return fail("ERR_UNKNOWN_REFERENCE", `No reference ${flags.get("--show")}.`, ["sable atlas --list"])
+			// Only inspect the requested files, so retrieval remains inexpensive for a large atlas.
+			const errors = validateAtlas({ schemaVersion: 1, entries: [entry] }, { root, verifyEvidence: true })
+			if (errors.length) return fail("ERR_ATLAS_INVALID", errors.join("\n"))
+			found = { entries: [detail(entry, root)], total: 1 }
+		} else {
+			found = searchAtlas(atlas.entries, { query: flags.get("--search"), mode: flags.get("--mode"), family: flags.get("--family"), limit: Number(flags.get("--limit") ?? (flags.has("--search") ? 6 : 100)), contrast: flags.has("--contrast") })
+			found.entries = found.entries.map(brief)
+		}
+		const data = { ...found, count: found.entries.length, notice, ...(!found.entries.length ? { suggestion: "Broaden the query or filter, or proceed with an original direction; the atlas is not exhaustive." } : {}) }
+		if (flags.has("--json")) stdout.write(`${JSON.stringify({ type: flags.has("--show") ? "atlas.detail" : "atlas.list", data }, null, 2)}\n`)
+		else {
+			for (const entry of found.entries) {
+				stdout.write(`${entry.id} — ${entry.title} [${entry.family}; ${entry.modes.join(", ")}]\n  ${entry.summary}\n`)
+				if (flags.has("--show")) {
+					for (const key of DESIGN) stdout.write(`  ${key}: ${entry.design[key]}\n`)
+					stdout.write(`  Apply: ${entry.appliesWhen}\n  Avoid: ${entry.avoidWhen}\n  Transfer: ${entry.transferPrinciple}\n  Source: ${entry.url}\n  Discovered: ${entry.discovery.url}\n`)
+					for (const item of entry.evidence) stdout.write(`  Evidence (${item.kind}): ${item.absolutePath}\n    ${item.observation}\n`)
+				} else stdout.write(`  Inspect: ${entry.retrieve}\n`)
+			}
+			stdout.write(`${data.count} of ${data.total} matching reference(s). ${data.notice}\n${data.suggestion ? `${data.suggestion}\n` : ""}`)
+		}
+		return 0
+	} catch (error) { return fail("ERR_ATLAS_IO", error.message) }
+}
+
+if (process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url)) process.exitCode = runAtlas(process.argv.slice(2))

package/scripts/design-directions.mjs

@@ -0,0 +1,123 @@
+#!/usr/bin/env node
+/** Rendered art-direction comparison; declared variety is not an automated taste score. */
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs"
+import { resolve } from "node:path"
+import { fileURLToPath } from "node:url"
+import { artifactMime, hasText, inspectArtifacts, parseFlags, portablePath, projectPath, sha256, validId, validateScope } from "./design-preferences.mjs"
+
+export const AXES = ["composition", "typography", "density", "imagery", "story", "motion"]
+const STRUCTURAL = ["composition", "density", "story"]
+const normalize = (value) => String(value).trim().toLowerCase().replace(/\s+/g, " ")
+export const directionTemplate = {
+	schemaVersion: 1, id: "replace-with-exploration-id", scope: { kind: "project", value: "" },
+	brief: { prompt: "", outcome: "", audience: "", mode: "persuade", contentConstraints: [""] },
+	directions: ["direction-a", "direction-b", "direction-c"].map((id) => ({ id, title: "", axes: Object.fromEntries(AXES.map((axis) => [axis, ""])), rationale: "", artifacts: ["desktop", "mobile", "interaction"].map((kind) => ({ kind, path: "", sha256: "", description: "" })) })),
+}
+
+export function validateDirections(manifest, { root = process.cwd() } = {}) {
+	if (!manifest || typeof manifest !== "object" || Array.isArray(manifest)) return { errors: ["Exploration must be an object."], manifest: null }
+	const errors = []
+	if (manifest.schemaVersion !== 1) errors.push("schemaVersion must be 1.")
+	if (!validId(manifest.id)) errors.push("id must be a lowercase hyphenated slug of at most 80 characters.")
+	errors.push(...validateScope(manifest.scope))
+	for (const key of ["prompt", "outcome", "audience"]) if (!hasText(manifest.brief?.[key])) errors.push(`brief.${key} must state the common brief for every direction.`)
+	if (!["persuade", "operate", "read", "experience"].includes(manifest.brief?.mode)) errors.push("brief.mode must be persuade, operate, read, or experience.")
+	if (!Array.isArray(manifest.brief?.contentConstraints) || !manifest.brief.contentConstraints.length || manifest.brief.contentConstraints.some((item) => !hasText(item))) errors.push("brief.contentConstraints must name the content and functional constraints held constant across directions.")
+	const directions = Array.isArray(manifest.directions) ? manifest.directions : []
+	if (directions.length < 3 || directions.length > 6) errors.push("Render between 3 and 6 directions before comparison.")
+	const ids = directions.map((direction) => direction?.id)
+	if (ids.some((id) => !validId(id) || id === "tie") || new Set(ids).size !== ids.length) errors.push("Direction ids must be unique slugs and cannot be tie.")
+	const seen = new Set()
+	let totalBytes = 0
+	const sealed = directions.map((direction, index) => {
+		for (const key of ["title", "rationale"]) if (!hasText(direction?.[key])) errors.push(`directions[${index}].${key} is required.`)
+		for (const axis of AXES) if (!hasText(direction?.axes?.[axis])) errors.push(`directions[${index}].axes.${axis} must describe a concrete choice, including an intentional absence of motion or imagery.`)
+		for (const kind of ["desktop", "mobile", "interaction"]) if (!direction?.artifacts?.some((item) => item?.kind === kind)) errors.push(`directions[${index}] needs a ${kind} artifact.`)
+		const result = inspectArtifacts(direction?.artifacts, { root, requireHashes: true, seen, label: `directions[${index}].artifacts` })
+		errors.push(...result.errors)
+		for (const artifact of result.artifacts) totalBytes += readFileSync(projectPath(root, artifact.path)).length
+		return { id: direction?.id, title: direction?.title, axes: direction?.axes, rationale: direction?.rationale, artifacts: result.artifacts }
+	})
+	if (totalBytes > 60 * 1024 * 1024) errors.push("Combined artifacts must be at most 60 MiB; resize screenshots or shorten recordings before comparison.")
+	const diversity = []
+	for (let left = 0; left < directions.length; left++) for (let right = left + 1; right < directions.length; right++) {
+		const a = directions[left], b = directions[right]
+		const changed = AXES.filter((axis) => hasText(a?.axes?.[axis]) && hasText(b?.axes?.[axis]) && normalize(a.axes[axis]) !== normalize(b.axes[axis]))
+		const structural = changed.filter((axis) => STRUCTURAL.includes(axis))
+		if (changed.length < 2 || structural.length === 0) errors.push(`${a?.id} / ${b?.id}: vary at least two declared axes, including composition, density, or story. Palette-only variants do not demonstrate direction diversity.`)
+		diversity.push({ left: a?.id, right: b?.id, changedAxes: changed, structuralAxes: structural })
+	}
+	return { errors, manifest: { schemaVersion: 1, id: manifest.id, scope: manifest.scope, brief: manifest.brief, directions: sealed }, diversity, notice: "Checks verify declared variation and captured evidence, not perceived originality or design quality. A still interaction capture shows a state, not animation timing. Review the rendered alternatives before choosing." }
+}
+
+const escapeHtml = (value) => String(value).replace(/[&<>"']/g, (char) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[char])
+const safeJson = (value) => JSON.stringify(value).replace(/</g, "\\u003c").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029")
+
+/** Labels are deterministic for this exploration but omit titles and rationales until revealed. */
+export function comparisonOrder(manifest) {
+	return [...manifest.directions].sort((a, b) => sha256(`${manifest.id}:${a.id}`).localeCompare(sha256(`${manifest.id}:${b.id}`))).map((direction, index) => ({ label: String.fromCharCode(65 + index), direction }))
+}
+
+export function renderComparison(manifest, { root, sourcePath, sourceHash }) {
+	const order = comparisonOrder(manifest)
+	const captures = (direction, label, kind) => direction.artifacts.filter((artifact) => artifact.kind === kind).map((artifact) => {
+		const bytes = readFileSync(projectPath(root, artifact.path))
+		if (sha256(bytes) !== artifact.sha256) throw new Error(`Evidence changed while building comparison: ${artifact.path}`)
+		const mime = artifactMime(bytes)
+		const src = `data:${mime};base64,${bytes.toString("base64")}`
+		const caption = `Direction ${label} · ${kind} capture`
+		return `<figure>${mime.startsWith("video/") ? `<video controls muted playsinline preload="metadata" aria-label="${escapeHtml(caption)}"><source src="${src}" type="${mime}"></video>` : `<img src="${src}" alt="${escapeHtml(caption)}" loading="lazy">`}<figcaption>${escapeHtml(caption)}</figcaption></figure>`
+	}).join("")
+	const cards = order.map(({ label, direction }) => `<article aria-labelledby="label-${label}"><h2 id="label-${label}">Direction ${label}</h2>${captures(direction, label, "desktop")}<details><summary>Mobile and interaction evidence for ${label}</summary>${captures(direction, label, "mobile")}${captures(direction, label, "interaction")}</details></article>`).join("")
+	const rationales = order.map(({ label, direction }) => `<section><h3>${label}: ${escapeHtml(direction.title)}</h3><p>${escapeHtml(direction.rationale)}</p><dl>${AXES.map((axis) => `<dt>${axis}</dt><dd>${escapeHtml(direction.axes[axis])}</dd>`).join("")}</dl><h4>Capture notes</h4><ul>${direction.artifacts.map((artifact) => `<li>${escapeHtml(artifact.kind)}: ${escapeHtml(artifact.description)}</li>`).join("")}</ul></section>`).join("")
+	const payload = { id: manifest.id, scope: manifest.scope, brief: manifest.brief.prompt, options: order.map(({ label, direction }) => ({ label, id: direction.id, artifacts: direction.artifacts })), source: { kind: "comparison", reference: sourcePath, sha256: sourceHash } }
+	const script = `const data = JSON.parse(document.getElementById('comparison-data').textContent);
+document.getElementById('judgment').addEventListener('submit', (event) => {
+  event.preventDefault();
+  const form = event.currentTarget;
+  if (!form.reportValidity()) return;
+  const values = new FormData(form);
+  const label = values.get('choice');
+  const choice = label === 'tie' ? 'tie' : data.options.find(option => option.label === label).id;
+  const now = new Date();
+  const record = {schemaVersion:1, id:data.id.slice(0,48)+'-'+now.toISOString().replace(/[^0-9]/g,''), scope:data.scope, brief:data.brief, options:data.options.map(({label,...option})=>option), choice, reviewer:{kind:values.get('kind'),name:values.get('name').trim()}, rationale:values.get('rationale').trim(),date:now.toISOString().slice(0,10),source:data.source};
+  if (!record.reviewer.name || !record.rationale) {document.getElementById('status').textContent='Enter your name and a concrete reason before exporting.'; return;}
+  const blob = new Blob([JSON.stringify(record,null,2)+'\\n'], {type:'application/json'});
+  const url = URL.createObjectURL(blob);
+  const link = document.createElement('a'); link.href=url; link.download=record.id+'.json'; link.click();
+  setTimeout(()=>URL.revokeObjectURL(url),1000);
+  document.getElementById('status').textContent='Preference JSON downloaded. Nothing has been saved to Sable memory. Move it into the project, then run: sable prefer --record '+record.id+'.json';
+});`
+	const scriptHash = sha256(Buffer.from(script))
+	const cspHash = Buffer.from(scriptHash, "hex").toString("base64")
+	return `<!doctype html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1"><meta http-equiv="Content-Security-Policy" content="default-src 'none'; img-src data:; media-src data:; style-src 'unsafe-inline'; script-src 'sha256-${cspHash}'; form-action 'none'; base-uri 'none'"><title>Rendered direction comparison</title><style>
+:root{color-scheme:light dark;font-family:system-ui,sans-serif;background:Canvas;color:CanvasText;line-height:1.55}*{box-sizing:border-box}body{margin:0}main{max-width:1600px;margin:auto;padding:clamp(16px,4vw,56px)}h1{font-size:clamp(1.8rem,4vw,3rem);line-height:1.1;max-width:24ch}h2,h3{line-height:1.25}p,li{max-width:80ch}.comparison{display:grid;grid-template-columns:repeat(${Math.min(order.length, 3)},minmax(0,1fr));gap:24px;align-items:start;margin-block:32px}article{min-width:0}figure{margin:0 0 20px}img,video{display:block;width:100%;height:auto;border:1px solid GrayText}figcaption{font-size:.85rem;margin-top:8px;overflow-wrap:anywhere}details{border-block:1px solid GrayText;padding-block:12px;margin-block:20px}summary{cursor:pointer;padding:8px 0;font-weight:600}details section{margin-block:24px}dl{display:grid;grid-template-columns:8rem 1fr;gap:8px}dt{font-weight:600}dd{margin:0}form{max-width:760px}fieldset{padding:16px;margin:16px 0;border:1px solid GrayText}legend{font-weight:600}.choices{display:flex;flex-wrap:wrap;gap:12px}.choices label{display:flex;align-items:center;gap:8px;padding:12px;border:1px solid GrayText;cursor:pointer}label.field{display:grid;gap:8px;margin-block:20px}input,select,textarea,button{font:inherit}input,select,textarea{padding:12px;min-width:0;border:1px solid GrayText;border-radius:0;background:Field;color:FieldText}textarea{min-height:120px;resize:vertical}button{padding:12px 24px;cursor:pointer;background:ButtonFace;color:ButtonText;border:2px solid ButtonText}a:focus-visible,button:focus-visible,summary:focus-visible,input:focus-visible,select:focus-visible,textarea:focus-visible{outline:3px solid Highlight;outline-offset:4px}code{overflow-wrap:anywhere}#status{min-height:3em}.notice{border-left:3px solid GrayText;padding-left:16px}@media(max-width:900px){.comparison{grid-template-columns:1fr}article{max-width:760px}dl{grid-template-columns:1fr}dd{margin-bottom:8px}}
+</style></head><body><main><header><p>Sable · rendered exploration</p><h1>Compare the directions</h1><p>${escapeHtml(manifest.brief.prompt)}</p><p><strong>Outcome:</strong> ${escapeHtml(manifest.brief.outcome)} <strong>Audience:</strong> ${escapeHtml(manifest.brief.audience)}</p><ul>${manifest.brief.contentConstraints.map((item) => `<li>${escapeHtml(item)}</li>`).join("")}</ul><p class="notice">Review the visual evidence before revealing the rationale. Labels are stable within this comparison. Still captures show states; they do not establish animation timing or prove that an interaction works.</p></header><div class="comparison">${cards}</div><details><summary>Reveal direction names and rationale</summary>${rationales}</details><section aria-labelledby="judgment-title"><h2 id="judgment-title">Record a contextual judgment</h2><p>This choice applies to <strong>${escapeHtml(manifest.scope.kind)}: ${escapeHtml(manifest.scope.value)}</strong>. An agent decision remains an agent observation. This page downloads a record; it does not save anything to Sable automatically.</p><form id="judgment"><fieldset><legend>Which direction best serves this brief?</legend><div class="choices">${order.map(({ label }) => `<label><input type="radio" name="choice" value="${label}" required>Direction ${label}</label>`).join("")}<label><input type="radio" name="choice" value="tie" required>Tie / no preference</label></div></fieldset><label class="field">Reviewer type<select name="kind" required><option value="">Choose explicitly</option><option value="human">Human judgment</option><option value="agent">Agent observation</option></select></label><label class="field">Reviewer name<input name="name" autocomplete="name" required maxlength="200"></label><label class="field">Reason and context<textarea name="rationale" required maxlength="10000" placeholder="Explain which visible relationships serve this audience, and any tradeoff or limitation."></textarea></label><button type="submit">Download preference JSON</button><p id="status" role="status" aria-live="polite"></p></form><p>Move the downloaded JSON into your project, then run <code>sable prefer --record &lt;downloaded-file.json&gt;</code>. Original evidence paths and hashes remain bound to the project that generated this comparison.</p></section></main><script id="comparison-data" type="application/json">${safeJson(payload)}</script><script>${script}</script></body></html>`
+}
+
+function main() {
+	const flags = parseFlags(process.argv.slice(2), ["--check", "--compare"], ["--template", "--json", "--help"])
+	if (["--check", "--compare", "--template"].filter((key) => flags.has(key)).length !== 1 && !flags.has("--help")) throw new Error("Choose one action: --template, --check <file.json>, or --compare <file.json>.")
+	if (flags.has("--help")) { process.stdout.write("sable explore — compare rendered art directions\n  --template | --check <file.json> | --compare <file.json>\n  --json\nRun from the project root. Render at least three directions, changing at least two declared axes including composition, density, or story. Every direction needs desktop, mobile, and interaction evidence with SHA-256 hashes. Checks establish evidence integrity and declared variety; they cannot judge visual quality. Comparison pages are local, anonymous until rationale is revealed, and export explicitly attributed preference JSON.\n"); return }
+	if (flags.has("--template")) { process.stdout.write(`${JSON.stringify(flags.has("--json") ? { type: "explore.template", data: directionTemplate } : directionTemplate, null, 2)}\n`); return }
+	const root = process.cwd()
+	const file = projectPath(root, flags.get("--check") ?? flags.get("--compare"))
+	const result = validateDirections(JSON.parse(readFileSync(file, "utf8")), { root })
+	if (result.errors.length) throw new Error(result.errors.join("\n"))
+	if (flags.has("--check")) { process.stdout.write(`${JSON.stringify({ type: "explore.check", data: { id: result.manifest.id, directions: result.manifest.directions.length, diversity: result.diversity, notice: result.notice } }, null, 2)}\n`); return }
+	const directory = projectPath(root, ".sable/comparisons", { existing: false })
+	mkdirSync(directory, { recursive: true })
+	const sourcePath = `.sable/comparisons/${result.manifest.id}.manifest.json`
+	const manifestPath = projectPath(root, sourcePath, { existing: false })
+	const htmlPath = projectPath(root, `.sable/comparisons/${result.manifest.id}.html`, { existing: false })
+	if (existsSync(manifestPath) || existsSync(htmlPath)) throw new Error(`Comparison ${result.manifest.id} already exists. Use a new id for an iteration so previous judgments retain their evidence.`)
+	const source = `${JSON.stringify(result.manifest, null, 2)}\n`
+	const html = renderComparison(result.manifest, { root, sourcePath, sourceHash: sha256(source) })
+	writeFileSync(manifestPath, source, { flag: "wx" })
+	writeFileSync(htmlPath, html, { flag: "wx" })
+	process.stdout.write(`${JSON.stringify({ type: "explore.comparison", data: { id: result.manifest.id, path: portablePath(root, htmlPath), manifest: sourcePath, labels: comparisonOrder(result.manifest).map(({ label }) => label), notice: "Open this local HTML file. Review evidence and export a judgment with an explicit reviewer type. Nothing is inferred or saved to preference memory until sable prefer --record is run." } }, null, 2)}\n`)
+}
+
+if (process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+	try { main() } catch (error) { process.stderr.write(`${JSON.stringify({ type: "error", code: "ERR_EXPLORATION_INVALID", message: error.message })}\n`); process.exitCode = 1 }
+}

package/scripts/design-memory.mjs

@@ -0,0 +1,166 @@
+#!/usr/bin/env node
+/** Offline precedent retrieval and project-owned, evidence-linked learning. */
+import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs"
+import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path"
+import { fileURLToPath } from "node:url"
+
+const PACKAGE = resolve(dirname(fileURLToPath(import.meta.url)), "..")
+const text = (value) => typeof value === "string" && value.trim().length > 0
+const words = (value) => String(value).toLowerCase().match(/[a-z0-9]+/g) ?? []
+const inside = (root, file) => {
+	const rel = relative(root, file)
+	return rel !== ".." && !rel.startsWith(`..${sep}`) && !isAbsolute(rel)
+}
+
+export function validateLesson(lesson, { root, bundled = false } = {}) {
+	const errors = []
+	if (!lesson || typeof lesson !== "object" || Array.isArray(lesson)) return ["Lesson must be an object."]
+	if (lesson.schemaVersion !== 1) errors.push("schemaVersion must be 1.")
+	if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(lesson.id ?? "")) errors.push("id must be a lowercase hyphenated slug.")
+	for (const key of ["title", "principle", "appliesWhen", "avoidWhen"]) {
+		if (!text(lesson[key])) errors.push(`${key} must describe a concrete decision.`)
+	}
+	if (!Array.isArray(lesson.tags) || !lesson.tags.length || lesson.tags.some((tag) => !text(tag))) errors.push("tags must contain searchable terms.")
+	if (!["page", "workspace", "either"].includes(lesson.register)) errors.push("register must be page, workspace, or either.")
+	if (!["persuade", "operate", "read", "experience", "either"].includes(lesson.mode)) errors.push("mode must be persuade, operate, read, experience, or either.")
+	if (!text(lesson.provenance?.source) || !text(lesson.provenance?.date)) errors.push("provenance needs a source description and date.")
+	if (lesson.provenance?.kind !== (bundled ? "curated-precedent" : "build-review")) errors.push(`provenance.kind must be ${bundled ? "curated-precedent" : "build-review"}.`)
+	if (!bundled && (!text(lesson.provenance?.reviewer) || !text(lesson.provenance?.sableVersion))) errors.push("Build provenance needs reviewer and sableVersion.")
+	if (!bundled && (!text(lesson.change?.before) || !text(lesson.change?.after))) errors.push("change must describe the observed before state and resulting after state.")
+	const evidence = Array.isArray(lesson.evidence) ? lesson.evidence : []
+	if (!evidence.length) errors.push("evidence must contain artifact references.")
+	if (!bundled) {
+		for (const kind of ["before", "after"]) if (!evidence.some((item) => item.kind === kind)) errors.push(`Evidence needs a ${kind} artifact.`)
+	}
+	for (const [index, item] of evidence.entries()) {
+		if (!item || !text(item.path) || !text(item.observation)) {
+			errors.push(`evidence[${index}] needs path and observation.`)
+			continue
+		}
+		if (!(bundled ? ["source"] : ["before", "after"]).includes(item.kind)) errors.push(`evidence[${index}] has an invalid kind.`)
+		if (!root) continue
+		const file = resolve(root, item.path)
+		if (!inside(root, file)) errors.push(`evidence[${index}] must stay inside the project.`)
+		else if (!existsSync(file) || !statSync(file).isFile() || statSync(file).size === 0) errors.push(`evidence[${index}] is missing or empty: ${item.path}`)
+	}
+	if (!bundled) {
+		const normalize = (path) => root && text(path) ? resolve(root, path) : path
+		const before = new Set(evidence.filter((item) => item?.kind === "before").map((item) => normalize(item.path)))
+		if (evidence.some((item) => item?.kind === "after" && before.has(normalize(item.path)))) errors.push("Before and after must reference different artifacts.")
+	}
+	return errors
+}
+
+export function readLessons(root = process.cwd()) {
+	const catalog = JSON.parse(readFileSync(join(PACKAGE, "llms", "taste", "lessons.json"), "utf8"))
+	const lessons = catalog.lessons.map((lesson) => ({ ...lesson, origin: "bundled", confidence: "precedent", retrieve: `sable docs ${lesson.id}` }))
+	const errors = []
+	for (const lesson of lessons) errors.push(...validateLesson(lesson, { root: PACKAGE, bundled: true }).map((error) => `${lesson.id}: ${error}`))
+	const local = join(root, ".sable", "lessons")
+	if (existsSync(local)) {
+		for (const name of readdirSync(local).filter((name) => name.endsWith(".json")).sort()) {
+			try {
+				const lesson = JSON.parse(readFileSync(join(local, name), "utf8"))
+				const failures = validateLesson(lesson, { root })
+				if (failures.length) errors.push(...failures.map((error) => `${name}: ${error}`))
+				else lessons.push({ ...lesson, origin: "project", confidence: "provisional" })
+			} catch (error) { errors.push(`${name}: ${error.message}`) }
+		}
+	}
+	const ids = lessons.map((lesson) => lesson.id)
+	if (new Set(ids).size !== ids.length) errors.push("Lesson ids must be unique across bundled and project memory.")
+	return { lessons, errors }
+}
+
+export function searchLessons(lessons, query = "") {
+	const terms = [...new Set(words(query))]
+	if (!terms.length) return lessons
+	return lessons.map((lesson) => {
+		const tags = new Set(words([lesson.id, lesson.title, ...lesson.tags, lesson.register, lesson.mode].join(" ")))
+		const body = new Set(words(`${lesson.appliesWhen} ${lesson.avoidWhen} ${lesson.principle}`))
+		const score = terms.reduce((sum, term) => sum + (tags.has(term) ? 4 : body.has(term) ? 1 : 0), 0)
+		return { ...lesson, relevance: score }
+	}).filter((lesson) => lesson.relevance > 0).sort((a, b) => b.relevance - a.relevance || a.id.localeCompare(b.id))
+}
+
+const template = {
+	schemaVersion: 1,
+	id: "replace-with-specific-lesson",
+	title: "",
+	tags: [],
+	register: "page",
+	mode: "operate",
+	principle: "",
+	appliesWhen: "",
+	avoidWhen: "",
+	change: { before: "", after: "" },
+	provenance: { kind: "build-review", source: "", date: "", reviewer: "", sableVersion: "" },
+	evidence: [{ kind: "before", path: "", observation: "" }, { kind: "after", path: "", observation: "" }],
+}
+
+function main() {
+	const args = process.argv.slice(2)
+	const flags = new Map()
+	const values = new Set(["--search", "--show", "--record"])
+	const switches = new Set(["--list", "--template", "--check", "--json", "--help"])
+	const fail = (code, message) => {
+		process.stderr.write(`${JSON.stringify({ type: "error", code, message })}\n`)
+		process.exitCode = 1
+	}
+	for (let index = 0; index < args.length; index++) {
+		const arg = args[index]
+		if (values.has(arg)) {
+			if (!args[index + 1] || args[index + 1].startsWith("--")) return fail("ERR_MISSING_ARGUMENT", `${arg} needs a value.`)
+			flags.set(arg, args[++index])
+		} else if (switches.has(arg)) flags.set(arg, true)
+		else return fail("ERR_BAD_FLAG", `Unknown flag: ${arg}`)
+	}
+	const actions = ["--list", "--search", "--show", "--record", "--template", "--check"].filter((flag) => flags.has(flag))
+	if (actions.length > 1) return fail("ERR_BAD_FLAG", "Choose one of --list, --search, --show, --record, --template, --check.")
+	if (flags.has("--help")) {
+		process.stdout.write("sable learn — retrieve precedents and record project-owned lessons\n\n  --list | --search <words> | --show <id> | --template | --record <lesson.json> | --check\n  --json   structured { type, data } output\n\nRun from the project root. Evidence paths are relative to that root. Records are provisional reviewer observations, never automatic proof of taste.\n")
+		return
+	}
+	if (flags.has("--template")) {
+		process.stdout.write(`${JSON.stringify(template, null, 2)}\n`)
+		return
+	}
+	const root = process.cwd()
+	const memory = readLessons(root)
+	if (memory.errors.length) return fail("ERR_LESSON_INVALID", memory.errors.join("\n"))
+	if (flags.has("--record")) {
+		const lesson = JSON.parse(readFileSync(resolve(root, flags.get("--record")), "utf8"))
+		const errors = validateLesson(lesson, { root })
+		if (errors.length) return fail("ERR_LESSON_INVALID", errors.join("\n"))
+		if (memory.lessons.some((existing) => existing.id === lesson.id)) return fail("ERR_LESSON_EXISTS", `The id ${lesson.id} already exists. Reuse its lesson, or record a distinct decision under a new id.`)
+		const directory = join(root, ".sable", "lessons")
+		mkdirSync(directory, { recursive: true })
+		const path = join(directory, `${lesson.id}.json`)
+		const recorded = { ...lesson, confidence: "provisional", evidence: lesson.evidence.map((item) => ({ ...item, path: relative(root, resolve(root, item.path)).split(sep).join("/") })) }
+		writeFileSync(path, `${JSON.stringify(recorded, null, 2)}\n`, { flag: "wx" })
+		process.stdout.write(`${JSON.stringify({ type: "learn.recorded", data: { id: lesson.id, path: relative(root, path), confidence: "provisional" } }, null, 2)}\n`)
+		return
+	}
+	let lessons = searchLessons(memory.lessons, flags.get("--search"))
+	if (flags.has("--show")) {
+		lessons = lessons.filter((lesson) => lesson.id === flags.get("--show"))
+		if (!lessons.length) return fail("ERR_UNKNOWN_LESSON", `No lesson ${flags.get("--show")}. Use sable learn --list.`)
+	}
+	const type = flags.has("--check") ? "learn.check" : flags.has("--show") ? "learn.detail" : "learn.list"
+	const data = { count: lessons.length, lessons, notice: "Precedents guide decisions; they are conditional and do not replace visual review. Local records remain provisional." }
+	if (flags.has("--json") || flags.has("--check")) process.stdout.write(`${JSON.stringify({ type, data }, null, 2)}\n`)
+	else {
+		for (const lesson of lessons) {
+			process.stdout.write(`${lesson.id} — ${lesson.title} [${lesson.origin}; ${lesson.confidence}]\n  Apply: ${lesson.appliesWhen}\n  Avoid: ${lesson.avoidWhen}\n`)
+			if (flags.has("--show")) process.stdout.write(`  Principle: ${lesson.principle}\n  Evidence: ${JSON.stringify(lesson.evidence)}\n`)
+		}
+		process.stdout.write(`${lessons.length} lesson(s). ${data.notice}\n`)
+	}
+}
+
+if (process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+	try { main() } catch (error) {
+		process.stderr.write(`${JSON.stringify({ type: "error", code: "ERR_LESSON_IO", message: error.message })}\n`)
+		process.exitCode = 1
+	}
+}