@human-synthesis/norns 0.0.15 → 0.1.0

package/src/kernel/address.js

@@ -0,0 +1,224 @@
+/**
+ * Addressing — stable identity for spec units.
+ *
+ * A unit lives at `module.Kind.name` (e.g. `orders.Action.submit`); a path
+ * extends that with a dotted sub-path into the unit's value
+ * (`orders.Entity.Order.fields.note`). Every object-valued unit also carries
+ * an immutable `uid` (ULID), so references survive renames: the address is
+ * how humans and specs refer to a unit, the uid is how history and the edge
+ * graph do.
+ *
+ * Unit names may themselves contain dots (Trigger sources like
+ * `catalog.Product.deleted`), so splitting a path into name vs sub-path is
+ * only possible against a loaded spec — that is what the index is for.
+ */
+
+import { randomBytes } from 'node:crypto';
+
+/** Spec collection key → unit kind. Order irrelevant; keys are the schema. */
+export const KIND_KEYS = {
+	Entity: 'entities',
+	Query: 'queries',
+	Action: 'actions',
+	Policy: 'policies',
+	Page: 'pages',
+	Trigger: 'triggers',
+	Function: 'functions',
+	Component: 'components',
+	Route: 'routes',
+	Worker: 'workers',
+	Adapter: 'adapters',
+	Middleware: 'middleware',
+	Plugin: 'plugins'
+};
+
+export const KINDS = Object.keys(KIND_KEYS);
+
+/** @type {Record<string, string>} collection key → Kind */
+export const KEY_KINDS = Object.fromEntries(Object.entries(KIND_KEYS).map(([k, v]) => [v, k]));
+
+const MODULE_RE = /^[a-z][a-z0-9_]*$/;
+const NAME_SEGMENT_RE = /^[A-Za-z_$][A-Za-z0-9_$-]*$/;
+
+/** @typedef {{ module: string, kind: string, name: string }} Address */
+
+/** `orders.Action.submit` ← { module, kind, name }. */
+export function formatAddress({ module, kind, name }) {
+	return `${module}.${kind}.${name}`;
+}
+
+/**
+ * Parse a unit address. The second segment must be a known Kind; everything
+ * after it is the name (which may itself contain dots).
+ *
+ * @param {string} text
+ * @returns {Address}
+ */
+export function parseAddress(text) {
+	const parts = String(text).split('.');
+	const [module, kind] = parts;
+	const name = parts.slice(2).join('.');
+	if (parts.length < 3 || name === '') {
+		throw new Error(`invalid address "${text}" — expected module.Kind.name`);
+	}
+	if (!MODULE_RE.test(module)) {
+		throw new Error(`invalid address "${text}" — bad module segment "${module}"`);
+	}
+	if (!KINDS.includes(kind)) {
+		throw new Error(`invalid address "${text}" — unknown kind "${kind}"`);
+	}
+	if (!parts.slice(2).every((s) => NAME_SEGMENT_RE.test(s))) {
+		throw new Error(`invalid address "${text}" — bad name "${name}"`);
+	}
+	return { module, kind, name };
+}
+
+/** @param {string} text */
+export function isAddress(text) {
+	try {
+		parseAddress(text);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+const CROCKFORD = '0123456789ABCDEFGHJKMNPQRSTVWXYZ';
+
+/** New ULID — 10 chars of timestamp + 16 chars of randomness, sortable. */
+export function newUid(now = Date.now()) {
+	let ts = '';
+	let t = now;
+	for (let i = 0; i < 10; i++) {
+		ts = CROCKFORD[t % 32] + ts;
+		t = Math.floor(t / 32);
+	}
+	const bytes = randomBytes(16);
+	let rand = '';
+	for (let i = 0; i < 16; i++) rand += CROCKFORD[bytes[i] % 32];
+	return ts + rand;
+}
+
+function isUnitObject(value) {
+	return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+/**
+ * @typedef {{
+ *   address: string, module: string, kind: string, name: string,
+ *   uid: string | null, value: *
+ * }} Unit
+ */
+
+/**
+ * List every unit in one module spec.
+ *
+ * @param {string} moduleName
+ * @param {*} moduleSpec
+ * @returns {Unit[]}
+ */
+export function listUnits(moduleName, moduleSpec) {
+	const units = [];
+	if (!isUnitObject(moduleSpec)) return units;
+	for (const [key, kind] of Object.entries(KEY_KINDS)) {
+		const collection = moduleSpec[key];
+		if (!isUnitObject(collection)) continue;
+		for (const [name, value] of Object.entries(collection)) {
+			units.push({
+				address: formatAddress({ module: moduleName, kind, name }),
+				module: moduleName,
+				kind,
+				name,
+				uid: isUnitObject(value) && typeof value.uid === 'string' ? value.uid : null,
+				value
+			});
+		}
+	}
+	return units;
+}
+
+/**
+ * Assign a fresh uid to every object-valued unit that lacks one, mutating
+ * the module specs in place (string-shorthand units carry no uid until
+ * they are expanded to objects).
+ *
+ * @param {Record<string, *>} modules module name → spec value
+ * @returns {string[]} addresses that received a uid
+ */
+export function ensureUids(modules) {
+	const assigned = [];
+	for (const [moduleName, spec] of Object.entries(modules)) {
+		for (const unit of listUnits(moduleName, spec)) {
+			if (unit.uid === null && isUnitObject(unit.value)) {
+				unit.value.uid = newUid();
+				assigned.push(unit.address);
+			}
+		}
+	}
+	return assigned;
+}
+
+/**
+ * @typedef {{
+ *   units: Unit[],
+ *   byAddress: Map<string, Unit>,
+ *   byUid: Map<string, Unit>,
+ *   issues: { level: 'error', address: string, message: string }[]
+ * }} UnitIndex
+ */
+
+/**
+ * Index all units across an app's modules for address/uid resolution.
+ * Duplicate uids are reported as issues (addresses cannot collide — they
+ * are object keys).
+ *
+ * @param {Record<string, *>} modules
+ * @returns {UnitIndex}
+ */
+export function indexUnits(modules) {
+	const units = [];
+	const byAddress = new Map();
+	const byUid = new Map();
+	const issues = [];
+	for (const [moduleName, spec] of Object.entries(modules)) {
+		for (const unit of listUnits(moduleName, spec)) {
+			units.push(unit);
+			byAddress.set(unit.address, unit);
+			if (unit.uid !== null) {
+				const prior = byUid.get(unit.uid);
+				if (prior) {
+					issues.push({
+						level: 'error',
+						address: unit.address,
+						message: `duplicate uid ${unit.uid} — already used by ${prior.address}`
+					});
+				} else {
+					byUid.set(unit.uid, unit);
+				}
+			}
+		}
+	}
+	return { units, byAddress, byUid, issues };
+}
+
+/**
+ * Resolve a path (`module.Kind.name[.sub.path]`) against an index. Because
+ * unit names may contain dots, the longest name that matches an existing
+ * unit wins; the remainder is the sub-path.
+ *
+ * @param {UnitIndex} index
+ * @param {string} text
+ * @returns {{ unit: Unit, subPath: string[] } | null}
+ */
+export function resolvePath(index, text) {
+	const parts = String(text).split('.');
+	if (parts.length < 3) return null;
+	const [module, kind] = parts;
+	const rest = parts.slice(2);
+	for (let take = rest.length; take >= 1; take--) {
+		const name = rest.slice(0, take).join('.');
+		const unit = index.byAddress.get(formatAddress({ module, kind, name }));
+		if (unit) return { unit, subPath: rest.slice(take) };
+	}
+	return null;
+}

package/src/kernel/adopt.js

@@ -0,0 +1,157 @@
+/**
+ * Adopt — wrap existing hand-written code as Level-3 units (K-20, PLAN §268).
+ *
+ * `adoptUnit` inspects one hand-written source file and proposes the
+ * Level-3 declaration (`{ source, auth, capabilities }` under Route /
+ * Worker / Adapter / Middleware) that would bring it under spec ownership.
+ * Everything is inference-with-evidence: the kind comes from the file's
+ * export shape, capabilities from what it touches, and auth from whether
+ * it reads the user/session — but auth is a *declaration*, so every
+ * proposal says the human must confirm it. Like absorb, this only ever
+ * proposes ops; nothing is applied here.
+ */
+
+import { KIND_KEYS } from './address.js';
+
+const NAME_RE = /^[A-Za-z_$][A-Za-z0-9_$-]*$/;
+const HTTP_VERBS = 'GET|POST|PUT|PATCH|DELETE|OPTIONS|HEAD';
+
+const KIND_RULES = [
+	{
+		kind: 'Worker',
+		test: (src, path) =>
+			(/export\s+default\s*\{[^}]*\b(fetch|scheduled|queue)\b/s.test(src) && 'exports a default { fetch/scheduled/queue } worker object') ||
+			(/extends\s+DurableObject\b/.test(src) && 'a class extends DurableObject') ||
+			(/\bwebSocketMessage\s*[(:=]/.test(src) && 'implements webSocketMessage') ||
+			(/addEventListener\(\s*['"](fetch|scheduled)['"]/.test(src) && "registers a global fetch/scheduled listener") ||
+			(/\.worker\.(c|civet|js|ts)$/.test(path) && 'file is named *.worker.*')
+	},
+	{
+		kind: 'Route',
+		test: (src, path) =>
+			(new RegExp(`export\\s+(?:async\\s+)?(?:function\\s+|const\\s+)?(${HTTP_VERBS})\\b`).test(src) && 'exports HTTP verb handlers') ||
+			(new RegExp(`\\b(${HTTP_VERBS})\\s*:=`).test(src) && 'exports HTTP verb handlers (Civet)') ||
+			(/\+server\.(c|civet|js|ts)$/.test(path) && 'file is a +server route module')
+	},
+	{
+		kind: 'Middleware',
+		test: (src) =>
+			(/export\s+(?:const\s+)?handle\b|(?:^|\s)handle\s*:=/.test(src) && 'exports a `handle` hook') ||
+			(/\bsequence\s*\(/.test(src) && 'composes hooks with sequence()') ||
+			(/\(\s*\{\s*event\s*,\s*resolve\s*\}\s*\)/.test(src) && 'takes the ({ event, resolve }) middleware contract')
+	},
+	{
+		kind: 'Adapter',
+		test: (src) =>
+			/export\s+(default|const|function|async|\{)|(?:^|\n)\s*[A-Za-z_$][\w$]*\s*:=/.test(src) &&
+			'no route/worker/middleware shape — treated as an adapter around its exports'
+	}
+];
+
+const CAPABILITY_RULES = [
+	{ name: 'db', re: /resolve\(\s*['"]db['"]\s*\)|from\s+['"]drizzle-orm|\bD1Database\b/, why: 'touches the database' },
+	{ name: 'events', re: /resolve\(\s*['"]events['"]\s*\)|\.emit\(/, why: 'emits events' },
+	{ name: 'storage', re: /resolve\(\s*['"]storage['"]\s*\)|\bR2Bucket\b/, why: 'uses the storage adapter' },
+	{ name: 'network', re: /\bfetch\s*\(|https?:\/\//, why: 'makes outbound network calls' },
+	{ name: 'env', re: /\benv\.[A-Z_]|platform\.env|\$env\b/, why: 'reads environment bindings' },
+	{ name: 'schedule', re: /\bscheduled\b|\bcron\b/i, why: 'runs on a schedule' },
+	{ name: 'websocket', re: /\bWebSocket\b|webSocketMessage/, why: 'speaks WebSocket' }
+];
+
+const AUTH_RE = /locals\.user|\buser\.roles\b|\bsession\b|better-auth|\bgetUser\b/;
+
+function nameFromPath(path) {
+	const base = String(path)
+		.split('/')
+		.filter(Boolean)
+		.pop()
+		?.replace(/\.(c|civet|n|js|ts)$/, '')
+		?.replace(/^\+/, '');
+	if (!base) return null;
+	const name = base.replace(/[^A-Za-z0-9_$-]/g, '-');
+	return NAME_RE.test(name) ? name : null;
+}
+
+export function inferKind(source, path) {
+	for (const rule of KIND_RULES) {
+		const evidence = rule.test(source, String(path));
+		if (evidence) return { kind: rule.kind, evidence };
+	}
+	return null;
+}
+
+export function inferCapabilities(source) {
+	const capabilities = [];
+	const evidence = {};
+	for (const rule of CAPABILITY_RULES) {
+		if (rule.re.test(source)) {
+			capabilities.push(rule.name);
+			evidence[rule.name] = rule.why;
+		}
+	}
+	return { capabilities, evidence };
+}
+
+export function inferAuth(source) {
+	return AUTH_RE.test(source)
+		? { auth: 'authenticated', evidence: 'references the user/session' }
+		: { auth: 'public', evidence: 'no user/session reference found' };
+}
+
+/**
+ * Propose adopting one hand-written file as a Level-3 unit.
+ *
+ * @param {{ app: object|null, modules: Record<string, object> }} specs
+ * @param {{ module: string, path: string, source: string|null }} file
+ * @returns {{ path, adoptable: false, reason } |
+ *           { path, adoptable: true, address, kind, name, ops, inferred, notes }}
+ */
+export function adoptUnit(specs, { module, path, source }) {
+	const no = (reason) => ({ path, adoptable: false, reason });
+
+	const moduleSpec = specs.modules?.[module];
+	if (!moduleSpec) return no(`module "${module}" is not in specs — add the module before adopting into it`);
+	if (typeof source !== 'string' || source.trim() === '') return no(`no source at ${path}`);
+
+	const name = nameFromPath(path);
+	if (!name) return no(`could not derive a unit name from "${path}"`);
+
+	const kindMatch = inferKind(source, path);
+	if (!kindMatch) return no('file has no recognisable exports — nothing to wrap as a unit');
+	const { kind, evidence: kindEvidence } = kindMatch;
+
+	const existing = moduleSpec[KIND_KEYS[kind]]?.[name];
+	if (existing) return no(`${module}.${kind}.${name} already exists — rename the file or the unit`);
+
+	const { capabilities, evidence: capabilityEvidence } = inferCapabilities(source);
+	const { auth, evidence: authEvidence } = inferAuth(source);
+
+	const value = { source: String(path), auth };
+	if (capabilities.length > 0) value.capabilities = capabilities;
+	if (kind === 'Worker' && /extends\s+DurableObject\b|webSocketMessage/.test(source)) value.room = true;
+
+	const address = `${module}.${kind}.${name}`;
+	return {
+		path,
+		adoptable: true,
+		address,
+		kind,
+		name,
+		ops: [{ op: 'set', path: address, value }],
+		inferred: { kind: kindEvidence, capabilities: capabilityEvidence, auth: authEvidence },
+		notes: [
+			`auth was inferred as "${auth}" (${authEvidence}) — auth is a declaration, confirm it before applying`,
+			'adopting declares ownership and capabilities; the file itself stays hand-written (Level 3)'
+		]
+	};
+}
+
+/**
+ * Adopt several files at once (the `spec.adopt {path}` directory case).
+ *
+ * @param {{ app: object|null, modules: Record<string, object> }} specs
+ * @param {{ module: string, files: Array<{ path: string, source: string|null }> }} input
+ */
+export function adoptFiles(specs, { module, files }) {
+	return { proposals: files.map(({ path, source }) => adoptUnit(specs, { module, path, source })) };
+}

package/src/kernel/emit-machines.js

@@ -0,0 +1,87 @@
+/**
+ * Status machines (K-17): every entity with a `status` map gets, in
+ * `lib/<module>/machines.c`:
+ *
+ *   - `<Entity>Machine := machine(<Entity>Status)` — the runtime machine
+ *     over the transition map the schema emitter already exports, and
+ *   - `transition<Entity>` — a policy-wrapped generic transition Action
+ *     (`{ id, to }`); only legal edges pass (`machine.assert` → 409),
+ *     and it emits `<module>.<Entity>.transitioned` for triggers.
+ *
+ * Authored actions stay the named, guarded edges (`submit`, `win`, …);
+ * this is the structural fallback that makes every edge reachable
+ * without hand-writing an action per edge.
+ */
+
+const header = (moduleName) =>
+	`// GENERATED by \`norns generate\` from specs/${moduleName}.tron — do not edit.`;
+
+export function emitModuleMachines(moduleName, moduleSpec) {
+	const entities = Object.entries(moduleSpec.entities ?? {})
+		.filter(([, e]) => Object.keys(e?.status ?? {}).length > 0)
+		.sort(([a], [b]) => (a < b ? -1 : 1));
+	if (entities.length === 0) return null;
+
+	const schemaImports = [];
+	const policyImports = [];
+	const blocks = [];
+
+	for (const [name, entity] of entities) {
+		const states = Object.keys(entity.status).sort();
+		const policy = moduleSpec.policies?.[name];
+		schemaImports.push(name, `${name}Status`);
+		if (policy?.write !== undefined) policyImports.push(`${name}Policy`);
+
+		const body = [
+			`\t\tconst db = container.resolve('db')`,
+			`\t\tconst row = (await db.select().from(${name}).where(eq(${name}.id, input.id)).limit(1))[0]`,
+			`\t\tif (!row) throw error(404, ${JSON.stringify(`${name} not found`)})`
+		];
+		if (policy?.write !== undefined) {
+			body.push(`\t\tif (!${name}Policy.write.check(row, user)) throw error(403, 'forbidden')`);
+		}
+		body.push(
+			`\t\t${name}Machine.assert(row.status, input.to)`,
+			`\t\tawait db.update(${name}).set({ status: input.to }).where(eq(${name}.id, input.id))`,
+			`\t\tawait container.resolve('events').emit(${JSON.stringify(`${moduleName}.${name}.transitioned`)}, { row, input, user })`,
+			`\t\treturn { ok: true }`
+		);
+
+		blocks.push(`export ${name}Machine := machine(${name}Status)`);
+		blocks.push(
+			[
+				`export transition${name} := {`,
+				[
+					`\taddress: ${JSON.stringify(`${moduleName}.Action.transition${name}`)}`,
+					`\tinput: v.strictObject({ id: v.string(), to: v.picklist(${JSON.stringify(states)}) })`,
+					[`\trun: async ({ input, container, user }) => {`, ...body, `\t}`].join('\n')
+				].join(',\n'),
+				`}`
+			].join('\n')
+		);
+	}
+
+	const lines = [
+		header(moduleName),
+		'',
+		`import { error } from '@sveltejs/kit'`,
+		`import { eq } from 'drizzle-orm'`,
+		`import * as v from 'valibot'`,
+		`import { machine } from '@human-synthesis/norns/server'`,
+		'',
+		`import { ${schemaImports.join(', ')} } from './schema.c'`
+	];
+	if (policyImports.length > 0) {
+		lines.push(`import { ${policyImports.join(', ')} } from './policies.c'`);
+	}
+	lines.push('', blocks.join('\n\n'), '');
+	return { path: `lib/${moduleName}/machines.c`, text: lines.join('\n') };
+}
+
+export const machinesEmitter = {
+	name: 'machines',
+	emit: ({ moduleName, moduleSpec }) => {
+		const file = emitModuleMachines(moduleName, moduleSpec);
+		return file ? [file] : [];
+	}
+};

package/src/kernel/emit-schema.js

@@ -0,0 +1,199 @@
+/**
+ * Entity emitter (K-10): every entity in a module becomes a Drizzle table,
+ * a valibot schema, and (if it has one) a status-machine map, emitted as
+ * Civet into `lib/<module>/schema.c`. Dialect comes from `specs/app.tron`:
+ * sqlite/d1 emit sqliteTable, postgres emits pgTable (K-16).
+ *
+ * Conventions:
+ *   - implicit `id` text primary key on every entity
+ *   - `money` is integer cents; `date`/`datetime` are timestamp integers
+ *   - `optional: true` → nullable column + v.optional in the schema
+ *   - the initial status state is the one no transition targets; output is
+ *     sorted, so emission is independent of spec key order
+ *   - `<Entity>Input` = schema minus `id` (for action/form input)
+ */
+
+const SQLITE_COLUMNS = {
+	text: (col) => `text('${col}')`,
+	email: (col) => `text('${col}')`,
+	url: (col) => `text('${col}')`,
+	file: (col) => `text('${col}')`,
+	ref: (col) => `text('${col}')`,
+	int: (col) => `integer('${col}')`,
+	money: (col) => `integer('${col}')`,
+	number: (col) => `real('${col}')`,
+	bool: (col) => `integer('${col}', { mode: 'boolean' })`,
+	date: (col) => `integer('${col}', { mode: 'timestamp' })`,
+	datetime: (col) => `integer('${col}', { mode: 'timestamp' })`,
+	json: (col) => `text('${col}', { mode: 'json' })`
+};
+
+const SQLITE_IMPORT = {
+	text: 'text',
+	email: 'text',
+	url: 'text',
+	file: 'text',
+	ref: 'text',
+	int: 'integer',
+	money: 'integer',
+	number: 'real',
+	bool: 'integer',
+	date: 'integer',
+	datetime: 'integer',
+	json: 'text'
+};
+
+const PG_COLUMNS = {
+	text: (col) => `text('${col}')`,
+	email: (col) => `text('${col}')`,
+	url: (col) => `text('${col}')`,
+	file: (col) => `text('${col}')`,
+	ref: (col) => `text('${col}')`,
+	int: (col) => `integer('${col}')`,
+	money: (col) => `integer('${col}')`,
+	number: (col) => `doublePrecision('${col}')`,
+	bool: (col) => `boolean('${col}')`,
+	// mode 'date' matches the sqlite timestamp columns, so runtime code sees
+	// Date objects under either dialect
+	date: (col) => `timestamp('${col}', { mode: 'date' })`,
+	datetime: (col) => `timestamp('${col}', { mode: 'date' })`,
+	json: (col) => `jsonb('${col}')`
+};
+
+const PG_IMPORT = {
+	text: 'text',
+	email: 'text',
+	url: 'text',
+	file: 'text',
+	ref: 'text',
+	int: 'integer',
+	money: 'integer',
+	number: 'doublePrecision',
+	bool: 'boolean',
+	date: 'timestamp',
+	datetime: 'timestamp',
+	json: 'jsonb'
+};
+
+const DIALECT_TABLES = {
+	d1: { table: 'sqliteTable', from: 'drizzle-orm/sqlite-core', columns: SQLITE_COLUMNS, imports: SQLITE_IMPORT },
+	sqlite: { table: 'sqliteTable', from: 'drizzle-orm/sqlite-core', columns: SQLITE_COLUMNS, imports: SQLITE_IMPORT },
+	postgres: { table: 'pgTable', from: 'drizzle-orm/pg-core', columns: PG_COLUMNS, imports: PG_IMPORT }
+};
+
+export const VALIBOT = {
+	text: 'v.string()',
+	file: 'v.string()',
+	ref: 'v.string()',
+	email: 'v.pipe(v.string(), v.email())',
+	url: 'v.pipe(v.string(), v.url())',
+	int: 'v.pipe(v.number(), v.integer())',
+	money: 'v.pipe(v.number(), v.integer())',
+	number: 'v.number()',
+	bool: 'v.boolean()',
+	date: 'v.pipe(v.string(), v.isoDate())',
+	datetime: 'v.pipe(v.string(), v.isoTimestamp())',
+	json: 'v.unknown()'
+};
+
+const snake = (name) => name.replace(/([a-z0-9])([A-Z])/g, '$1_$2').toLowerCase();
+
+export const normalizeField = (f) => (typeof f === 'string' ? { type: f } : f);
+
+/** The state no transition targets; falls back to the (sorted) first. */
+function initialState(status) {
+	const states = Object.keys(status).sort();
+	const targeted = new Set(Object.values(status).flat());
+	const sources = states.filter((s) => !targeted.has(s));
+	return sources.length === 1 ? sources[0] : states[0];
+}
+
+/**
+ * Emit `lib/<module>/schema.c` for one module, or null when it has no
+ * entities.
+ *
+ * @param {string} moduleName
+ * @param {*} moduleSpec
+ * @returns {{ path: string, text: string } | null}
+ */
+export function emitModuleSchema(moduleName, moduleSpec, dialect = 'd1') {
+	const entities = Object.entries(moduleSpec?.entities ?? {});
+	if (entities.length === 0) return null;
+	const { table, from, columns: COLUMNS, imports: IMPORTS } = DIALECT_TABLES[dialect] ?? DIALECT_TABLES.d1;
+
+	const columnFns = new Set(['text']); // id column is always text
+	const blocks = [];
+
+	for (const [name, entity] of entities.sort(([a], [b]) => (a < b ? -1 : 1))) {
+		const fields = Object.entries(entity.fields ?? {})
+			.map(([f, def]) => [f, normalizeField(def)])
+			.sort(([a], [b]) => (a < b ? -1 : 1));
+		const states = Object.keys(entity.status ?? {}).sort();
+
+		const columns = [`\tid: text('id').primaryKey()`];
+		for (const [fieldName, def] of fields) {
+			columnFns.add(IMPORTS[def.type]);
+			let col = `\t${fieldName}: ${COLUMNS[def.type](snake(fieldName))}`;
+			if (!def.optional) col += '.notNull()';
+			if (def.unique) col += '.unique()';
+			if (def.default !== undefined) col += `.default(${JSON.stringify(def.default)})`;
+			columns.push(col);
+		}
+		if (states.length > 0) {
+			columns.push(
+				`\tstatus: text('status').notNull().default(${JSON.stringify(initialState(entity.status))})`
+			);
+		}
+
+		const schemaFields = [`\tid: v.string()`];
+		for (const [fieldName, def] of fields) {
+			const base = VALIBOT[def.type];
+			schemaFields.push(`\t${fieldName}: ${def.optional ? `v.optional(${base})` : base}`);
+		}
+		if (states.length > 0) {
+			schemaFields.push(`\tstatus: v.picklist(${JSON.stringify(states)})`);
+		}
+
+		const lines = [
+			`export ${name} := ${table}('${snake(moduleName)}_${snake(name)}', {`,
+			columns.join(',\n'),
+			`})`,
+			``
+		];
+		if (states.length > 0) {
+			const rows = states.map(
+				(s) => `\t${s}: [${entity.status[s].map((t) => JSON.stringify(t)).join(', ')}]`
+			);
+			lines.push(`export ${name}Status := {`, rows.join(',\n'), `}`, ``);
+		}
+		lines.push(
+			`export ${name}Schema := v.strictObject({`,
+			schemaFields.join(',\n'),
+			`})`,
+			``,
+			`export ${name}Input := v.omit(${name}Schema, ['id'])`
+		);
+		blocks.push(lines.join('\n'));
+	}
+
+	const imports = [...columnFns].sort().join(', ');
+	const text = [
+		`// GENERATED by \`norns generate\` from specs/${moduleName}.tron — do not edit.`,
+		`import { ${table}, ${imports} } from '${from}'`,
+		`import * as v from 'valibot'`,
+		``,
+		blocks.join('\n\n'),
+		``
+	].join('\n');
+
+	return { path: `lib/${moduleName}/schema.c`, text };
+}
+
+/** @type {{ name: string, emit: (ctx: *) => { path: string, text: string }[] }} */
+export const schemaEmitter = {
+	name: 'schema',
+	emit({ moduleName, moduleSpec, specs }) {
+		const file = emitModuleSchema(moduleName, moduleSpec, specs?.app?.dialect ?? 'd1');
+		return file ? [file] : [];
+	}
+};