@human-synthesis/norns 0.0.16 → 0.2.0

package/src/kernel/graph.js

@@ -0,0 +1,222 @@
+/**
+ * Spec edge graph (K-07) — derived, never stored (PLAN §4.3).
+ *
+ * Nodes are unit addresses plus `event:<name>` nodes for the emit/on
+ * namespace. Edges are derived per module, so incremental invalidation is
+ * a per-module cache keyed by the module's spec hash. Code edges (custom
+ * body imports via civet-bridge) are appended by the MCP indexer later —
+ * this module covers the spec-derived edges.
+ *
+ * Edge types: reads · writes · binds · guards · emits · on · calls · refreshes
+ */
+
+import { formatAddress, isAddress, listUnits } from './address.js';
+
+/** @typedef {{ from: string, to: string, type: string }} Edge */
+
+const eventNode = (name) => `event:${name}`;
+
+/** Resolve a written ref to a full address: bare names bind in-module. */
+function refAddress(moduleName, kind, ref) {
+	if (typeof ref !== 'string' || ref === '') return null;
+	if (isAddress(ref)) return ref;
+	return formatAddress({ module: moduleName, kind, name: ref.split('.')[0] });
+}
+
+/**
+ * Derive all edges that originate from one module's units.
+ *
+ * @param {string} moduleName
+ * @param {*} moduleSpec
+ * @returns {Edge[]}
+ */
+export function moduleEdges(moduleName, moduleSpec) {
+	/** @type {Edge[]} */
+	const edges = [];
+	const add = (from, to, type) => {
+		if (to) edges.push({ from, to, type });
+	};
+
+	for (const unit of listUnits(moduleName, moduleSpec)) {
+		const { address: at, value, kind, name } = unit;
+		switch (kind) {
+			case 'Query':
+				add(at, refAddress(moduleName, 'Entity', value?.from), 'reads');
+				break;
+			case 'Action': {
+				for (const step of Array.isArray(value?.steps) ? value.steps : []) {
+					if (step === null || typeof step !== 'object') continue;
+					for (const [stepKind, stepValue] of Object.entries(step)) {
+						if (stepKind === 'emit' && typeof stepValue === 'string') {
+							add(at, eventNode(stepValue), 'emits');
+						} else if (typeof stepValue?.entity === 'string') {
+							add(at, refAddress(moduleName, 'Entity', stepValue.entity), 'writes');
+						} else if (stepKind === 'call' && typeof stepValue === 'string') {
+							add(at, refAddress(moduleName, 'Function', stepValue), 'calls');
+						}
+					}
+				}
+				for (const ev of Array.isArray(value?.emits) ? value.emits : []) {
+					if (typeof ev === 'string') add(at, eventNode(ev), 'emits');
+				}
+				for (const q of Array.isArray(value?.refresh) ? value.refresh : []) {
+					add(at, refAddress(moduleName, 'Query', q), 'refreshes');
+				}
+				break;
+			}
+			case 'Page': {
+				for (const comp of Array.isArray(value?.components) ? value.components : []) {
+					if (comp === null || typeof comp !== 'object') continue;
+					for (const bound of Object.values(comp)) {
+						if (typeof bound === 'string' && isAddress(bound)) add(at, bound, 'binds');
+					}
+				}
+				break;
+			}
+			case 'Policy': {
+				add(at, formatAddress({ module: moduleName, kind: 'Entity', name }), 'guards');
+				for (const actionName of Object.keys(value?.run ?? {})) {
+					add(at, refAddress(moduleName, 'Action', actionName), 'guards');
+				}
+				break;
+			}
+			case 'Trigger': {
+				add(eventNode(name), at, 'on');
+				const action = typeof value === 'string' ? value : value?.action;
+				add(at, refAddress(moduleName, 'Action', action), 'calls');
+				break;
+			}
+			case 'Component': {
+				for (const target of Object.values(value?.events ?? {})) {
+					add(at, refAddress(moduleName, 'Action', target), 'calls');
+				}
+				break;
+			}
+		}
+	}
+	return edges;
+}
+
+/**
+ * @typedef {{
+ *   edges: Edge[],
+ *   outbound: Map<string, Edge[]>,
+ *   inbound: Map<string, Edge[]>
+ * }} Graph
+ */
+
+/** @param {Edge[]} edges @returns {Graph} */
+function assemble(edges) {
+	const outbound = new Map();
+	const inbound = new Map();
+	for (const edge of edges) {
+		if (!outbound.has(edge.from)) outbound.set(edge.from, []);
+		outbound.get(edge.from).push(edge);
+		if (!inbound.has(edge.to)) inbound.set(edge.to, []);
+		inbound.get(edge.to).push(edge);
+	}
+	return { edges, outbound, inbound };
+}
+
+/**
+ * Build the full graph from scratch.
+ *
+ * @param {Record<string, *>} modules
+ * @returns {Graph}
+ */
+export function buildGraph(modules) {
+	const edges = [];
+	for (const [name, spec] of Object.entries(modules)) edges.push(...moduleEdges(name, spec));
+	return assemble(edges);
+}
+
+/** @returns {{ hashes: Record<string, string>, edges: Record<string, Edge[]> }} */
+export function createGraphCache() {
+	return { hashes: {}, edges: {} };
+}
+
+/**
+ * Incrementally update the graph: only modules whose hash changed are
+ * re-derived; removed modules drop out. Mutates and returns the cache.
+ *
+ * @param {{ hashes: Record<string, string>, edges: Record<string, Edge[]> }} cache
+ * @param {Record<string, *>} modules
+ * @param {Record<string, string>} hashes per-module spec hashes (e.g. from readSpecs)
+ * @returns {{ graph: Graph, changed: string[] }}
+ */
+export function updateGraph(cache, modules, hashes) {
+	const changed = [];
+	for (const name of Object.keys(cache.edges)) {
+		if (!(name in modules)) {
+			delete cache.edges[name];
+			delete cache.hashes[name];
+			changed.push(name);
+		}
+	}
+	for (const [name, spec] of Object.entries(modules)) {
+		if (cache.hashes[name] !== hashes[name]) {
+			cache.edges[name] = moduleEdges(name, spec);
+			cache.hashes[name] = hashes[name];
+			changed.push(name);
+		}
+	}
+	return { graph: assemble(Object.values(cache.edges).flat()), changed };
+}
+
+/**
+ * Addresses reachable within `depth` hops of `address`, in either
+ * direction — the unit's working context.
+ *
+ * @param {Graph} graph
+ * @param {string} address
+ * @param {number} [depth]
+ * @returns {Set<string>}
+ */
+export function neighborhood(graph, address, depth = 1) {
+	const seen = new Set([address]);
+	let frontier = [address];
+	for (let d = 0; d < depth && frontier.length > 0; d++) {
+		const next = [];
+		for (const node of frontier) {
+			for (const edge of graph.outbound.get(node) ?? []) {
+				if (!seen.has(edge.to)) {
+					seen.add(edge.to);
+					next.push(edge.to);
+				}
+			}
+			for (const edge of graph.inbound.get(node) ?? []) {
+				if (!seen.has(edge.from)) {
+					seen.add(edge.from);
+					next.push(edge.from);
+				}
+			}
+		}
+		frontier = next;
+	}
+	return seen;
+}
+
+/**
+ * Everything that (transitively) depends on `address` — the units to
+ * re-check or regenerate when it changes. Follows inbound edges only;
+ * excludes the address itself.
+ *
+ * @param {Graph} graph
+ * @param {string} address
+ * @returns {Set<string>}
+ */
+export function impact(graph, address) {
+	const seen = new Set();
+	const stack = [address];
+	while (stack.length > 0) {
+		const node = stack.pop();
+		for (const edge of graph.inbound.get(node) ?? []) {
+			if (!seen.has(edge.from)) {
+				seen.add(edge.from);
+				stack.push(edge.from);
+			}
+		}
+	}
+	seen.delete(address);
+	return seen;
+}

package/src/kernel/index.js

@@ -0,0 +1,78 @@
+/**
+ * Norns kernel — the spec-canonical engine (`@human-synthesis/norns/kernel`).
+ *
+ * Owns the pipeline: load `specs/*.tron` → validate → generate code into
+ * `.norns/generated/`. Kept as a subpath of the norns package (not its own
+ * package) but with no imports from the rest of `src/`, so it stays
+ * extractable if it ever needs its own release cadence.
+ */
+
+export {
+	KINDS,
+	KIND_KEYS,
+	KEY_KINDS,
+	formatAddress,
+	parseAddress,
+	isAddress,
+	newUid,
+	listUnits,
+	ensureUids,
+	indexUnits,
+	resolvePath
+} from './address.js';
+export { CMP_OPS, parseExpr, printExpr, isExpr } from './expr.js';
+export { evalExpr, compileGuard, compileWhere } from './expr-compile.js';
+export {
+	FIELD_TYPES,
+	DIALECTS,
+	UNIT_SCHEMAS,
+	MODULE_SCHEMA,
+	APP_SCHEMA,
+	schemaIssues
+} from './meta.js';
+export {
+	moduleEdges,
+	buildGraph,
+	createGraphCache,
+	updateGraph,
+	neighborhood,
+	impact
+} from './graph.js';
+export { refineSpecs } from './refine.js';
+export {
+	CUSTOM_RATIO_THRESHOLD,
+	customUnits,
+	customRatio,
+	customBodyPath,
+	absorbUnit,
+	absorbApp
+} from './absorb.js';
+export { inferKind, inferCapabilities, inferAuth, adoptUnit, adoptFiles } from './adopt.js';
+export { loadSpecs, validateSpecs } from './validate.js';
+export { generateApp, checkGenerate, checkBindings, checkServiceSecrets, checkNetworkInBodies, checkTokenOverrides, tokenOverrides, tokensFile, layoutFile, liveRouteFile, selfCheck, GenerateError, EMITTERS } from './generate.js';
+export { indexBody, unitFlow, buildModuleFlow, emitFlow, flowApp, flowDelta } from './flow.js';
+export { wranglerConfig, wranglerFile } from './emit-wrangler.js';
+export { emitModuleMachines, machinesEmitter } from './emit-machines.js';
+export { migrateApp } from './migrate.js';
+export { traceApp, TRACE_USER } from './trace.js';
+export { emitModuleSchema, schemaEmitter } from './emit-schema.js';
+export {
+	emitModulePolicies,
+	emitModuleQueries,
+	emitModuleActions,
+	emitModuleServices,
+	emitModuleJobs,
+	emitModuleTriggers,
+	emitModulePages,
+	emitModuleRemotes,
+	emitModuleEndpoints,
+	policiesEmitter,
+	queriesEmitter,
+	actionsEmitter,
+	servicesEmitter,
+	jobsEmitter,
+	triggersEmitter,
+	pagesEmitter,
+	remotesEmitter,
+	endpointsEmitter
+} from './emit-units.js';

package/src/kernel/meta.js

@@ -0,0 +1,381 @@
+/**
+ * Valibot meta-schemas — one per resource kind. These make invalid specs
+ * unrepresentable at the shape level: unknown keys are rejected
+ * (strictObject), expressions must parse, references must look like
+ * addresses. Cross-unit refinements (refs resolve, depends DAG, closed
+ * status machines) live in refine.js (K-06), not here.
+ */
+
+import * as v from 'valibot';
+
+import { isAddress } from './address.js';
+import { isExpr } from './expr.js';
+
+export const FIELD_TYPES = [
+	'text',
+	'number',
+	'int',
+	'money',
+	'bool',
+	'date',
+	'datetime',
+	'email',
+	'url',
+	'json',
+	'file',
+	'ref'
+];
+
+export const DIALECTS = ['d1', 'sqlite', 'postgres'];
+
+const IDENT_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
+
+const ident = v.pipe(v.string(), v.regex(IDENT_RE, 'must be an identifier'));
+const uid = v.optional(
+	v.pipe(v.string(), v.regex(/^[0-9A-HJKMNP-TV-Z]{26}$/, 'must be a 26-char ULID'))
+);
+const expr = v.pipe(
+	v.string(),
+	v.check(isExpr, 'must be a valid expression (see the CEL-subset grammar)')
+);
+const address = v.pipe(
+	v.string(),
+	v.check(isAddress, 'must be a unit address (module.Kind.name)')
+);
+/** Full address or a bare/dotted local name like `Order` or `Order.id`. */
+const unitRef = v.pipe(
+	v.string(),
+	v.check(
+		(s) => isAddress(s) || s.split('.').every((seg) => IDENT_RE.test(seg)),
+		'must be a unit reference'
+	)
+);
+
+const fieldObject = v.pipe(
+	v.strictObject({
+		type: v.picklist(FIELD_TYPES),
+		ref: v.optional(unitRef),
+		optional: v.optional(v.boolean()),
+		unique: v.optional(v.boolean()),
+		default: v.optional(v.unknown())
+	}),
+	v.check((f) => (f.type === 'ref') === (f.ref !== undefined), 'ref fields need `ref`, others must not have it')
+);
+const field = v.union([v.picklist(FIELD_TYPES), fieldObject]);
+
+const example = v.strictObject({
+	input: v.optional(v.unknown()),
+	expect: v.optional(v.unknown())
+});
+
+const requiresExamplesWhenCustom = (unit) =>
+	unit.impl !== 'custom' || (Array.isArray(unit.examples) && unit.examples.length > 0);
+const CUSTOM_NEEDS_EXAMPLES = '`impl: custom` requires at least one example';
+
+const Entity = v.strictObject({
+	uid,
+	owner: v.optional(ident),
+	fields: v.record(ident, field),
+	status: v.optional(v.record(ident, v.array(ident)))
+});
+
+const Query = v.strictObject({
+	uid,
+	from: unitRef,
+	live: v.optional(v.boolean()),
+	groupBy: v.optional(v.string()),
+	filter: v.optional(expr),
+	sort: v.optional(v.union([v.string(), v.array(v.string())])),
+	limit: v.optional(v.pipe(v.number(), v.integer(), v.minValue(1)))
+});
+
+const Action = v.pipe(
+	v.strictObject({
+		uid,
+		input: v.optional(v.record(ident, v.union([v.string(), v.record(v.string(), v.unknown())]))),
+		requires: v.optional(expr),
+		steps: v.optional(v.array(v.record(v.string(), v.unknown()))),
+		emits: v.optional(v.array(v.string())),
+		refresh: v.optional(v.array(address)),
+		examples: v.optional(v.array(example)),
+		impl: v.optional(v.picklist(['generated', 'custom'])),
+		transport: v.optional(v.picklist(['form', 'remote']))
+	}),
+	v.check(requiresExamplesWhenCustom, CUSTOM_NEEDS_EXAMPLES)
+);
+
+const Policy = v.strictObject({
+	uid,
+	roles: v.optional(v.array(ident)),
+	read: v.optional(expr),
+	write: v.optional(expr),
+	run: v.optional(v.record(ident, expr))
+});
+
+const Page = v.pipe(
+	v.strictObject({
+		uid,
+		route: v.pipe(v.string(), v.regex(/^\//, 'route must start with "/"')),
+		params: v.optional(v.record(ident, v.string())),
+		layout: v.optional(v.string()),
+		state: v.optional(v.record(ident, v.string())),
+		components: v.optional(v.array(v.record(v.string(), v.unknown()))),
+		slots: v.optional(v.array(ident)),
+		examples: v.optional(v.array(example)),
+		impl: v.optional(v.picklist(['generated', 'custom']))
+	}),
+	v.check(requiresExamplesWhenCustom, CUSTOM_NEEDS_EXAMPLES)
+);
+
+const Trigger = v.union([
+	address,
+	v.strictObject({
+		uid,
+		action: address,
+		schedule: v.optional(v.string()),
+		source: v.optional(v.string())
+	})
+]);
+
+const Function = v.strictObject({
+	uid,
+	input: v.optional(v.record(ident, v.union([v.string(), v.record(v.string(), v.unknown())]))),
+	output: v.optional(v.unknown()),
+	examples: v.pipe(v.array(example), v.minLength(1, 'functions require at least one example'))
+});
+
+const Component = v.strictObject({
+	uid,
+	props: v.optional(v.record(ident, v.unknown())),
+	events: v.optional(v.record(ident, address)),
+	slots: v.optional(v.array(ident))
+});
+
+// Snippet (U-07) — a typed render fragment for a palette slot (cell
+// renderers, empty states). Declared args are the slot's calling
+// convention; the body lives in `src/<m>/snippets/<name>.n` and the page
+// emitter wraps it in a `+snippet` forwarding the args as props.
+const Snippet = v.strictObject({
+	uid,
+	args: v.optional(v.array(ident)),
+	description: v.optional(v.string())
+});
+
+// Service (D15) — an external system as a typed operation manifest.
+// Credentials never appear here: `auth.binding` is an env binding *name*
+// (UPPER_SNAKE); a literal secret anywhere in a service is refused at
+// generate time (SECRET_IN_SPEC, generate.js).
+const bindingName = v.pipe(
+	v.string(),
+	v.regex(/^[A-Z][A-Z0-9_]*$/, 'must be an UPPER_SNAKE env binding name, never a secret value')
+);
+
+const ServiceAuth = v.pipe(
+	v.strictObject({
+		mode: v.picklist(['none', 'bearer', 'basic', 'hmac', 'header']),
+		binding: v.optional(bindingName),
+		header: v.optional(v.pipe(v.string(), v.regex(/^[A-Za-z][A-Za-z0-9-]*$/, 'must be a header name')))
+	}),
+	v.check(
+		(a) => (a.mode === 'none' ? a.binding === undefined : a.binding !== undefined),
+		"auth modes other than 'none' require a `binding` name; 'none' must not have one"
+	),
+	v.check((a) => a.mode === 'header' || a.header === undefined, "`header` is only valid with mode 'header'"),
+	v.check((a) => a.mode !== 'header' || a.header !== undefined, "auth mode 'header' requires `header`")
+);
+
+const ServiceOperation = v.strictObject({
+	method: v.optional(v.picklist(['GET', 'POST', 'PUT', 'PATCH', 'DELETE'])),
+	path: v.optional(v.pipe(v.string(), v.regex(/^\//, 'path must start with "/"'))),
+	input: v.optional(v.record(ident, v.union([v.string(), v.record(v.string(), v.unknown())]))),
+	output: v.optional(v.unknown())
+});
+
+const Service = v.strictObject({
+	uid,
+	base: v.pipe(v.string(), v.url('base must be an absolute URL')),
+	auth: ServiceAuth,
+	operations: v.pipe(
+		v.record(ident, ServiceOperation),
+		v.check((ops) => Object.keys(ops).length > 0, 'services require at least one operation')
+	)
+});
+
+// Job (D14/K-22) — durable work. Retry policy is required by guardrail:
+// a job without declared failure behavior is refused at the shape level.
+// Jobs run from `enqueue` steps via the events bus (`job:<address>`
+// messages) — Cloudflare Queues in production, inline in dev.
+const queueName = v.pipe(
+	v.string(),
+	v.regex(/^[a-z][a-z0-9-]*$/, 'must be a queue name (lowercase, digits, dashes)')
+);
+
+const Job = v.pipe(
+	v.strictObject({
+		uid,
+		input: v.optional(v.record(ident, v.union([v.string(), v.record(v.string(), v.unknown())]))),
+		retry: v.strictObject({
+			attempts: v.pipe(v.number(), v.integer(), v.minValue(1), v.maxValue(20)),
+			backoff: v.picklist(['none', 'fixed', 'exponential']),
+			baseMs: v.optional(v.pipe(v.number(), v.integer(), v.minValue(1)))
+		}),
+		dlq: v.optional(queueName),
+		concurrency: v.optional(v.pipe(v.number(), v.integer(), v.minValue(1), v.maxValue(100))),
+		steps: v.optional(v.array(v.record(v.string(), v.unknown()))),
+		emits: v.optional(v.array(v.string())),
+		examples: v.optional(v.array(example)),
+		impl: v.optional(v.picklist(['generated', 'custom']))
+	}),
+	v.check(requiresExamplesWhenCustom, CUSTOM_NEEDS_EXAMPLES),
+	v.check(
+		(j) => j.impl === 'custom' || (Array.isArray(j.steps) && j.steps.length > 0),
+		'generated jobs need at least one step (or `impl: custom`)'
+	)
+);
+
+// Endpoint (D14/K-23) — a Route grown up: declared route/method/auth and
+// IO contract in spec, body in `src/<m>/endpoints/<name>.c`. `stream`
+// declares an SSE output mode with typed frames (the chat/AI-token path).
+// `auth` is required — public endpoints declare `{ mode: 'none' }` explicitly.
+const Endpoint = v.pipe(
+	v.strictObject({
+		uid,
+		route: v.pipe(v.string(), v.regex(/^\//, 'route must start with "/"')),
+		method: v.optional(v.picklist(['GET', 'POST', 'PUT', 'PATCH', 'DELETE'])),
+		auth: ServiceAuth,
+		input: v.optional(v.record(ident, v.union([v.string(), v.record(v.string(), v.unknown())]))),
+		output: v.optional(v.record(ident, v.unknown())),
+		stream: v.optional(
+			v.strictObject({
+				frame: v.pipe(
+					v.record(ident, v.unknown()),
+					v.check((f) => Object.keys(f).length > 0, 'stream frames need at least one field')
+				)
+			})
+		),
+		impl: v.optional(v.literal('custom')),
+		examples: v.optional(v.array(example))
+	}),
+	v.check((e) => !(e.output && e.stream), 'declare either `output` or `stream`, not both'),
+	v.check(requiresExamplesWhenCustom, CUSTOM_NEEDS_EXAMPLES)
+);
+
+// Room contract (D14) — Workers with `room: true` may declare state and
+// message schemas plus script examples: message sequences driven against
+// the Room class headless, checked as expected state + broadcasts (K-25).
+const roomScriptStep = v.strictObject({
+	send: ident,
+	with: v.optional(v.record(v.string(), v.unknown()))
+});
+
+const roomExample = v.strictObject({
+	script: v.pipe(v.array(roomScriptStep), v.minLength(1, 'room examples need at least one script step')),
+	expect: v.optional(v.unknown())
+});
+
+// L3 kinds: whole Civet files with declared auth + capabilities.
+// `validate` refuses them without an auth declaration (PLAN §6).
+const level3 = (extra = {}) =>
+	v.strictObject({
+		uid,
+		source: v.string(),
+		auth: v.union([v.string(), v.record(v.string(), v.unknown())]),
+		capabilities: v.optional(v.array(v.string())),
+		...extra
+	});
+
+const Plugin = v.strictObject({
+	uid,
+	kind: v.picklist(['field', 'step', 'component', 'trigger']),
+	source: v.string(),
+	contract: v.optional(v.record(v.string(), v.unknown()))
+});
+
+/** Kind → valibot schema for one unit's spec value. */
+export const UNIT_SCHEMAS = {
+	Entity,
+	Query,
+	Action,
+	Policy,
+	Page,
+	Trigger,
+	Function,
+	Component,
+	Snippet,
+	Service,
+	Job,
+	Endpoint,
+	Route: level3(),
+	Worker: level3({
+		room: v.optional(v.boolean()),
+		state: v.optional(v.record(ident, v.string())),
+		messages: v.optional(
+			v.record(
+				ident,
+				v.strictObject({
+					in: v.optional(v.record(v.string(), v.unknown())),
+					out: v.optional(v.record(v.string(), v.unknown()))
+				})
+			)
+		),
+		tickMs: v.optional(v.pipe(v.number(), v.integer(), v.minValue(0))),
+		examples: v.optional(v.array(roomExample))
+	}),
+	Adapter: level3(),
+	Middleware: level3(),
+	Plugin
+};
+
+const collection = v.optional(v.record(v.string(), v.unknown()));
+
+/** Module spec shape — collection contents are validated per unit. */
+export const MODULE_SCHEMA = v.strictObject({
+	module: ident,
+	depends: v.optional(v.array(ident)),
+	settings: v.optional(v.record(v.string(), v.unknown())),
+	entities: collection,
+	queries: collection,
+	actions: collection,
+	policies: collection,
+	pages: collection,
+	triggers: collection,
+	functions: collection,
+	components: collection,
+	snippets: collection,
+	services: collection,
+	jobs: collection,
+	endpoints: collection,
+	routes: collection,
+	workers: collection,
+	adapters: collection,
+	middleware: collection,
+	plugins: collection
+});
+
+export const APP_SCHEMA = v.strictObject({
+	name: v.optional(v.string()),
+	modules: v.optional(v.array(ident)),
+	dialect: v.optional(v.picklist(DIALECTS)),
+	settings: v.optional(v.record(v.string(), v.unknown()))
+});
+
+/**
+ * Run a valibot schema and convert its issues to kernel Issues.
+ *
+ * @param {*} schema
+ * @param {*} value
+ * @param {string} addr issue address (unit address or module name)
+ * @returns {{ level: 'error', address: string, message: string }[]}
+ */
+export function schemaIssues(schema, value, addr) {
+	const result = v.safeParse(schema, value);
+	if (result.success) return [];
+	return result.issues.map((issue) => {
+		const path = v.getDotPath(issue);
+		return {
+			level: 'error',
+			address: addr,
+			message: path ? `${path}: ${issue.message}` : issue.message
+		};
+	});
+}