@menapo/machine 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 menapo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,136 @@
-# Temporary Holding Version
+# @menapo/machine
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Typed state machines for UI components and app logic. One object describes a
+machine: its states, events and data, what it does while a state is active,
+and the DOM attributes of a component's parts. The same machine runs in
+React, Preact, Vue, Svelte, Solid, plain code, on servers and on Workers, and
+its types come from that object alone.
+
+**Status: built, private until 1.0.** The core, its types, parts and the
+glue for six frameworks, the `/dom` helpers, parallel states, history and
+jobs, `/test`, DevTools, build-time compilation and the vicss preset are
+implemented and tested, each framework against an example app; the release
+waits on the owner's review.
+
+```ts title="packages/machine/tests/docs/snippets.test.ts"
+const counter = defineMachine({
+  context: { count: 0 },
+  events: { INC: null, ADD: payload<{ by: number }>(), TWICE: null },
+  initial: "active",
+  states: {
+    active: {
+      on: {
+        INC: ({ context }) => void context.count++,
+        ADD: ({ context, event }) => void (context.count += event.by), // event: { type: "ADD"; by: number }
+        // Sends made while an event is handled run once it is done, before `send`
+        // returns; subscribers hear once for all of it.
+        TWICE: ({ send }) => (send("INC"), send("INC")),
+      },
+    },
+  },
+});
+
+const c = start(counter);
+```
+
+`defineMachine`, `payload` and `start` come from `@menapo/machine`. In a
+component, the same import in every framework:
+`const api = useMachine(dialog, props)`, then
+`<button {...api.parts.trigger}>` ([Getting started](https://github.com/menapo/kit/blob/main/packages/machine/docs/guide/getting-started.md)).
+
+## Why
+
+- **Small.** A compiled machine ships tables and only the runtime they use,
+  a fraction of Zag's or XState's engine. Parallel states, history, jobs and
+  each DOM helper are separate imports: a machine that uses none ships none.
+- **Fast.** Events run synchronously from per-state lookup tables, with no
+  microtask and no snapshot per event; an event no state handles allocates
+  nothing.
+- **One render per visible change.** A part's props object is rebuilt only
+  when what it shows changed, and its handlers never change identity, so
+  React renders once to open a dialog (Zag: twice), never for a change no
+  part shows, and memoised children of unchanged parts stay put.
+- **Readable, typed from one place.** Functions sit where they are used;
+  context is written directly (`context.count++`); each handler gets its own
+  event; targets, names and events are checked with "Did you mean", with
+  fewer type instantiations and a faster check than XState's.
+- **Controlled values without twins.** `bindable(false, { states })` gives
+  the owner `open`, `defaultOpen` and `onOpenChange` with one transition.
+- **Checked and compiled at build time.** With the Vite plugin a mistake in a
+  machine fails the build at its line, and the bundle ships tables instead of
+  the code that builds them.
+- **The platform first.** Modal overlays use `<dialog>` and `inert`; each
+  `/dom` helper is a module of its own.
+
+### In numbers
+
+Measured against pinned Zag.js and XState on every change to the machine
+([benchmarks](https://github.com/menapo/kit/blob/main/bench/README.md#menapomachine));
+these lines are written by that run:
+
+<!-- results:machine-numbers -->
+
+- **Size, gzip:** a compiled toggle with its engine 1.49 KB (Zag 5.22 KB, XState 11.36 KB); the dialog a React app ships (machine, parts, glue, DOM behaviour) 5.97 KB (Zag 15.57 KB).
+- **Speed, Node / Chromium:** a handled event that writes context and notifies 73 ns / 66 ns (the better of the others 2.6 µs (Zag) / 2.6 µs (XState)); an unhandled one 18 ns / 23 ns, allocating nothing; creating a toggle 124–145 ns / 98–100 ns; opening or closing the dialog with its DOM behaviour in Chromium 15 µs (Zag 113 µs).
+
+Measured on Node v22.22.0, Chromium 141.0.7390.37, Intel(R) Xeon(R) Processor @ 2.10GHz (4 cores, load average 1.0 → 1.5).
+
+<!-- /results:machine-numbers -->
+
+<!-- results:machine-types -->
+
+The benchmark's 30-state wizard, written out as a compiled config, type-checks with 35,703 instantiations in 25 ms; XState's takes 74,628 in 108 ms. Zag's is cheaper, 2,027 in 4 ms, because Zag's machine casts its states to a hand-written schema and checks no transition target: not a like-for-like row, so ours is held to XState's (`bench:machine-types`).
+
+<!-- /results:machine-types -->
+
+## Install
+
+```sh
+vp add @menapo/machine
+```
+
+The engine needs nothing; components need the Vite plugin (Vite 8.3 or
+newer, Node 22.18 or newer):
+
+```ts title="examples/machine-react/vite.config.ts"
+import { machine } from "@menapo/machine/vite";
+// …
+export default defineConfig(({ isSsrBuild }) => ({
+  plugins: [react(), machine(), vicss()],
+```
+
+## Entries
+
+| Entry                   | What                                                                                                                                     |
+| ----------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- |
+| `@menapo/machine`       | `defineMachine`, `start`, `payload`, `bindable`, `provide`, `useMachine`, `parallel`, `history`, `job`, `inspect`                        |
+| `@menapo/machine/dom`   | DOM behaviour for effects: `dismiss`, `focusTrap`, `hideOthers`, `scrollLock`, `presence`, `popper`, `typeahead`, `liveRegion`, `spread` |
+| `@menapo/machine/test`  | `testMachine` (a fake clock, every step recorded) and `paths`                                                                            |
+| `@menapo/machine/vicss` | `conditions(...machines)`: vicss conditions for every state, `_dialogOpen`                                                               |
+| `@menapo/machine/vite`  | `machine()`: `useMachine` per framework, build-time compilation, the DevTools panel                                                      |
+
+## Guide
+
+- [Getting started](https://github.com/menapo/kit/blob/main/packages/machine/docs/guide/getting-started.md)
+- [States and transitions](https://github.com/menapo/kit/blob/main/packages/machine/docs/guide/states.md) ·
+  [Context, props and derived values](https://github.com/menapo/kit/blob/main/packages/machine/docs/guide/data.md) ·
+  [Events](https://github.com/menapo/kit/blob/main/packages/machine/docs/guide/events.md) ·
+  [Effects and DOM behaviour](https://github.com/menapo/kit/blob/main/packages/machine/docs/guide/effects.md) ·
+  [Parts and expose](https://github.com/menapo/kit/blob/main/packages/machine/docs/guide/parts.md)
+- [Frameworks](https://github.com/menapo/kit/blob/main/packages/machine/docs/guide/frameworks.md) ·
+  [Servers and app logic](https://github.com/menapo/kit/blob/main/packages/machine/docs/guide/servers.md) ·
+  [Server-side rendering](https://github.com/menapo/kit/blob/main/packages/machine/docs/guide/ssr.md)
+- [Parallel states, history and jobs](https://github.com/menapo/kit/blob/main/packages/machine/docs/guide/statecharts.md) ·
+  [Build-time compilation](https://github.com/menapo/kit/blob/main/packages/machine/docs/guide/compilation.md) ·
+  [Testing](https://github.com/menapo/kit/blob/main/packages/machine/docs/guide/testing.md) ·
+  [DevTools](https://github.com/menapo/kit/blob/main/packages/machine/docs/guide/devtools.md) ·
+  [TypeScript](https://github.com/menapo/kit/blob/main/packages/machine/docs/guide/typescript.md)
+- [Performance and size](https://github.com/menapo/kit/blob/main/packages/machine/docs/guide/performance.md) ·
+  [Coming from Zag or XState](https://github.com/menapo/kit/blob/main/packages/machine/docs/guide/coming-from.md)
+
+The design, the budgets and what each milestone measured are in
+[PLAN.md](https://github.com/menapo/kit/blob/main/packages/machine/docs/PLAN.md).
+
+## License
+
+MIT

package/dist/chart-BWjU2VF4.js

@@ -0,0 +1,395 @@
+import { r as run, u as bit } from "./instance-BM2UqeXW.js";
+import { n as recorded, t as record } from "./records-7FFepzo9.js";
+//#region src/core/props.ts
+/** Marks a `bindable()` value and carries its {@link Control}. */
+const BOUND = Symbol();
+/**
+* Records each declared prop's default, and hands a `bindable()` one to its
+* {@link Control}: what the normaliser does, and a compiled machine at load.
+*/
+function bind(tables, props) {
+	tables.pn.forEach((prop, j) => {
+		const value = props[prop];
+		const control = value?.[BOUND];
+		tables.pd.push(control ? value.value : value);
+		if (control) (tables.k = control).bind(tables, j, prop, value, tables.Q.prototype);
+		else tables.pl.push(j);
+	});
+}
+/**
+* Takes the owner's props; a missing plain prop falls back to its default.
+* From `setProps` (`queue`): taken once the event being handled is done,
+* as one event of their own when none is, never once stopped.
+*/
+function own(instance, owner, queue) {
+	if (queue) {
+		if (instance.b !== 2) {
+			instance.n = owner;
+			if (!instance.b) instance.go(void 0, instance.event);
+		}
+		return;
+	}
+	const { M, props } = instance;
+	const previous = instance.o;
+	instance.o = owner;
+	for (const j of M.pl) {
+		const given = owner[M.pn[j]];
+		const value = given === void 0 ? M.pd[j] : given;
+		if (props.v[j] !== value) {
+			props.v[j] = value;
+			props.m |= bit(1 + M.nm.length - M.pn.length + j);
+		}
+	}
+	if (instance.s) M.k?.own(instance, previous);
+}
+//#endregion
+//#region src/core/effects.ts
+const AFTER = { type: "machine.after" };
+/** An `after` timer: setTimeout's extra arguments spare a closure per timer. */
+function fire(instance, rules) {
+	if (!instance.b) instance.go(rules, AFTER);
+}
+/** `[state, cleanup or timer, …]`: what an instance keeps while its states are active. */
+const keep = (instance, at, item) => void (instance.r ??= []).push(at, item);
+/** `instance.b` once stopped (the interpreter's STOPPED). */
+const STOPPED = 2;
+/**
+* Sets the timers and starts the effects of `states`, entered in the event
+* that just settled and still active, while the instance is busy: what an
+* effect sends runs once all have started. The glue's component calls it
+* only once the framework has committed the DOM, and never on a server.
+*
+* An effect that stops the instance ends it: nothing after it starts, and
+* the cleanup it returns runs at once. An effect that throws does not keep
+* the others from starting: the event runs to completion and tells its
+* subscribers, then the first error is thrown.
+*/
+function activate(instance, states) {
+	let thrown;
+	for (const at of states) {
+		if (instance.b === STOPPED) break;
+		if (at.af) for (const [ms, rules] of at.af) keep(instance, at, setTimeout(fire, ms, instance, rules));
+		if (at.ef) for (const effect of at.ef) {
+			if (instance.b === STOPPED) break;
+			try {
+				const cleanup = effect(instance);
+				if (typeof cleanup === "function") {
+					if (instance.b === STOPPED) cleanup();
+					else keep(instance, at, cleanup);
+				}
+			} catch (error) {
+				thrown ??= [error];
+			}
+		}
+	}
+	if (thrown) {
+		instance.settle();
+		throw thrown[0];
+	}
+}
+/**
+* Stops what `instance` keeps for state `at`, latest first, and forgets it
+* if it waits to start; without `at` (the instance stops), everything. A
+* cleanup that throws does not keep the others from running: the first
+* error is thrown once all have.
+*/
+function release(instance, at) {
+	const { r, x } = instance;
+	let thrown;
+	if (!at) instance.r = instance.x = void 0;
+	else x?.splice(x.indexOf(at) >>> 0, 1);
+	if (r) {
+		for (let k = r.length - 2; k >= 0; k -= 2) if (!at || r[k] === at) {
+			const item = r.splice(k, 2)[1];
+			try {
+				if (typeof item === "function") item();
+				else clearTimeout(item);
+			} catch (error) {
+				thrown ??= [error];
+			}
+		}
+	}
+	if (thrown) throw thrown[0];
+}
+//#endregion
+//#region src/features/resume.ts
+function wireHistory(tables) {
+	const states = tables.ss;
+	const histories = states.filter((s) => s.h !== void 0);
+	/** History state → the state its parent enters when nothing is recorded yet: its initial child. */
+	const initial = /* @__PURE__ */ new Map();
+	for (const h of histories) {
+		const parent = h.up;
+		let child = parent.lf;
+		while (child.up !== parent) child = child.up;
+		initial.set(h, child);
+		const deep = h.h;
+		const keep = (view) => {
+			const leaf = view.s;
+			let child = leaf;
+			while (child.up !== parent) child = child.up;
+			record(view, h, [deep ? leaf : child]);
+		};
+		parent.ex = [keep, ...parent.ex ?? []];
+	}
+	const all = /* @__PURE__ */ new Set();
+	for (const state of [states[0].up, ...states]) {
+		for (const handler of state.on.values()) for (const rule of handler.ru) all.add(rule);
+		for (const rule of state.al ?? []) all.add(rule);
+		for (const [, rules] of state.af ?? []) for (const rule of rules) all.add(rule);
+	}
+	for (const rule of all) {
+		const h = rule.to;
+		if (!h || !initial.has(h)) continue;
+		const guard = rule.if;
+		const routed = rule;
+		routed.h = h;
+		routed.if = (view) => (!guard || guard(view)) && !!(routed.to = recorded(view, h)?.[0] ?? initial.get(h));
+	}
+}
+//#endregion
+//#region src/features/chart.ts
+/**
+* The runtime of `type: parallel` (PLAN §4.9, D12): what a machine with
+* parallel states runs on, wired by {@link wireParallel} once its tables are
+* prepared (`parallel.ts`, which the normaliser runs, or the plugin at build
+* time for a compiled machine, M7). Only a machine that declares a parallel
+* state ships this module.
+*
+* The core keeps one leaf (`instance.s`). In a machine with parallel
+* states that leaf is a configuration: an object shaped like a state, one
+* per set of active states, made once per machine and reused, whose `path`
+* lists the active leaves, whose `on` holds every event an active state
+* handles, and whose `up` chain names every active state for `is()`. Each
+* of its handlers is one rule whose guard selects the transitions (SCXML's
+* selection: per active leaf in document order, its own handler first,
+* then its ancestors'; of two whose exits overlap, the one declared deeper,
+* else the earlier) and whose action takes them all as one microstep:
+* exits in reverse document order, the transitions' actions, entries in
+* document order. The core's own `move` is never used; it runs the queue,
+* `always`, timers, effects and notifications as for any machine.
+*
+* Where a transition's exits stop is the core's rule: at the nearest common
+* ancestor of the leaf it was found from and the target's parent, so a
+* transition into a state's own subtree never exits that state; when that
+* ancestor is parallel, the next one up, so every region is left together.
+*
+* A region whose active child is a `type: "final"` state is done; when
+* every region of a parallel state is, the state's `done` transition is
+* taken after the event that finished it (an internal `machine.done`).
+* History states inside parallel machines are handled here too, with the
+* records `history` keeps.
+*/
+const DONE = { type: "machine.done" };
+/** Each parallel machine's chart, by its tables. */
+const charts = /* @__PURE__ */ new WeakMap();
+/** `at` strictly inside `up`: depth-first numbering puts a subtree in one range. */
+const inside = (at, up) => at.i > up.i && at.i <= up.e;
+/** What a leaf takes events through: a final state in a region has none of its own, its region's apply. */
+const handlersOf = (chart, leaf) => leaf.fi && leaf.up !== chart.r ? leaf.up.on : leaf.on;
+const configOf = (instance) => instance.s;
+/** The configuration of these active states (document order), made once per machine. */
+function configuration(chart, a) {
+	const key = a.map((s) => s.i).join();
+	let made = chart.m.get(key);
+	if (!made) {
+		const l = a.filter((s, k) => !(a[k + 1] && inside(a[k + 1], s)));
+		let up;
+		for (const s of a) up = {
+			path: s.path,
+			up
+		};
+		const on = /* @__PURE__ */ new Map();
+		for (const leaf of l) for (const [type, handler] of handlersOf(chart, leaf)) if (!on.has(type)) on.set(type, {
+			ev: handler.ev,
+			ru: chart.e
+		});
+		if (a.some((s) => s.dn)) on.set(DONE.type, {
+			ev: DONE,
+			ru: chart.f
+		});
+		chart.m.set(key, made = {
+			i: -2,
+			path: l.map((s) => s.path).join(" "),
+			up,
+			fi: l.length === 1 && l[0].fi && l[0].up === chart.r,
+			on,
+			al: l.some((s) => s.al) ? chart.a : void 0,
+			a,
+			l
+		});
+	}
+	return made;
+}
+/**
+* The transitions a guard selected, read by the action right after it: the
+* core runs a rule's action as soon as its guard passed (`take`), so one
+* module binding is enough.
+*/
+let picked = [];
+/**
+* Keeps the transitions found (rule, leaf, …) that SCXML would: one per
+* rule, and of two whose exits overlap the one declared deeper, else the
+* earlier. True when any is left, kept in {@link picked}.
+*/
+function choose(instance, found) {
+	const taken = [];
+	next: for (let k = 0; k < found.length; k += 2) {
+		const rule = found[k];
+		const leaf = found[k + 1];
+		if (taken.some((t) => t[0] === rule)) continue;
+		let domain;
+		if (rule.to) {
+			domain = leaf;
+			let b = rule.to.up;
+			while (domain !== b) if (domain.i > b.i) domain = domain.up;
+			else b = b.up;
+			while (domain.p) domain = domain.up;
+		}
+		const exits = domain ? configOf(instance).a.filter((s) => inside(s, domain)) : [];
+		for (let j = 0; j < taken.length; j++) {
+			const other = taken[j];
+			if (!exits.some((s) => other[2].includes(s))) continue;
+			if (inside(rule.s ?? leaf, other[0].s ?? leaf)) taken.splice(j--, 1);
+			else continue next;
+		}
+		taken.push([
+			rule,
+			domain,
+			exits
+		]);
+	}
+	picked = taken;
+	return taken.length > 0;
+}
+/** Pushes the first rule of `rules` whose guard passes, found from `leaf`. */
+function first(instance, rules, leaf, found) {
+	for (const rule of rules) if (!rule.if || rule.if(instance)) return found.push(rule, leaf);
+}
+/** Per active leaf, its first transition for the event being handled, or (`always`) its first eventless one. */
+function pick(chart, instance, always) {
+	const found = [];
+	for (const leaf of configOf(instance).l) {
+		const rules = always ? leaf.al : handlersOf(chart, leaf).get(instance.event.type)?.ru;
+		if (rules) first(instance, rules, leaf, found);
+	}
+	return choose(instance, found);
+}
+/** A state's own rules (a timer's, a `done`): taken from the first active leaf inside it. */
+function pickFrom(instance, rules, state) {
+	const { a, l } = configOf(instance);
+	const found = [];
+	if (a.includes(state)) first(instance, rules, l.find((s) => s === state || inside(s, state)), found);
+	return choose(instance, found);
+}
+/** A rule whose guard picks the transitions and whose action takes them. */
+const routed = (pick) => ({
+	to: void 0,
+	if: pick,
+	do: [step]
+});
+/** The action of every configuration rule: the microstep of what its guard picked. */
+const step = (view) => {
+	const instance = view;
+	const taken = picked;
+	const { a, l } = configOf(instance);
+	const exits = /* @__PURE__ */ new Set();
+	for (const t of taken) for (const s of t[2]) exits.add(s);
+	for (const s of exits) for (const h of s.hs) record(instance, h, h.h ? l.filter((leaf) => inside(leaf, s)) : a.filter((c) => c.up === s));
+	for (const s of [...exits].sort((x, y) => y.i - x.i)) instance.exit(s);
+	for (const t of taken) run(t[0].do, instance);
+	const enter = /* @__PURE__ */ new Set();
+	for (const [rule, domain] of taken) if (rule.to) {
+		descend(instance, rule.to, enter);
+		ascend(instance, rule.to, domain, enter);
+	}
+	settle(instance, a.filter((s) => !exits.has(s)), enter);
+};
+/** Adds `state` and what entering it enters (SCXML's addDescendantStatesToEnter). */
+function descend(instance, state, enter) {
+	if (state.h !== void 0) {
+		const parent = state.up;
+		const states = recorded(instance, state) ?? (parent.p ? parent.k : [parent.n]);
+		for (const s of states) descend(instance, s, enter);
+		for (const s of states) ascend(instance, s, parent, enter);
+	} else {
+		enter.add(state);
+		if (state.p) for (const region of state.k) regions(instance, region, enter);
+		else if (state.n) descend(instance, state.n, enter);
+	}
+}
+/** Enters `region` by default unless a state in it is entered already. */
+function regions(instance, region, enter) {
+	for (const s of enter) if (s === region || inside(s, region)) return;
+	descend(instance, region, enter);
+}
+/** Adds the ancestors of `state` below `stop`, and the other regions of the parallel ones. */
+function ascend(instance, state, stop, enter) {
+	for (let up = state.up; up !== stop && up.i >= 0; up = up.up) {
+		enter.add(up);
+		if (up.p) for (const region of up.k) regions(instance, region, enter);
+	}
+}
+/**
+* Enters the new states in document order, each added to the configuration
+* just before its entry actions run (so `is()` there sees it and its
+* ancestors, not what is entered after it, as in the core): their timers
+* and effects start once the event settles, and a final state that
+* completes a parallel state queues that state's `done`.
+*/
+function settle(instance, kept, enter) {
+	const chart = charts.get(instance.M);
+	let active = kept;
+	instance.s = configuration(chart, active);
+	for (const s of [...enter].sort((x, y) => x.i - y.i)) {
+		active = [...active, s].sort((x, y) => x.i - y.i);
+		instance.s = configuration(chart, active);
+		instance.d = 1;
+		run(s.en, instance);
+		if (s.af || s.ef) (instance.x ??= []).push(s);
+		const done = s.fi && s.up.up?.dn;
+		if (done && !instance.q?.includes(done.event) && complete(instance, s.up.up)) {
+			const q = instance.q ??= [];
+			let k = 0;
+			while (k < q.length && chart.d.has(q[k])) k++;
+			q.splice(k, 0, done.event);
+		}
+	}
+}
+/** SCXML's isInFinalState: a compound state whose active child is final, a parallel one whose regions all are. */
+const complete = (instance, state) => state.p ? state.k.every((region) => complete(instance, region)) : configOf(instance).a.some((s) => s.up === state && s.fi);
+/** The runtime of a machine whose tables `parallel.ts` prepared: its chart, its timers' rules, its first configuration. */
+function wireParallel(tables) {
+	const states = tables.ss;
+	const root = states[0].up;
+	const chart = {
+		r: root,
+		m: /* @__PURE__ */ new Map(),
+		d: /* @__PURE__ */ new Map(),
+		e: [routed((view) => pick(chart, view))],
+		a: [routed((view) => pick(chart, view, true))],
+		f: [routed((view) => {
+			const state = chart.d.get(view.event);
+			return !!state && complete(view, state) && pickFrom(view, state.dn.rules, state);
+		})]
+	};
+	charts.set(tables, chart);
+	for (const s of [root, ...states]) {
+		if (s.af) s.af = s.af.map(([ms, list]) => [ms, [{
+			...routed((view) => pickFrom(view, list, s)),
+			w: list
+		}]]);
+		if (s.dn) chart.d.set(s.dn.event, s);
+	}
+	tables.i0 = {
+		i: -2,
+		up: root,
+		en: [(view) => {
+			const enter = /* @__PURE__ */ new Set();
+			descend(view, root.n, enter);
+			settle(view, [], enter);
+		}]
+	};
+}
+//#endregion
+export { release as a, own as c, activate as i, wireParallel as n, BOUND as o, wireHistory as r, bind as s, DONE as t };

package/dist/compiled.d.ts

@@ -0,0 +1,58 @@
+import { c as derivedClass, l as storeClass, n as Tables, o as Interpreter, t as State } from "./machine-BstWHtWL.js";
+//#region src/core/effects.d.ts
+/**
+ * Sets the timers and starts the effects of `states`, entered in the event
+ * that just settled and still active, while the instance is busy: what an
+ * effect sends runs once all have started. The glue's component calls it
+ * only once the framework has committed the DOM, and never on a server.
+ *
+ * An effect that stops the instance ends it: nothing after it starts, and
+ * the cleanup it returns runs at once. An effect that throws does not keep
+ * the others from starting: the event runs to completion and tells its
+ * subscribers, then the first error is thrown.
+ */
+export declare function activate(instance: Interpreter, states: readonly State[]): void;
+/**
+ * Stops what `instance` keeps for state `at`, latest first, and forgets it
+ * if it waits to start; without `at` (the instance stops), everything. A
+ * cleanup that throws does not keep the others from running: the first
+ * error is thrown once all have.
+ */
+export declare function release(instance: Interpreter, at?: State): void;
+//#endregion
+//#region src/core/props.d.ts
+type Owner = Readonly<Record<string, unknown>>;
+/**
+ * Records each declared prop's default, and hands a `bindable()` one to its
+ * {@link Control}: what the normaliser does, and a compiled machine at load.
+ */
+export declare function bind(tables: Tables, props: Owner): void;
+/**
+ * Takes the owner's props; a missing plain prop falls back to its default.
+ * From `setProps` (`queue`): taken once the event being handled is done,
+ * as one event of their own when none is, never once stopped.
+ */
+export declare function own(instance: Interpreter, owner: Owner, queue?: boolean): void;
+//#endregion
+//#region src/features/chart.d.ts
+/** The runtime of a machine whose tables `parallel.ts` prepared: its chart, its timers' rules, its first configuration. */
+export declare function wireParallel(tables: Tables): void;
+//#endregion
+//#region src/features/resume.d.ts
+export declare function wireHistory(tables: Tables): void;
+//#endregion
+//#region src/compiled.d.ts
+/**
+ * Development only: what the normaliser adds in development (the name for
+ * messages, every event some state handles, frozen context defaults) and
+ * checks (its parts), which a compiled machine works out at load instead of
+ * carrying it.
+ */
+export declare function devTables(tables: Tables): void;
+/**
+ * Development only: a value the plugin took for a function without seeing
+ * it (an imported name, a call's result), checked when the machine loads.
+ */
+export declare function fn<T>(value: T, where: string, name: string): T;
+//#endregion
+export { derivedClass, storeClass };

package/dist/compiled.js

@@ -0,0 +1,43 @@
+import { n as checkParts, r as fail } from "./dev-BAz6e3W-.js";
+import { f as DEV, o as derivedClass, s as storeClass } from "./instance-BM2UqeXW.js";
+import { a as release, c as own, i as activate, n as wireParallel, r as wireHistory, s as bind } from "./chart-BWjU2VF4.js";
+//#region src/compiled.ts
+/**
+* `@menapo/machine/compiled`: what a machine the plugin compiled at build
+* time (PLAN §5.6, M7) runs on, and the only module its emitted code
+* imports. Internal: no app imports it, as vi18n's `/engine` (PLAN §5.1).
+*
+* The plugin emits a machine's tables (the shape the runtime normaliser
+* produces) and imports from here only what they use: the stores of
+* context, props and derived values, binding props, the timers and effects
+* of states, and the runtimes of parallel states and history. Nothing here
+* imports the normaliser, so an app whose machines are all compiled ships
+* none of it.
+*/
+/**
+* Development only: what the normaliser adds in development (the name for
+* messages, every event some state handles, frozen context defaults) and
+* checks (its parts), which a compiled machine works out at load instead of
+* carrying it.
+*/
+function devTables(tables) {
+	const handled = /* @__PURE__ */ new Set();
+	for (const state of [tables.ss[0]?.up, ...tables.ss]) for (const type of state?.on.keys() ?? []) handled.add(type);
+	const name = tables.c.name ?? "machine";
+	Object.assign(tables, {
+		name,
+		handled
+	});
+	checkParts(tables.c, name, handled);
+	for (const value of tables.df ?? []) if (Array.isArray(value) || Object.getPrototypeOf(value ?? 0) === Object.prototype) Object.freeze(value);
+}
+/**
+* Development only: a value the plugin took for a function without seeing
+* it (an imported name, a call's result), checked when the machine loads.
+*/
+function fn(value, where, name) {
+	if (DEV && typeof value !== "function") fail("NOT_A_FUNCTION", name, `${where} is ${JSON.stringify(value)}, which the build took for a function; write a target or a name as a string literal in the config, or a function, so the plugin can compile it.`);
+	return value;
+}
+//#endregion
+export { activate, bind, derivedClass, devTables, fn, own, release, storeClass, wireHistory, wireParallel };