@human-synthesis/norns 0.0.16 → 0.1.0

package/src/kernel/emit-units.js

@@ -0,0 +1,587 @@
+/**
+ * Unit templates (K-12): Query, Action, Policy, Page, Trigger.
+ *
+ * Guard-first by construction: emitted actions check the entity's write
+ * policy (and any per-action run rule) before touching the database;
+ * emitted queries AND the read policy's row rule into every select. All
+ * iteration is over sorted keys so output is independent of spec key
+ * order. Level-2 (`impl: custom`) actions and pages emit shells (K-13):
+ * the generated code keeps the guards and the contract, then delegates to
+ * the hand-written body imported via the `$custom` alias (→ `src/`).
+ */
+
+import { isAddress, parseAddress } from './address.js';
+import { VALIBOT, normalizeField } from './emit-schema.js';
+import { compileGuard } from './expr-compile.js';
+import { parseExpr } from './expr.js';
+
+const header = (moduleName) =>
+	`// GENERATED by \`norns generate\` from specs/${moduleName}.tron — do not edit.`;
+
+const pascal = (name) => name[0].toUpperCase() + name.slice(1);
+
+/** `Order` (in-module) or `catalog.Entity.Product` → { module, entity }. */
+function resolveEntityRef(moduleName, ref) {
+	if (isAddress(ref)) {
+		const parsed = parseAddress(ref);
+		return { module: parsed.module, entity: parsed.name };
+	}
+	return { module: moduleName, entity: ref };
+}
+
+function policyFor(specs, module, entity) {
+	return specs.modules[module]?.policies?.[entity];
+}
+
+function ownerFieldOf(specs, module, entity) {
+	return specs.modules[module]?.entities?.[entity]?.owner;
+}
+
+/** Relative import prefix from a file at `depth` dirs below the generated root. */
+const up = (depth) => '../'.repeat(depth);
+
+/**
+ * In specs, `status == draft` compares against the state *name* — the
+ * canonical form is unquoted (PLAN §5.2). The parser reads `draft` as a
+ * path, so rewrite single-segment paths that name a state of the target
+ * entity into literals when compared with `status`.
+ */
+function withStateLiterals(node, states) {
+	if (!node || typeof node !== 'object' || !node.op) return node;
+	if (node.op === 'and' || node.op === 'or' || node.op === 'not') {
+		return { op: node.op, args: node.args.map((a) => withStateLiterals(a, states)) };
+	}
+	const isStatus = (n) => n.path?.length === 1 && n.path[0] === 'status';
+	const asState = (n) =>
+		n.path?.length === 1 && states.has(n.path[0]) ? { lit: n.path[0] } : n;
+	let [a, b] = node.args;
+	if (isStatus(a)) b = asState(b);
+	else if (isStatus(b)) a = asState(a);
+	return { op: node.op, args: [a, b] };
+}
+
+function statesOf(specs, module, entity) {
+	return new Set(Object.keys(specs.modules[module]?.entities?.[entity]?.status ?? {}));
+}
+
+function parseUnitExpr(exprSrc, states) {
+	return withStateLiterals(parseExpr(exprSrc), states ?? new Set());
+}
+
+function whereCall(exprSrc, { entity, ownerField, states }) {
+	const ast = JSON.stringify(parseUnitExpr(exprSrc, states));
+	const owner = ownerField ? `, ownerField: ${JSON.stringify(ownerField)}` : '';
+	return `compileWhere(${ast}, { table: ${entity}, ops, user${owner} })`;
+}
+
+function guardExpr(exprSrc, ownerField, states) {
+	return compileGuard(parseUnitExpr(exprSrc, states), { ownerField });
+}
+
+/* ------------------------------------------------------------------ */
+/* Policies → lib/<module>/policies.c                                  */
+/* ------------------------------------------------------------------ */
+
+export function emitModulePolicies(moduleName, moduleSpec, specs) {
+	const policies = moduleSpec.policies ?? {};
+	const names = Object.keys(policies).sort();
+	if (names.length === 0) return null;
+
+	const lines = [header(moduleName), '', `import { compileWhere } from '@human-synthesis/norns/server'`, '', `import { ${names.join(', ')} } from './schema.c'`, ''];
+
+	for (const entity of names) {
+		const policy = policies[entity];
+		const ownerField = ownerFieldOf(specs, moduleName, entity);
+		const states = statesOf(specs, moduleName, entity);
+		const owner = ownerField ? `, ownerField: ${JSON.stringify(ownerField)}` : '';
+		const body = [`\tentity: ${entity}`];
+		if (ownerField) body.push(`\townerField: ${JSON.stringify(ownerField)}`);
+		for (const rule of ['read', 'write']) {
+			if (policy[rule] === undefined) continue;
+			const ast = JSON.stringify(parseUnitExpr(policy[rule], states));
+			body.push(
+				[
+					`\t${rule}: {`,
+					`\t\tcheck: (row, user) => ${guardExpr(policy[rule], ownerField, states)},`,
+					`\t\twhere: (ops, user) => compileWhere(${ast}, { table: ${entity}, ops, user${owner} })`,
+					`\t}`
+				].join('\n')
+			);
+		}
+		const runs = Object.keys(policy.run ?? {}).sort();
+		if (runs.length > 0) {
+			body.push(
+				[
+					`\trun: {`,
+					runs
+						.map((a) => `\t\t${a}: (row, user) => ${guardExpr(policy.run[a], ownerField, states)}`)
+						.join(',\n'),
+					`\t}`
+				].join('\n')
+			);
+		}
+		lines.push(`export ${entity}Policy := {`, body.join(',\n'), `}`, '');
+	}
+	return { path: `lib/${moduleName}/policies.c`, text: lines.join('\n') };
+}
+
+/* ------------------------------------------------------------------ */
+/* Queries → lib/<module>/queries.c                                    */
+/* ------------------------------------------------------------------ */
+
+const OPS_CONST = `ops := { 'and': dz.and, 'or': dz.or, 'not': dz.not, eq: dz.eq, ne: dz.ne, lt: dz.lt, lte: dz.lte, gt: dz.gt, gte: dz.gte, inArray: dz.inArray, bool: (b) => b ? dz.sql\`1 = 1\` : dz.sql\`1 = 0\` }`;
+
+const GROUP_ROWS = [
+	`groupRows := (rows, key) => {`,
+	`\tconst out = {}`,
+	`\tfor (const row of rows) (out[row[key]] ??= []).push(row)`,
+	`\treturn out`,
+	`}`
+].join('\n');
+
+export function emitModuleQueries(moduleName, moduleSpec, specs) {
+	const queries = moduleSpec.queries ?? {};
+	const names = Object.keys(queries).sort();
+	if (names.length === 0) return null;
+
+	const entityImports = new Map();
+	const policyImports = new Map();
+	const fns = [];
+	let needsGroup = false;
+	let needsWhere = false;
+
+	for (const name of names) {
+		const q = queries[name];
+		const { module, entity } = resolveEntityRef(moduleName, q.from);
+		const local = module === moduleName ? './' : `../${module}/`;
+		entityImports.set(entity, `${local}schema.c`);
+
+		const policy = policyFor(specs, module, entity);
+		const ownerField = ownerFieldOf(specs, module, entity);
+		const wheres = [];
+		if (policy?.read !== undefined) {
+			policyImports.set(`${entity}Policy`, `${local}policies.c`);
+			wheres.push(`${entity}Policy.read.where(ops, ctx.user)`);
+		}
+		if (q.filter !== undefined) {
+			needsWhere = true;
+			wheres.push(whereCall(q.filter, { entity, ownerField, states: statesOf(specs, module, entity) }));
+		}
+
+		const chain = [`db.select().from(${entity})`];
+		if (wheres.length === 1) chain.push(`.where(${wheres[0]})`);
+		else if (wheres.length > 1) chain.push(`.where(dz.and(${wheres.join(', ')}))`);
+		for (const sort of [q.sort ?? []].flat()) {
+			const desc = sort.startsWith('-');
+			chain.push(`.orderBy(dz.${desc ? 'desc' : 'asc'}(${entity}.${desc ? sort.slice(1) : sort}))`);
+		}
+		if (q.limit !== undefined) chain.push(`.limit(${q.limit})`);
+
+		const body = [
+			`export ${name} := async (ctx) => {`,
+			`\tconst db = ctx.container.resolve('db')`,
+			`\tconst rows = await ${chain.join('')}`
+		];
+		if (q.groupBy) {
+			needsGroup = true;
+			body.push(`\treturn groupRows(rows, ${JSON.stringify(q.groupBy)})`);
+		} else {
+			body.push(`\treturn rows`);
+		}
+		body.push(`}`);
+		fns.push(body.join('\n'));
+	}
+
+	const lines = [header(moduleName), '', `import * as dz from 'drizzle-orm'`];
+	if (needsWhere) lines.push(`import { compileWhere } from '@human-synthesis/norns/server'`);
+	lines.push('');
+	for (const [file, names_] of groupImports(entityImports)) {
+		lines.push(`import { ${names_.join(', ')} } from '${file}'`);
+	}
+	for (const [file, names_] of groupImports(policyImports)) {
+		lines.push(`import { ${names_.join(', ')} } from '${file}'`);
+	}
+	lines.push('', OPS_CONST, '');
+	if (needsGroup) lines.push(GROUP_ROWS, '');
+	lines.push(fns.join('\n\n'), '');
+	return { path: `lib/${moduleName}/queries.c`, text: lines.join('\n') };
+}
+
+function groupImports(map) {
+	const byFile = new Map();
+	for (const [name, file] of [...map.entries()].sort(([a], [b]) => a.localeCompare(b))) {
+		if (!byFile.has(file)) byFile.set(file, []);
+		byFile.get(file).push(name);
+	}
+	return [...byFile.entries()].sort(([a], [b]) => a.localeCompare(b));
+}
+
+/* ------------------------------------------------------------------ */
+/* Actions → lib/<module>/actions.c                                    */
+/* ------------------------------------------------------------------ */
+
+/** The entity an action operates on: first `set` step, else its input refs. */
+export function actionEntity(moduleName, action, specs) {
+	for (const step of action.steps ?? []) {
+		if (step.set?.entity) return resolveEntityRef(moduleName, step.set.entity);
+	}
+	for (const key of Object.keys(action.input ?? {}).sort()) {
+		const ref = action.input[key];
+		if (typeof ref !== 'string') continue;
+		const entity = ref.replace(/\?$/, '').split('.')[0];
+		if (specs.modules[moduleName]?.entities?.[entity]) return { module: moduleName, entity };
+	}
+	return null;
+}
+
+function inputSchema(moduleName, action, specs) {
+	const input = action.input ?? {};
+	const keys = Object.keys(input).sort();
+	if (keys.length === 0) return null;
+	const fields = keys.map((key) => {
+		const ref = input[key];
+		let schema = 'v.unknown()';
+		if (typeof ref === 'string') {
+			const optional = ref.endsWith('?');
+			const [entity, field] = ref.replace(/\?$/, '').split('.');
+			const def =
+				field === 'id'
+					? { type: 'text' }
+					: normalizeField(specs.modules[moduleName]?.entities?.[entity]?.fields?.[field] ?? 'text');
+			schema = VALIBOT[def.type] ?? 'v.string()';
+			if (optional) schema = `v.optional(${schema})`;
+		}
+		return `${key}: ${schema}`;
+	});
+	return `v.strictObject({ ${fields.join(', ')} })`;
+}
+
+export function emitModuleActions(moduleName, moduleSpec, specs) {
+	const actions = moduleSpec.actions ?? {};
+	const names = Object.keys(actions).sort();
+	if (names.length === 0) return null;
+
+	const entityImports = new Map();
+	const policyImports = new Map();
+	const customImports = [];
+	const fns = [];
+
+	for (const name of names) {
+		const action = actions[name];
+		const custom = action.impl === 'custom';
+		const target = actionEntity(moduleName, action, specs);
+		const address = `${moduleName}.Action.${name}`;
+		const body = [];
+
+		if (target) {
+			const { module, entity } = target;
+			const local = module === moduleName ? './' : `../${module}/`;
+			entityImports.set(entity, `${local}schema.c`);
+			const policy = policyFor(specs, module, entity);
+			const ownerField = ownerFieldOf(specs, module, entity);
+			const idKey =
+				Object.keys(action.input ?? {})
+					.sort()
+					.find((k) => action.input[k] === `${entity}.id`) ?? 'id';
+
+			body.push(
+				`\t\tconst db = container.resolve('db')`,
+				`\t\tconst row = (await db.select().from(${entity}).where(eq(${entity}.id, input.${idKey})).limit(1))[0]`,
+				`\t\tif (!row) throw error(404, ${JSON.stringify(`${entity} not found`)})`
+			);
+			if (policy?.write !== undefined) {
+				policyImports.set(`${entity}Policy`, `${local}policies.c`);
+				body.push(`\t\tif (!${entity}Policy.write.check(row, user)) throw error(403, 'forbidden')`);
+			}
+			if (policy?.run?.[name] !== undefined) {
+				policyImports.set(`${entity}Policy`, `${local}policies.c`);
+				body.push(`\t\tif (!${entity}Policy.run.${name}(row, user)) throw error(403, 'forbidden')`);
+			}
+			if (action.requires !== undefined) {
+				body.push(
+					`\t\tif (!(${guardExpr(action.requires, ownerField, statesOf(specs, module, entity))})) throw error(409, ${JSON.stringify(`requires failed: ${action.requires}`)})`
+				);
+			}
+			if (custom) {
+				body.push(`\t\treturn ${name}Body({ row, input, container, user })`);
+			}
+			for (const step of custom ? [] : (action.steps ?? [])) {
+				if (step.set) {
+					const { entity: setEntity, ...fields } = step.set;
+					const sets = Object.keys(fields)
+						.sort()
+						.map((f) => `${f}: ${JSON.stringify(fields[f])}`);
+					// K-17: a status write must be a legal edge of the entity's
+					// machine, independent of any authored `requires` guard.
+					if ('status' in fields && statesOf(specs, module, entity).size > 0) {
+						entityImports.set(`${entity}Status`, `${local}schema.c`);
+						const to = JSON.stringify(fields.status);
+						body.push(
+							`\t\tif (!(${entity}Status[row.status] ?? []).includes(${to})) throw error(409, 'invalid transition ' + row.status + ' -> ' + ${to})`
+						);
+					}
+					body.push(
+						`\t\tawait db.update(${entity}).set({ ${sets.join(', ')} }).where(eq(${entity}.id, input.${idKey}))`
+					);
+				} else if (step.emit) {
+					body.push(
+						`\t\tawait container.resolve('events').emit(${JSON.stringify(step.emit)}, { row, input, user })`
+					);
+				} else if (step.call) {
+					body.push(`\t\tawait container.resolve(${JSON.stringify(step.call)})({ row, input, user })`);
+				}
+			}
+			for (const evt of custom ? [] : (action.emits ?? [])) {
+				body.push(
+					`\t\tawait container.resolve('events').emit(${JSON.stringify(evt)}, { row, input, user })`
+				);
+			}
+		} else if (custom) {
+			body.push(`\t\treturn ${name}Body({ input, container, user })`);
+		}
+		if (custom) {
+			customImports.push(`import ${name}Body from '$custom/${moduleName}/actions/${name}.c'`);
+		} else {
+			body.push(`\t\treturn { ok: true }`);
+		}
+
+		const schema = inputSchema(moduleName, action, specs);
+		const props = [`\taddress: ${JSON.stringify(address)}`];
+		if (schema) props.push(`\tinput: ${schema}`);
+		if (action.refresh) props.push(`\trefresh: ${JSON.stringify(action.refresh)}`);
+		props.push([`\trun: async ({ input, container, user }) => {`, ...body, `\t}`].join('\n'));
+		fns.push([`export ${name} := {`, props.join(',\n'), `}`].join('\n'));
+	}
+
+	const lines = [header(moduleName), '', `import { error } from '@sveltejs/kit'`, `import { eq } from 'drizzle-orm'`, `import * as v from 'valibot'`, ''];
+	for (const [file, names_] of groupImports(entityImports)) {
+		lines.push(`import { ${names_.join(', ')} } from '${file}'`);
+	}
+	for (const [file, names_] of groupImports(policyImports)) {
+		lines.push(`import { ${names_.join(', ')} } from '${file}'`);
+	}
+	lines.push(...customImports);
+	lines.push('', fns.join('\n\n'), '');
+	return { path: `lib/${moduleName}/actions.c`, text: lines.join('\n') };
+}
+
+/* ------------------------------------------------------------------ */
+/* Triggers → lib/<module>/triggers.c                                  */
+/* ------------------------------------------------------------------ */
+
+export function emitModuleTriggers(moduleName, moduleSpec) {
+	const triggers = moduleSpec.triggers ?? {};
+	const names = Object.keys(triggers).sort();
+	if (names.length === 0) return null;
+
+	const actionImports = new Map();
+	const entries = [];
+	for (const name of names) {
+		const t = triggers[name];
+		const spec = typeof t === 'string' ? { action: t } : t;
+		const parsed = parseAddress(spec.action);
+		const local = parsed.module === moduleName ? './' : `../${parsed.module}/`;
+		actionImports.set(parsed.name, `${local}actions.c`);
+		const props = [`on: ${JSON.stringify(name)}`, `action: ${parsed.name}`];
+		if (spec.schedule) props.push(`schedule: ${JSON.stringify(spec.schedule)}`);
+		if (spec.source) props.push(`source: ${JSON.stringify(spec.source)}`);
+		entries.push(`\t{ ${props.join(', ')} }`);
+	}
+
+	const lines = [header(moduleName), ''];
+	for (const [file, names_] of groupImports(actionImports)) {
+		lines.push(`import { ${names_.join(', ')} } from '${file}'`);
+	}
+	lines.push('', `export triggers := [`, entries.join(',\n'), `]`, '');
+	return { path: `lib/${moduleName}/triggers.c`, text: lines.join('\n') };
+}
+
+/* ------------------------------------------------------------------ */
+/* Remote actions → routes/api/<module>/<action>/+server.c             */
+/* ------------------------------------------------------------------ */
+
+/**
+ * Actions with `transport: 'remote'` also get a POST endpoint wrapping the
+ * same generated unit (schema + guards + refresh publication ride along
+ * via `remoteAction`). Client side: `remoteCall` in `norns/live-client`.
+ */
+export function emitModuleRemotes(moduleName, moduleSpec) {
+	const actions = moduleSpec.actions ?? {};
+	const names = Object.keys(actions)
+		.filter((n) => actions[n]?.transport === 'remote')
+		.sort();
+	if (names.length === 0) return null;
+
+	return names.map((name) => ({
+		path: `routes/api/${moduleName}/${name}/+server.c`,
+		text: [
+			header(moduleName),
+			'',
+			`import { remoteAction } from '@human-synthesis/norns/server'`,
+			'',
+			`import { ${name} } from '${up(4)}lib/${moduleName}/actions.c'`,
+			'',
+			`export POST := remoteAction(${name})`,
+			''
+		].join('\n')
+	}));
+}
+
+/* ------------------------------------------------------------------ */
+/* Pages → routes<route>/+page.server.c + +page.n                      */
+/* ------------------------------------------------------------------ */
+
+/** '/orders/:id' → ['orders', '[id]'] */
+function routeSegments(route) {
+	return route
+		.split('/')
+		.filter(Boolean)
+		.map((seg) => (seg.startsWith(':') ? `[${seg.slice(1)}]` : seg));
+}
+
+/** Collect { queries, actions, components } bound by a page spec. */
+function pageBindings(pageSpec) {
+	const queries = new Map();
+	const actions = new Map();
+	const components = [];
+	for (const entry of pageSpec.components ?? []) {
+		const keys = Object.keys(entry);
+		if (keys.length === 0) continue;
+		const [first, ...rest] = keys;
+		const component = { tag: pascal(first), props: [] };
+		for (const key of keys) {
+			const value = entry[key];
+			const parsed = typeof value === 'string' && isAddress(value) ? parseAddress(value) : null;
+			if (parsed?.kind === 'Query') {
+				queries.set(parsed.name, parsed.module);
+				component.props.push(
+					key === first
+						? `data!="{data.${parsed.name}}"`
+						: `${key}!="{data.${parsed.name}}"`
+				);
+			} else if (parsed?.kind === 'Action') {
+				actions.set(parsed.name, parsed.module);
+				// an Action in the component slot is the form target, so it binds
+				// the conventional `action` prop rather than the slot key
+				component.props.push(`${key === first ? 'action' : key}="?/${parsed.name}"`);
+			} else if (typeof value === 'string' && key !== first) {
+				component.props.push(`${key}=${JSON.stringify(value)}`);
+			} else if ((typeof value === 'number' || typeof value === 'boolean') && key !== first) {
+				component.props.push(`${key}!="{${JSON.stringify(value)}}"`);
+			}
+		}
+		components.push(component);
+	}
+	return { queries, actions, components };
+}
+
+export function emitModulePages(moduleName, moduleSpec, specs) {
+	const pages = moduleSpec.pages ?? {};
+	const names = Object.keys(pages).sort();
+	const files = [];
+
+	for (const name of names) {
+		const spec = pages[name];
+		const segments = routeSegments(spec.route);
+		const dir = ['routes', ...segments].join('/');
+		const lib = up(segments.length + 1) + 'lib';
+		const { queries, actions, components } = pageBindings(spec);
+		// Queries marked `live: true` get a depends key in the load and an
+		// EventSource subscription in the page, so refresh signals from
+		// /_norns/live re-run the load (R-11).
+		const liveAddrs = [...queries]
+			.filter(([q, m]) => specs?.modules?.[m]?.queries?.[q]?.live === true)
+			.map(([q, m]) => `${m}.Query.${q}`)
+			.sort();
+
+		const lines = [header(moduleName), '', `import { page } from '@human-synthesis/norns/server'`, ''];
+		for (const [file, names_] of groupImports(
+			new Map([...queries].map(([q, m]) => [q, `${lib}/${m}/queries.c`]))
+		)) {
+			lines.push(`import { ${names_.join(', ')} } from '${file}'`);
+		}
+		for (const [file, names_] of groupImports(
+			new Map([...actions].map(([a, m]) => [a, `${lib}/${m}/actions.c`]))
+		)) {
+			lines.push(`import { ${names_.join(', ')} } from '${file}'`);
+		}
+		lines.push('');
+
+		const loads = [...queries.keys()].sort();
+		lines.push(
+			`export load := page.load({`,
+			`\thandler: async (ctx) => {`,
+			...liveAddrs.map((addr) => `\t\tctx.event.depends(${JSON.stringify(`norns:${addr}`)})`),
+			`\t\treturn { ${loads.map((q) => `${q}: await ${q}(ctx)`).join(', ')} }`,
+			`\t}`,
+			`})`
+		);
+		const acts = [...actions.keys()].sort();
+		if (acts.length > 0) {
+			lines.push('', `export actions := page.actions({`, acts.map((a) => `\t${a}: ${a}`).join(',\n'), `})`);
+		}
+		lines.push('');
+		files.push({ path: `${dir}/+page.server.c`, text: lines.join('\n') });
+
+		const liveScript = liveAddrs.length
+			? {
+					imports: [
+						`\timport { invalidate } from '$app/navigation'`,
+						`\timport { liveQueries } from '@human-synthesis/norns/live-client'`
+					],
+					effect: `\t$effect(() => liveQueries(${JSON.stringify(liveAddrs)}, invalidate))`
+				}
+			: null;
+
+		const pug = [header(moduleName), ''];
+		if (spec.impl === 'custom') {
+			// Level-2: the template body lives in src/, the generated shell
+			// stays the routing surface and passes the page contract through.
+			pug.push(
+				`Body(data!="{data}" form!="{form}")`,
+				'',
+				'<script>',
+				...(liveScript?.imports ?? []),
+				`\timport Body from '$custom/${moduleName}/pages/${name}.n'`,
+				`\t{ data, form } := $props()`,
+				...(liveScript ? [liveScript.effect] : []),
+				'</script>',
+				''
+			);
+		} else {
+			pug.push(`section.norns-page`);
+			for (const c of components) {
+				pug.push(`\t${c.tag}(${c.props.join(' ')})`);
+			}
+			const stateKeys = Object.keys(spec.state ?? {}).sort();
+			pug.push('', '<script>');
+			if (liveScript) pug.push(...liveScript.imports);
+			pug.push(`\t{ data, form } := $props()`);
+			for (const key of stateKeys) pug.push(`\t${key} := $state(null)`);
+			if (liveScript) pug.push(liveScript.effect);
+			pug.push('</script>', '');
+		}
+		files.push({ path: `${dir}/+page.n`, text: pug.join('\n') });
+	}
+	return files;
+}
+
+/* ------------------------------------------------------------------ */
+
+const single = (fn) => ({ moduleName, moduleSpec, specs }) => {
+	const file = fn(moduleName, moduleSpec, specs);
+	return file ? [file] : [];
+};
+
+export const policiesEmitter = { name: 'policies', emit: single(emitModulePolicies) };
+export const queriesEmitter = { name: 'queries', emit: single(emitModuleQueries) };
+export const actionsEmitter = { name: 'actions', emit: single(emitModuleActions) };
+export const triggersEmitter = { name: 'triggers', emit: single(emitModuleTriggers) };
+export const pagesEmitter = {
+	name: 'pages',
+	emit: ({ moduleName, moduleSpec, specs }) => emitModulePages(moduleName, moduleSpec, specs)
+};
+export const remotesEmitter = {
+	name: 'remotes',
+	emit: ({ moduleName, moduleSpec }) => emitModuleRemotes(moduleName, moduleSpec) ?? []
+};

package/src/kernel/emit-wrangler.js

@@ -0,0 +1,114 @@
+/**
+ * Wrangler config generation (R-12): the Cloudflare deploy surface is
+ * derived from the specs, not hand-maintained. `generateApp` writes
+ * `wrangler.json` into the generated root; deploy with
+ * `wrangler deploy -c .norns/generated/wrangler.json`.
+ *
+ * Binding names are fixed contracts (`DB`, `STORAGE`, `EVENTS`, `ASSETS`,
+ * `ROOM`)
+ * so runtime adapters can rely on them. Account-specific values live in
+ * `app.settings.cloudflare` — spec-canonical, like everything else:
+ *
+ *   settings: { cloudflare: { d1_id: '…', compatibility_date: '…', queue: true } }
+ */
+
+// Pinned so regeneration is deterministic; bump deliberately with runtime upgrades.
+const DEFAULT_COMPAT_DATE = '2025-06-01';
+
+const fieldType = (f) => (typeof f === 'string' ? f : f?.type);
+
+function hasFileFields(specs) {
+	for (const mod of Object.values(specs.modules)) {
+		for (const entity of Object.values(mod.entities ?? {})) {
+			for (const field of Object.values(entity?.fields ?? {})) {
+				if (fieldType(field) === 'file') return true;
+			}
+		}
+	}
+	return false;
+}
+
+/** A Room DO is needed for live queries and for Worker units marked `room`. */
+function needsRoom(specs) {
+	for (const mod of Object.values(specs.modules)) {
+		for (const query of Object.values(mod.queries ?? {})) {
+			if (query?.live === true) return true;
+		}
+		for (const worker of Object.values(mod.workers ?? {})) {
+			if (worker?.room === true) return true;
+		}
+	}
+	return false;
+}
+
+function cronSchedules(specs) {
+	const crons = new Set();
+	for (const mod of Object.values(specs.modules)) {
+		for (const trigger of Object.values(mod.triggers ?? {})) {
+			if (typeof trigger?.schedule === 'string') crons.add(trigger.schedule);
+		}
+	}
+	return [...crons].sort();
+}
+
+/**
+ * Build the wrangler configuration object for an app's specs.
+ *
+ * @param {{ app?: *, modules: Record<string, *> }} specs loaded specs (loadSpecs shape)
+ * @returns {object} wrangler config, JSON-serializable
+ */
+export function wranglerConfig(specs) {
+	const app = specs.app ?? {};
+	const cf = app.settings?.cloudflare ?? {};
+	const name = (app.name ?? 'app').toLowerCase().replaceAll('_', '-');
+	const dialect = app.dialect ?? 'd1';
+
+	const config = {
+		name,
+		main: '.svelte-kit/cloudflare/_worker.js',
+		compatibility_date: cf.compatibility_date ?? DEFAULT_COMPAT_DATE,
+		compatibility_flags: ['nodejs_compat'],
+		assets: { binding: 'ASSETS', directory: '.svelte-kit/cloudflare' }
+	};
+
+	if (dialect === 'd1') {
+		config.d1_databases = [
+			{
+				binding: 'DB',
+				database_name: `${name}-db`,
+				database_id: cf.d1_id ?? '<set app.settings.cloudflare.d1_id>'
+			}
+		];
+	}
+
+	if (hasFileFields(specs) || cf.r2 === true) {
+		config.r2_buckets = [{ binding: 'STORAGE', bucket_name: `${name}-storage` }];
+	}
+
+	if (cf.queue === true) {
+		const queue = `${name}-events`;
+		config.queues = {
+			producers: [{ binding: 'EVENTS', queue }],
+			consumers: [{ queue }]
+		};
+	}
+
+	if (needsRoom(specs)) {
+		const className = cf.room_class ?? 'NornsRoom';
+		config.durable_objects = { bindings: [{ name: 'ROOM', class_name: className }] };
+		config.migrations = [{ tag: 'norns-room-v1', new_classes: [className] }];
+	}
+
+	const crons = cronSchedules(specs);
+	if (crons.length > 0) config.triggers = { crons };
+
+	return config;
+}
+
+/** @param {*} specs @returns {{ path: string, text: string }} */
+export function wranglerFile(specs) {
+	return {
+		path: 'wrangler.json',
+		text: JSON.stringify(wranglerConfig(specs), null, '\t') + '\n'
+	};
+}