@human-synthesis/norns 0.0.16 → 0.1.0

package/src/kernel/generate.js

@@ -0,0 +1,397 @@
+/**
+ * Generator pipeline (K-09): load → validate → refuse → plan → emit.
+ *
+ * Incremental by module hash: a cache under `.norns/cache/generate.json`
+ * records the per-module spec hash of the last successful run; only
+ * changed modules are re-emitted. Emitters (K-10..K-12: schema, queries,
+ * actions, pages, routes) register in EMITTERS — each returns files
+ * relative to `.norns/generated/`.
+ *
+ * The refusal engine turns unsafe-but-shapely specs into structured
+ * errors `{ address, path, code, message, fix? }` — the safe path is the
+ * only path.
+ */
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { dirname, join, resolve } from 'node:path';
+
+import * as v from 'valibot';
+
+import { isAddress, listUnits, parseAddress } from './address.js';
+import { schemaEmitter } from './emit-schema.js';
+import {
+	actionsEmitter,
+	pagesEmitter,
+	policiesEmitter,
+	queriesEmitter,
+	remotesEmitter,
+	triggersEmitter
+} from './emit-units.js';
+import { machinesEmitter } from './emit-machines.js';
+import { wranglerFile } from './emit-wrangler.js';
+import { buildGraph } from './graph.js';
+import { loadSpecs, validateSpecs } from './validate.js';
+
+/** @typedef {{ address: string, path?: string, code: string, message: string, fix?: string }} Refusal */
+
+/**
+ * Generator-specific refusals, beyond what `validate` rejects.
+ *
+ * @param {{ modules: Record<string, *> }} specs
+ * @param {{ contracts?: Record<string, *> }} [opts] palette props contracts
+ *   (valibot schemas keyed by component tag, normally loaded from
+ *   `@human-synthesis/norns-ui/contracts` in the app's node_modules)
+ * @returns {Refusal[]}
+ */
+export function checkGenerate(specs, opts = {}) {
+	/** @type {Refusal[]} */
+	const refusals = [];
+	const graph = buildGraph(specs.modules);
+	if (opts.contracts) refusals.push(...checkBindings(specs, opts.contracts));
+
+	for (const [moduleName, spec] of Object.entries(specs.modules)) {
+		for (const unit of listUnits(moduleName, spec)) {
+			if (unit.kind === 'Action') {
+				const writes = (graph.outbound.get(unit.address) ?? []).filter(
+					(e) => e.type === 'writes'
+				);
+				for (const edge of writes) {
+					const guarded = (graph.inbound.get(edge.to) ?? []).some((e) => e.type === 'guards');
+					if (!guarded) {
+						refusals.push({
+							address: unit.address,
+							path: `${unit.address}.steps`,
+							code: 'UNGUARDED_ACTION',
+							message: `action writes ${edge.to} but no Policy guards that entity`,
+							fix: `add policies.${edge.to.split('.').pop()} with read/write rules to module "${moduleName}"`
+						});
+					}
+				}
+			}
+			if (unit.kind === 'Action') {
+				const a = unit.value;
+				if (a && typeof a === 'object' && a.transport === 'remote') {
+					refusals.push({
+						address: unit.address,
+						path: `${unit.address}.transport`,
+						code: 'UNSPIKED_TRANSPORT',
+						message: '`transport: remote` is not generated yet (spike pending) — only `form` actions are emitted',
+						fix: 'use `transport: form` (default) or drop the field'
+					});
+				}
+			}
+			if (unit.kind === 'Query') {
+				const q = unit.value;
+				if (q && typeof q === 'object' && !q.live && !q.groupBy && q.limit === undefined) {
+					refusals.push({
+						address: unit.address,
+						path: `${unit.address}.limit`,
+						code: 'UNPAGINATED_QUERY',
+						message: 'query has no limit and is neither live nor grouped — unbounded reads are refused',
+						fix: 'add `limit` (or mark the query `live` / add `groupBy`)'
+					});
+				}
+			}
+		}
+	}
+	return refusals;
+}
+
+/**
+ * Validate page `components:` entries against palette props contracts
+ * (U-02). Each entry is normalized the way the pages emitter binds it: the
+ * first key names the component; its value becomes the `data` prop when it
+ * is a Query address and the `action` prop when it is an Action address.
+ * Tags without a contract are left alone — they may be custom components.
+ *
+ * @param {{ modules: Record<string, *> }} specs
+ * @param {Record<string, *>} contracts valibot schema per component tag
+ * @returns {Refusal[]}
+ */
+export function checkBindings(specs, contracts) {
+	/** @type {Refusal[]} */
+	const refusals = [];
+	for (const [moduleName, moduleSpec] of Object.entries(specs.modules)) {
+		for (const [pageName, page] of Object.entries(moduleSpec.pages ?? {})) {
+			(page.components ?? []).forEach((entry, i) => {
+				const keys = Object.keys(entry);
+				if (keys.length === 0) return;
+				const [first, ...rest] = keys;
+				const tag = first[0].toUpperCase() + first.slice(1);
+				const contract = contracts[tag];
+				if (!contract) return;
+
+				const primary = entry[first];
+				const parsed =
+					typeof primary === 'string' && isAddress(primary) ? parseAddress(primary) : null;
+				const props = {};
+				if (parsed) props[parsed.kind === 'Action' ? 'action' : 'data'] = primary;
+				for (const key of rest) props[key] = entry[key];
+
+				const result = v.safeParse(contract, props);
+				if (result.success) return;
+				const issue = result.issues[0];
+				const at = issue.path?.map((p) => p.key).join('.');
+				refusals.push({
+					address: `${moduleName}.Page.${pageName}`,
+					path: `${moduleName}.Page.${pageName}.components[${i}]${at ? `.${at}` : ''}`,
+					code: 'INVALID_BINDING',
+					message: `<${tag}> binding rejected${at ? ` at \`${at}\`` : ''}: ${issue.message}`,
+					fix: `match the ${tag} props contract exported by @human-synthesis/norns-ui/contracts`
+				});
+			});
+		}
+	}
+	return refusals;
+}
+
+/**
+ * Emitters (K-10..K-12). Each: { name, emit(ctx) } where ctx =
+ * { moduleName, moduleSpec, specs, graph } and the return value is a list
+ * of { path, text } relative to the generated root.
+ * @type {{ name: string, emit: (ctx: *) => { path: string, text: string }[] }[]}
+ */
+export const EMITTERS = [
+	schemaEmitter,
+	policiesEmitter,
+	machinesEmitter,
+	queriesEmitter,
+	actionsEmitter,
+	triggersEmitter,
+	pagesEmitter,
+	remotesEmitter
+];
+
+const require = createRequire(import.meta.url);
+
+const FILE_KINDS = {
+	'schema.c': 'Entity',
+	'queries.c': 'Query',
+	'actions.c': 'Action',
+	'machines.c': 'Action',
+	'policies.c': 'Policy',
+	'triggers.c': 'Trigger'
+};
+
+/** `lib/orders/actions.c` + an error near line N → `orders.Action.<unit>`. */
+function selfCheckAddress(file, message) {
+	const lib = file.path.match(/^lib\/([^/]+)\/([^/]+)$/);
+	const kind = lib ? FILE_KINDS[lib[2]] : file.path.startsWith('routes/') ? 'Page' : null;
+	if (!kind) return file.path;
+	const line = Number(message.match(/:(\d+):\d+/)?.[1] ?? NaN);
+	const lines = file.text.split('\n');
+	for (let i = Math.min(line, lines.length) - 1; i >= 0; i--) {
+		const unit = lines[i]?.match(/^export (\w+) :=/)?.[1];
+		if (unit && lib) return `${lib[1]}.${kind}.${unit}`;
+	}
+	return lib ? `${lib[1]}.${kind}.*` : file.path;
+}
+
+const scriptOf = (pug) => pug.match(/<script>\n([\s\S]*?)<\/script>/)?.[1] ?? null;
+
+/**
+ * Self-check (K-14): every emitted `.c` file and `.n` script block must
+ * compile through Civet before anything is written — a generator bug can
+ * never leave a broken tree behind. (svelte-check across the assembled
+ * app runs in the app's own check pipeline, not here.)
+ *
+ * @param {{ path: string, text: string }[]} files
+ * @returns {Refusal[]}
+ */
+export function selfCheck(files) {
+	const { compile } = require('@danielx/civet');
+	const refusals = [];
+	for (const file of files) {
+		const src = file.path.endsWith('.c') ? file.text : file.path.endsWith('.n') ? scriptOf(file.text) : null;
+		if (src === null) continue;
+		try {
+			compile(src, { sync: true, js: true });
+		} catch (e) {
+			const message = String(e.message ?? e).split('\n')[0];
+			refusals.push({
+				address: selfCheckAddress(file, message),
+				path: file.path,
+				code: 'SELFCHECK_FAILED',
+				message: `emitted file does not compile: ${message}`
+			});
+		}
+	}
+	return refusals;
+}
+
+export class GenerateError extends Error {
+	/** @param {Refusal[]} refusals */
+	constructor(refusals) {
+		const lines = refusals.map(
+			(r) => `  [${r.code}] ${r.address}: ${r.message}${r.fix ? `\n      fix: ${r.fix}` : ''}`
+		);
+		super(`norns generate: refused\n${lines.join('\n')}`);
+		this.name = 'GenerateError';
+		this.refusals = refusals;
+	}
+}
+
+/**
+ * Load palette props contracts from the app's own dependency tree. Apps
+ * that don't use norns-ui simply skip binding validation.
+ *
+ * @param {string} appRoot
+ * @returns {Record<string, *> | null}
+ */
+function loadContracts(appRoot) {
+	try {
+		const appRequire = createRequire(join(appRoot, 'package.json'));
+		return appRequire('@human-synthesis/norns-ui/contracts').contracts ?? null;
+	} catch {
+		return null;
+	}
+}
+
+/** Any `live: true` query anywhere means the app serves `/_norns/live`. */
+function hasLiveQueries(specs) {
+	for (const mod of Object.values(specs.modules)) {
+		for (const query of Object.values(mod.queries ?? {})) {
+			if (query?.live === true) return true;
+		}
+	}
+	return false;
+}
+
+/**
+ * App-level SSE endpoint streaming live-query refresh signals (R-11).
+ *
+ * @returns {{ path: string, text: string }}
+ */
+export function liveRouteFile() {
+	return {
+		path: 'routes/_norns/live/+server.c',
+		text: [
+			'// GENERATED by `norns generate` — do not edit.',
+			'',
+			`import { liveHandler } from '@human-synthesis/norns/server'`,
+			'',
+			`export GET := liveHandler`,
+			''
+		].join('\n')
+	};
+}
+
+/**
+ * Root layout for the generated route tree (app-level, like wrangler.json).
+ * Plain `.svelte` — no Pug/Civet — so it stays outside the vetted-subset
+ * surface. Imports the app's global stylesheet when `src/app.css` exists.
+ *
+ * @param {boolean} hasAppCss
+ * @returns {{ path: string, text: string }}
+ */
+export function layoutFile(hasAppCss) {
+	return {
+		path: 'routes/+layout.svelte',
+		text: [
+			'<!-- GENERATED by `norns generate` — do not edit. -->',
+			'<script>',
+			...(hasAppCss ? ["\timport '$custom/app.css';"] : []),
+			'\tlet { children } = $props();',
+			'</script>',
+			'',
+			'{@render children()}',
+			''
+		].join('\n')
+	};
+}
+
+function readCache(file) {
+	try {
+		return JSON.parse(readFileSync(file, 'utf-8'));
+	} catch {
+		return { moduleHashes: {} };
+	}
+}
+
+/**
+ * Generate an app from its specs into `.norns/generated/`.
+ *
+ * @param {string} [dir] specs directory, defaults to `<cwd>/specs`
+ * @param {{ out?: string, force?: boolean, contracts?: Record<string, *> }} [opts]
+ * @returns {{ version: string, written: string[], skipped: string[], refusals: [] }}
+ */
+export function generateApp(dir, opts = {}) {
+	const specs = loadSpecs(dir);
+	const appRoot = dirname(specs.dir);
+	const outRoot = resolve(opts.out ?? join(appRoot, '.norns', 'generated'));
+	const cacheFile = join(appRoot, '.norns', 'cache', 'generate.json');
+
+	const validation = validateSpecs(specs.dir);
+	if (!validation.ok) {
+		throw new GenerateError(
+			validation.issues
+				.filter((i) => i.level === 'error')
+				.map((i) => ({ address: i.address, code: 'INVALID_SPEC', message: i.message }))
+		);
+	}
+	const contracts = opts.contracts ?? loadContracts(appRoot);
+	const refusals = checkGenerate(specs, contracts ? { contracts } : {});
+	if (refusals.length > 0) throw new GenerateError(refusals);
+
+	const cache = opts.force ? { moduleHashes: {} } : readCache(cacheFile);
+	const graph = buildGraph(specs.modules);
+	const written = [];
+	const skipped = [];
+	const pending = [];
+
+	for (const [moduleName, moduleSpec] of Object.entries(specs.modules)) {
+		if (cache.moduleHashes[moduleName] === specs.hashes[moduleName]) {
+			skipped.push(moduleName);
+			continue;
+		}
+		for (const emitter of EMITTERS) {
+			pending.push(...emitter.emit({ moduleName, moduleSpec, specs, graph }));
+		}
+		cache.moduleHashes[moduleName] = specs.hashes[moduleName];
+	}
+
+	// App-level: the wrangler config derives from all modules, so refresh it
+	// whenever anything re-emitted (or it's missing entirely).
+	if (pending.length > 0 || !existsSync(join(outRoot, 'wrangler.json'))) {
+		pending.push(wranglerFile(specs));
+	}
+
+	// App-level: the live SSE route exists iff any query is live.
+	if (
+		hasLiveQueries(specs) &&
+		(pending.length > 0 || !existsSync(join(outRoot, 'routes', '_norns', 'live', '+server.c')))
+	) {
+		pending.push(liveRouteFile());
+	}
+
+	// App-level: a root layout so generated routes render inside a shell.
+	if (pending.length > 0 || !existsSync(join(outRoot, 'routes', '+layout.svelte'))) {
+		pending.push(layoutFile(existsSync(join(appRoot, 'src', 'app.css'))));
+	}
+
+	const failures = selfCheck(pending);
+	if (failures.length > 0) throw new GenerateError(failures);
+
+	for (const file of pending) {
+		const full = join(outRoot, file.path);
+		mkdirSync(dirname(full), { recursive: true });
+		writeFileSync(full, file.text, 'utf-8');
+		written.push(file.path);
+	}
+	for (const name of Object.keys(cache.moduleHashes)) {
+		if (!(name in specs.modules)) delete cache.moduleHashes[name];
+	}
+
+	const manifest = {
+		version: specs.version,
+		modules: specs.hashes,
+		generatedAt: new Date().toISOString()
+	};
+	mkdirSync(outRoot, { recursive: true });
+	writeFileSync(join(outRoot, 'manifest.json'), JSON.stringify(manifest, null, '\t') + '\n');
+	mkdirSync(dirname(cacheFile), { recursive: true });
+	writeFileSync(cacheFile, JSON.stringify(cache, null, '\t') + '\n');
+
+	return { version: specs.version, written, skipped, refusals: [] };
+}

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,71 @@
+/**
+ * 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, layoutFile, liveRouteFile, selfCheck, GenerateError, EMITTERS } from './generate.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,
+	emitModuleTriggers,
+	emitModulePages,
+	emitModuleRemotes,
+	policiesEmitter,
+	queriesEmitter,
+	actionsEmitter,
+	triggersEmitter,
+	pagesEmitter,
+	remotesEmitter
+} from './emit-units.js';