@iowarp/clio-coder 0.3.0 → 0.3.2

package/src/domains/agents/spec.ts

@@ -0,0 +1,371 @@
+import { createHash } from "node:crypto";
+import { type BuiltinToolName, isBuiltinToolName, type ToolName, ToolNames } from "../../core/tool-names.js";
+import { type ActionClass, classify } from "../safety/action-classifier.js";
+import type { AgentBudget, AgentRecipe, AgentToolRequirement } from "./recipe.js";
+import type { ResultContract } from "./result-contract.js";
+
+export type AgentCategory =
+	| "explore"
+	| "plan"
+	| "research"
+	| "implement"
+	| "quality"
+	| "science"
+	| "evolution"
+	| "operations"
+	| "internal";
+
+export type AgentCapabilityClass =
+	| "read-only"
+	| "artifact-write"
+	| "workspace-edit"
+	| "verification"
+	| "orchestration"
+	| "internal";
+
+/** Authority classes a bounded coordinator plan may grant to agent automation. */
+export const AGENT_AUTOMATION_AUTHORITIES = ["read-only", "verification", "artifact-write", "workspace-edit"] as const;
+export type AgentAutomationAuthority = (typeof AGENT_AUTOMATION_AUTHORITIES)[number];
+
+export type AgentLatencyClass = "fast" | "balanced" | "deep";
+
+/**
+ * How much durable project context a worker run receives as a dynamic prompt
+ * message: "bounded" is the capped name/conventions/invariants projection,
+ * "none" is nothing. Defaults derive from the capability class so read-only
+ * scouts never pay the CLIO-CODER.md read; recipe frontmatter may override.
+ */
+export type AgentProjectContextTier = "none" | "bounded";
+
+export type AgentAudience = "base" | "shadow" | "custom" | "internal";
+
+/**
+ * What a run delivers, which is what decides the shape of its reserve window.
+ * The reserve ends discovery, not the run's own product, so the delivery tools
+ * a run keeps inside it depend on what it is producing. An "orientation" run
+ * delivers a description of a codebase, so `code_nav` is a delivery tool for it
+ * the way `write` and `edit` are for a run that delivers files.
+ *
+ * Closed on purpose: it widens the reserve admission set, so an unrecognized
+ * value must be a loud parse error rather than a silent degrade back to the
+ * default set. `product: orientaton` in a recipe would otherwise cost the run
+ * its navigation tool with no diagnostic anywhere.
+ */
+export type AgentProduct = "orientation";
+
+const AGENT_PRODUCTS: ReadonlyArray<AgentProduct> = ["orientation"];
+
+const AGENT_CATEGORIES: ReadonlyArray<AgentCategory> = [
+	"explore",
+	"plan",
+	"research",
+	"implement",
+	"quality",
+	"science",
+	"evolution",
+	"operations",
+	"internal",
+];
+
+const AGENT_CAPABILITY_CLASSES: ReadonlyArray<AgentCapabilityClass> = [
+	"read-only",
+	"artifact-write",
+	"workspace-edit",
+	"verification",
+	"orchestration",
+	"internal",
+];
+
+const AGENT_LATENCY_CLASSES: ReadonlyArray<AgentLatencyClass> = ["fast", "balanced", "deep"];
+
+const AGENT_AUDIENCES: ReadonlyArray<AgentAudience> = ["base", "shadow", "custom", "internal"];
+
+const AGENT_PROJECT_CONTEXT_TIERS: ReadonlyArray<AgentProjectContextTier> = ["none", "bounded"];
+
+export interface AgentToolRequirements {
+	required: ReadonlyArray<ToolName | { anyOf: ReadonlyArray<ToolName> }>;
+	optional: ReadonlyArray<ToolName>;
+}
+
+export interface AgentSpec {
+	version: 1;
+	id: string;
+	name: string;
+	description: string;
+	source: AgentRecipe["source"] | "custom";
+	filepath: string;
+	tools: ReadonlyArray<ToolName>;
+	toolRequirements: AgentToolRequirements;
+	category: AgentCategory;
+	capabilityClass: AgentCapabilityClass;
+	latencyClass: AgentLatencyClass;
+	projectContextTier: AgentProjectContextTier;
+	audience: AgentAudience;
+	tags: ReadonlyArray<string>;
+	skills: ReadonlyArray<string>;
+	resultContract: ResultContract;
+	product?: AgentProduct;
+	budget: AgentBudget;
+	body: string;
+}
+
+function includes<T extends string>(values: ReadonlyArray<T>, value: unknown): value is T {
+	return typeof value === "string" && (values as ReadonlyArray<string>).includes(value);
+}
+
+export function isAgentCategory(value: unknown): value is AgentCategory {
+	return includes(AGENT_CATEGORIES, value);
+}
+
+export function isAgentCapabilityClass(value: unknown): value is AgentCapabilityClass {
+	return includes(AGENT_CAPABILITY_CLASSES, value);
+}
+
+export function isAgentLatencyClass(value: unknown): value is AgentLatencyClass {
+	return includes(AGENT_LATENCY_CLASSES, value);
+}
+
+export function isAgentAudience(value: unknown): value is AgentAudience {
+	return includes(AGENT_AUDIENCES, value);
+}
+
+export function isAgentProjectContextTier(value: unknown): value is AgentProjectContextTier {
+	return includes(AGENT_PROJECT_CONTEXT_TIERS, value);
+}
+
+export function isAgentProduct(value: unknown): value is AgentProduct {
+	return includes(AGENT_PRODUCTS, value);
+}
+
+/**
+ * Default tier per capability class. Reproduces the historical dispatch
+ * allowlist byte-for-byte: workers that act on the workspace get the bounded
+ * projection; read-only, orchestration, and internal classes get none.
+ */
+export function defaultProjectContextTier(capability: AgentCapabilityClass): AgentProjectContextTier {
+	return capability === "workspace-edit" || capability === "verification" || capability === "artifact-write"
+		? "bounded"
+		: "none";
+}
+
+function actionClassesForTools(tools: ReadonlyArray<ToolName>): ReadonlySet<ActionClass> {
+	const actions = new Set<ActionClass>();
+	for (const tool of tools) actions.add(classify({ tool }).actionClass);
+	return actions;
+}
+
+function normalizeTools(recipe: AgentRecipe): ReadonlyArray<ToolName> {
+	const seen = new Set<string>();
+	const tools: ToolName[] = [];
+	for (const tool of recipe.tools) {
+		if (typeof tool !== "string" || tool.trim().length === 0) {
+			throw new Error(`agent recipe '${recipe.id}' declares an invalid tool name`);
+		}
+		if (seen.has(tool)) continue;
+		seen.add(tool);
+		tools.push(isBuiltinToolName(tool as ToolName) ? (tool as BuiltinToolName) : (tool as ToolName));
+	}
+	return tools;
+}
+
+function asToolName(tool: string): ToolName {
+	return isBuiltinToolName(tool as ToolName) ? (tool as BuiltinToolName) : (tool as ToolName);
+}
+
+function normalizeToolRequirements(recipe: AgentRecipe, tools: ReadonlyArray<ToolName>): AgentToolRequirements {
+	if (!recipe.toolRequirements) {
+		throw new Error(`agent recipe '${recipe.id}' must declare tools.required and tools.optional`);
+	}
+	const declared = new Set(tools);
+	const required = recipe.toolRequirements.required.map((requirement: AgentToolRequirement, index) => {
+		if (typeof requirement === "string") return asToolName(requirement);
+		if (!Array.isArray(requirement.anyOf) || requirement.anyOf.length === 0) {
+			throw new Error(`agent recipe '${recipe.id}' tools.required[${index}].anyOf must be non-empty`);
+		}
+		return { anyOf: requirement.anyOf.map(asToolName) };
+	});
+	const optional = recipe.toolRequirements.optional.map(asToolName);
+	const mentioned = required.flatMap((requirement) =>
+		typeof requirement === "string" ? [requirement] : requirement.anyOf,
+	);
+	for (const tool of [...mentioned, ...optional]) {
+		if (!declared.has(tool)) throw new Error(`agent recipe '${recipe.id}' requirement '${tool}' is not declared`);
+	}
+	if (new Set([...mentioned, ...optional]).size !== mentioned.length + optional.length) {
+		throw new Error(`agent recipe '${recipe.id}' contains duplicate tool requirements`);
+	}
+	if (new Set([...mentioned, ...optional]).size !== tools.length) {
+		throw new Error(`agent recipe '${recipe.id}' has declared tools without required/optional semantics`);
+	}
+	return { required, optional };
+}
+
+export interface AgentToolCompatibility {
+	compatible: boolean;
+	missingRequired: ReadonlyArray<string>;
+	lostOptional: ReadonlyArray<ToolName>;
+}
+
+export function resolveAgentToolCompatibility(
+	spec: Pick<AgentSpec, "toolRequirements">,
+	effectiveTools: ReadonlyArray<ToolName>,
+	options: { mediatesDispatch: boolean },
+): AgentToolCompatibility {
+	const available = new Set(effectiveTools);
+	const missingRequired: string[] = [];
+	for (const requirement of spec.toolRequirements.required) {
+		if (typeof requirement === "string") {
+			if (!available.has(requirement)) missingRequired.push(requirement);
+			continue;
+		}
+		if (!requirement.anyOf.some((tool) => available.has(tool))) {
+			missingRequired.push(`anyOf(${requirement.anyOf.join("|")})`);
+		}
+	}
+	if (available.has(ToolNames.Dispatch) && !options.mediatesDispatch) {
+		missingRequired.push("dispatch(runtime mediation unavailable)");
+	}
+	return {
+		compatible: missingRequired.length === 0,
+		missingRequired,
+		lostOptional: spec.toolRequirements.optional.filter((tool) => !available.has(tool)),
+	};
+}
+
+export function normalizeAgentSpec(recipe: AgentRecipe): AgentSpec {
+	const tools = normalizeTools(recipe);
+	const toolRequirements = normalizeToolRequirements(recipe, tools);
+	return {
+		version: recipe.version,
+		id: recipe.id,
+		name: recipe.name,
+		description: recipe.description,
+		source: recipe.source,
+		filepath: recipe.filepath,
+		tools,
+		toolRequirements,
+		category: recipe.category,
+		capabilityClass: recipe.capabilityClass,
+		latencyClass: recipe.latencyClass,
+		projectContextTier: recipe.projectContextTier,
+		audience: recipe.audience,
+		tags: recipe.tags,
+		skills: recipe.skills,
+		resultContract: recipe.resultContract,
+		...(recipe.product !== undefined ? { product: recipe.product } : {}),
+		budget: recipe.budget,
+		body: recipe.body,
+	};
+}
+
+/**
+ * Stable identity of everything about a recipe that changes what a route means.
+ *
+ * Route statistics are only comparable when they were produced by the same
+ * agent. A Coder run under a reviewer persona, a Coder whose declared tools
+ * changed, and a Coder whose body was rewritten are three different things to
+ * aggregate, so each gets a different fingerprint. Display-only metadata
+ * (name, description, category, filepath, source, tags) is excluded: display
+ * metadata edits must not invalidate measured history.
+ */
+export function agentSpecFingerprint(spec: AgentSpec): string {
+	const requirement = (entry: AgentToolRequirement): string =>
+		typeof entry === "string" ? entry : `anyOf(${[...entry.anyOf].sort().join("|")})`;
+	const payload = JSON.stringify({
+		id: spec.id,
+		tools: [...spec.tools].sort(),
+		required: spec.toolRequirements.required.map(requirement).sort(),
+		optional: [...spec.toolRequirements.optional].sort(),
+		capabilityClass: spec.capabilityClass,
+		latencyClass: spec.latencyClass,
+		projectContextTier: spec.projectContextTier,
+		audience: spec.audience,
+		skills: [...spec.skills].sort(),
+		resultContract: spec.resultContract,
+		budget: spec.budget,
+		body: createHash("sha256").update(spec.body, "utf8").digest("hex"),
+	});
+	return createHash("sha256").update(payload, "utf8").digest("hex");
+}
+
+export function isUserVisibleAgent(spec: AgentSpec): boolean {
+	return spec.audience === "base" || spec.audience === "custom";
+}
+
+export function isShadowAgent(spec: AgentSpec): boolean {
+	return spec.audience === "shadow" || spec.audience === "internal";
+}
+
+export function agentSpecPolicyErrors(spec: AgentSpec): string[] {
+	const errors: string[] = [];
+	const actions = actionClassesForTools(spec.tools);
+	const requiredGroups = spec.toolRequirements.required.map((requirement) =>
+		typeof requirement === "string" ? [requirement] : requirement.anyOf,
+	);
+	const requiresTool = (tool: ToolName): boolean =>
+		requiredGroups.some((group) => group.length > 0 && group.every((candidate) => candidate === tool));
+	const requiresMutation = requiredGroups.some(
+		(group) => group.length > 0 && group.every((tool) => tool === ToolNames.Write || tool === ToolNames.Edit),
+	);
+	if (spec.capabilityClass === "workspace-edit" && (!requiresTool(ToolNames.Read) || !requiresMutation)) {
+		errors.push(`workspace-edit agent '${spec.id}' must require read and write|edit`);
+	}
+	if (spec.capabilityClass === "verification" && !requiresTool(ToolNames.Verify)) {
+		errors.push(`verification agent '${spec.id}' must require verify`);
+	}
+	if (spec.capabilityClass === "artifact-write" && !requiresTool(ToolNames.Artifact)) {
+		errors.push(`artifact-write agent '${spec.id}' must require artifact`);
+	}
+	if (spec.skills.length > 0 && !requiresTool(ToolNames.Context)) {
+		errors.push(`agent '${spec.id}' must require context for bound skills`);
+	}
+	if (
+		spec.capabilityClass === "orchestration" &&
+		spec.tools.includes(ToolNames.Dispatch) &&
+		!requiresTool(ToolNames.Dispatch)
+	) {
+		errors.push(`orchestration agent '${spec.id}' must require dispatch when it is declared`);
+	}
+	const toolList = spec.tools.join(", ");
+	if (spec.capabilityClass === "read-only") {
+		for (const action of actions) {
+			if (action !== "read") errors.push(`read-only agent '${spec.id}' requests ${action} tools (${toolList})`);
+		}
+	}
+	if (spec.capabilityClass === "artifact-write") {
+		for (const tool of spec.tools) {
+			const action = classify({ tool }).actionClass;
+			if (action === "execute" || action === "dispatch" || action === "system_modify" || action === "git_destructive") {
+				errors.push(`artifact-write agent '${spec.id}' requests ${action} tool '${tool}'`);
+			}
+			if (action === "write" && tool !== ToolNames.Artifact) {
+				errors.push(`artifact-write agent '${spec.id}' can only write terminal artifacts; got '${tool}'`);
+			}
+		}
+	}
+	if (spec.capabilityClass === "verification") {
+		for (const tool of spec.tools) {
+			const action = classify({ tool }).actionClass;
+			if (action === "write" || action === "dispatch" || action === "system_modify" || action === "git_destructive") {
+				errors.push(`verification agent '${spec.id}' must not request ${action} tool '${tool}'`);
+			}
+			if (tool === ToolNames.Bash)
+				errors.push(`verification agent '${spec.id}' must use typed validation tools, not bash`);
+		}
+	}
+	if (spec.capabilityClass !== "orchestration" && spec.tools.includes(ToolNames.Dispatch)) {
+		errors.push(`agent '${spec.id}' exposes dispatch without orchestration capability`);
+	}
+	if (spec.tools.includes(ToolNames.AskUser)) {
+		errors.push(`agent '${spec.id}' exposes ask_user, which is only available to the orchestrator`);
+	}
+	if (spec.skills.length > 0 && !spec.tools.includes(ToolNames.Context)) {
+		errors.push(`agent '${spec.id}' declares skills but does not expose context`);
+	}
+	return errors;
+}
+
+export function assertAgentSpecPolicy(spec: AgentSpec): void {
+	const errors = agentSpecPolicyErrors(spec);
+	if (errors.length > 0) throw new Error(`agent policy violation:\n${errors.map((error) => `- ${error}`).join("\n")}`);
+}

package/src/domains/agents/write-boundary.ts

@@ -0,0 +1,109 @@
+/**
+ * Declared write boundaries: the repo paths a fleet step is allowed to change.
+ *
+ * A tool permission level is a capability list. This is a boundary, and they
+ * are not the same thing: a step that may run a command may write anywhere that
+ * command can reach, so "this step changes nothing outside `docs/`" is a claim
+ * about the repository, not about the tool surface. Clio settles the claim in
+ * code, after the step, by diffing the workspace.
+ *
+ * This module owns only the grammar: what a declared entry may look like, what
+ * it covers, and when two declarations overlap. The enforcement half lives in
+ * `src/domains/dispatch/write-boundary.ts`, because deciding what a step was
+ * allowed to write is contract policy and observing what it did write is a
+ * property of the checkout.
+ *
+ * Grammar, deliberately small (v1 has no globs):
+ *
+ *   src/domains/dispatch/route-facts.ts   exactly that file
+ *   docs/                                 that directory and everything under it
+ *
+ * Entries are repo-relative and POSIX-separated. An absolute path, a `..`
+ * segment, a backslash, or a glob character is refused at parse time rather
+ * than interpreted, because an allowlist that quietly means something other
+ * than it says is worse than no allowlist.
+ */
+
+/**
+ * Upper bound on one step's declared allowlist. A boundary is a statement an
+ * operator has to be able to read; thirty-two prefixes is already generous, and
+ * a step that needs more of the tree than that should say `workspace` and mean
+ * it in a contract that does not claim a boundary.
+ */
+export const WRITE_BOUNDARY_MAX_ENTRIES = 32;
+
+/** A normalized allowlist. Empty means "changes nothing", which is `readonly`. */
+export type WriteBoundary = ReadonlyArray<string>;
+
+const GLOB_CHARACTERS = /[*?[\]{}]/u;
+
+/** Normalize one declared entry, or throw explaining exactly what is wrong. */
+export function normalizeWriteBoundaryEntry(entry: string): string {
+	const raw = entry.trim();
+	if (raw.length === 0) throw new Error("write boundary: entry must be a non-empty path");
+	if (raw.includes("\\")) {
+		throw new Error(`write boundary: entry '${entry}' must use '/' separators`);
+	}
+	if (GLOB_CHARACTERS.test(raw)) {
+		throw new Error(`write boundary: entry '${entry}' looks like a glob, which v1 does not support`);
+	}
+	if (raw.startsWith("/") || /^[A-Za-z]:/u.test(raw)) {
+		throw new Error(`write boundary: entry '${entry}' must be repository-relative, not absolute`);
+	}
+	const subtree = raw.endsWith("/");
+	const segments = raw.split("/").filter((segment) => segment.length > 0);
+	if (segments.length === 0) {
+		throw new Error(`write boundary: entry '${entry}' must name a path inside the repository`);
+	}
+	for (const segment of segments) {
+		if (segment === "..") throw new Error(`write boundary: entry '${entry}' must not contain '..'`);
+		if (segment === ".") throw new Error(`write boundary: entry '${entry}' must not contain '.' segments`);
+	}
+	const joined = segments.join("/");
+	return subtree ? `${joined}/` : joined;
+}
+
+/**
+ * Normalize a declaration. Duplicates collapse and the result is sorted, so two
+ * spellings of the same boundary produce one canonical value that a plan hash
+ * and a sealed verdict can both carry.
+ */
+export function normalizeWriteBoundary(entries: ReadonlyArray<string>): string[] {
+	if (entries.length > WRITE_BOUNDARY_MAX_ENTRIES) {
+		throw new Error(`write boundary: at most ${WRITE_BOUNDARY_MAX_ENTRIES} entries may be declared`);
+	}
+	const normalized = new Set(entries.map(normalizeWriteBoundaryEntry));
+	// A file entry covered by a declared subtree is redundant, not an error: the
+	// operator said the directory, and saying one of its files again changes
+	// nothing about what is allowed.
+	return [...normalized].sort();
+}
+
+/** Repo-relative path with the separators this grammar speaks. */
+function toRepoRelativePosix(path: string): string {
+	return path.split("\\").join("/");
+}
+
+/** Whether the boundary permits a change to one repo-relative path. */
+export function writeBoundaryCovers(boundary: WriteBoundary, path: string): boolean {
+	const candidate = toRepoRelativePosix(path);
+	return boundary.some((entry) => (entry.endsWith("/") ? candidate.startsWith(entry) : candidate === entry));
+}
+
+/** Whether two declared entries can describe the same path. */
+function entriesOverlap(left: string, right: string): boolean {
+	if (left === right) return true;
+	if (left.endsWith("/") && right.startsWith(left)) return true;
+	if (right.endsWith("/") && left.startsWith(right)) return true;
+	return false;
+}
+
+/** Whether two boundaries share any path. Empty boundaries never overlap. */
+export function writeBoundariesOverlap(left: WriteBoundary, right: WriteBoundary): boolean {
+	return left.some((entry) => right.some((other) => entriesOverlap(entry, other)));
+}
+
+/** Operator-facing rendering, used verbatim in violation messages. */
+export function describeWriteBoundary(boundary: WriteBoundary): string {
+	return boundary.length === 0 ? "(nothing: readonly)" : boundary.join(", ");
+}

package/src/domains/components/diff.ts

@@ -0,0 +1,99 @@
+import type {
+	ChangedHarnessComponent,
+	ComponentDiff,
+	ComponentFieldName,
+	ComponentSnapshot,
+	HarnessComponent,
+} from "./types.js";
+
+const COMPONENT_FIELDS: ReadonlyArray<ComponentFieldName> = [
+	"id",
+	"kind",
+	"path",
+	"ownerDomain",
+	"mutable",
+	"authority",
+	"reloadClass",
+	"contentHash",
+	"description",
+];
+
+export function diffComponentSnapshots(from: ComponentSnapshot, to: ComponentSnapshot): ComponentDiff {
+	const fromById = indexComponents(from.components, "from");
+	const toById = indexComponents(to.components, "to");
+	const added: HarnessComponent[] = [];
+	const removed: HarnessComponent[] = [];
+	const changed: ChangedHarnessComponent[] = [];
+	let unchanged = 0;
+
+	for (const before of from.components) {
+		const after = toById.get(before.id);
+		if (!after) {
+			removed.push(before);
+			continue;
+		}
+		const changedFields = changedComponentFields(before, after);
+		if (changedFields.length === 0) {
+			unchanged += 1;
+			continue;
+		}
+		changed.push({ id: before.id, before, after, changedFields });
+	}
+
+	for (const after of to.components) {
+		if (!fromById.has(after.id)) added.push(after);
+	}
+
+	return {
+		version: 1,
+		from: {
+			root: from.root,
+			generatedAt: from.generatedAt,
+			componentCount: from.components.length,
+		},
+		to: {
+			root: to.root,
+			generatedAt: to.generatedAt,
+			componentCount: to.components.length,
+		},
+		summary: {
+			added: added.length,
+			removed: removed.length,
+			changed: changed.length,
+			unchanged,
+		},
+		added: sortComponents(added),
+		removed: sortComponents(removed),
+		changed: changed.sort((a, b) => a.id.localeCompare(b.id)),
+	};
+}
+
+function indexComponents(
+	components: ReadonlyArray<HarnessComponent>,
+	label: "from" | "to",
+): Map<string, HarnessComponent> {
+	const map = new Map<string, HarnessComponent>();
+	for (const component of components) {
+		if (map.has(component.id)) {
+			throw new Error(`component diff ${label} snapshot has duplicate id: ${component.id}`);
+		}
+		map.set(component.id, component);
+	}
+	return map;
+}
+
+function changedComponentFields(before: HarnessComponent, after: HarnessComponent): ComponentFieldName[] {
+	const changed: ComponentFieldName[] = [];
+	for (const field of COMPONENT_FIELDS) {
+		if (before[field] !== after[field]) changed.push(field);
+	}
+	return changed;
+}
+
+function sortComponents(components: ReadonlyArray<HarnessComponent>): HarnessComponent[] {
+	return [...components].sort((a, b) => {
+		const idOrder = a.id.localeCompare(b.id);
+		if (idOrder !== 0) return idOrder;
+		return a.path.localeCompare(b.path);
+	});
+}

package/src/domains/components/hash.ts

@@ -0,0 +1,21 @@
+import { createHash } from "node:crypto";
+
+export function sha256Hex(content: Buffer | string): string {
+	return createHash("sha256").update(content).digest("hex");
+}
+
+export function stableJson(value: unknown): string {
+	if (value === null) return "null";
+	if (typeof value === "string") return JSON.stringify(value);
+	if (typeof value === "number" || typeof value === "boolean") return JSON.stringify(value);
+	if (Array.isArray(value)) return `[${value.map((item) => stableJson(item)).join(",")}]`;
+	if (isRecord(value)) {
+		const entries = Object.entries(value).sort(([a], [b]) => a.localeCompare(b));
+		return `{${entries.map(([key, entry]) => `${JSON.stringify(key)}:${stableJson(entry)}`).join(",")}}`;
+	}
+	return JSON.stringify(null);
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null;
+}

package/src/domains/components/index.ts

@@ -0,0 +1,3 @@
+export { diffComponentSnapshots } from "./diff.js";
+export { createComponentSnapshot } from "./scan.js";
+export { loadComponentSnapshot } from "./snapshot.js";