@camstack/system 1.2.38 → 1.2.40

package/dist/builtins/core-blocks/core-blocks.addon.mjs

@@ -1,8 +1,407 @@
 import { o as __toESM } from "../../chunk-CNf5ZN-e.mjs";
-import { S as coreBlocksCapability, ct as BaseAddon, o as CoreBlockSchema } from "../../dist-DO76YVO2.mjs";
+import { S as coreBlocksCapability, ct as BaseAddon, o as CoreBlockSchema } from "../../dist-BXS0DP92.mjs";
 import * as path$1 from "node:path";
 import { randomUUID } from "node:crypto";
 import * as fs from "node:fs/promises";
+//#region src/builtins/core-blocks/block-package.ts
+/**
+* Turning a stored block into something the addon runner can fork.
+*
+* The runner already knows how to do everything a block needs — fork a
+* process, build the full UDS `ctx`, redirect host-provided imports, and hand
+* the whole thing to `CrashSupervisor` (D6). What it does NOT know how to do is
+* load code out of a database row: `addon-runner` reads a package.json off
+* disk. So a block is MATERIALISED as a minimal addon package and spawned like
+* any other addon. No second runner, no second supervisor, no `node:vm`.
+*
+* Two files are generated per block:
+*
+*   `dist/block.js` — the author's TypeScript, transpiled.
+*   `dist/index.js` — a generated wrapper that adapts the author's contract
+*                     (`export default (ctx) => disposer`) to `ICamstackAddon`.
+*
+* The wrapper exists so the author never writes `super({})`, which is the trap
+* that killed `CoreBlocksAddon` in production while the build stayed green and
+* the topology reported it running.
+*/
+/** Prefix for the generated addon id AND the runner id — one addon, one
+*  process, so the two are the same string (D2). Grep-able on purpose: an
+*  operator reading `$process.list` must be able to tell a block runner from
+*  an addon runner at a glance. */
+var BLOCK_ADDON_PREFIX = "core-block-";
+/** The generated addon/runner id for a block. */
+function blockAddonId(blockId) {
+	return `${BLOCK_ADDON_PREFIX}${blockId}`;
+}
+/** The block id behind a generated addon/runner id, or null when the id
+*  belongs to something else. The inverse of {@link blockAddonId} — used to
+*  read the live process list back into block terms. */
+function blockIdFromAddonId(addonId) {
+	if (!addonId.startsWith("core-block-")) return null;
+	const rest = addonId.slice(11);
+	return rest.length > 0 ? rest : null;
+}
+/**
+* The wrapper module, generated verbatim.
+*
+* A string rather than a file copied from `dist` because it must land NEXT to
+* the author's code inside the block package: the runner imports one entry, and
+* relative imports have to resolve inside that directory.
+*
+* Three things it guarantees, all of them failures this repo has already paid
+* for once:
+*
+*  - `super({})` is here, so no author can omit it;
+*  - a module with no default function FAILS LOUDLY with the block's name in
+*    the message, instead of starting a process that does nothing;
+*  - the disposer is awaited on shutdown, so a block that owns a timer or a
+*    socket releases it on `setEnabled(false)` rather than on the next reboot.
+*/
+var WRAPPER_SOURCE = `// GENERATED by @camstack/system core-blocks. Do not edit — rewritten on every
+// deploy of the block it wraps.
+import { BaseAddon } from '@camstack/types'
+// NAMESPACE import, not \`import blockMain from\`. A default import of a module
+// that has no default export is a LINK-time SyntaxError: the module never
+// executes, so the friendly check below would never run and the author would
+// get a bare Node stack trace naming neither their block nor the mistake.
+// Verified, not assumed — a test spawns exactly that module.
+import * as blockModule from './block.js'
+
+const BLOCK_ID = __BLOCK_ID__
+const BLOCK_NAME = __BLOCK_NAME__
+const blockMain = blockModule.default
+
+export default class CoreBlockAddon extends BaseAddon {
+  constructor() {
+    // NOT optional: BaseAddon.resolveConfig reads Object.keys(this.defaults),
+    // so omitting this kills the process at init while the topology still
+    // reports the addon running.
+    super({})
+    this.disposer = null
+  }
+
+  async onInitialize() {
+    if (typeof blockMain !== 'function') {
+      throw new Error(
+        \`core block "\${BLOCK_NAME}" (\${BLOCK_ID}) has no default export function — \` +
+          'a block must "export default" a function taking ctx',
+      )
+    }
+    const result = await blockMain(this.ctx)
+    this.disposer = typeof result === 'function' ? result : null
+    // One line, always. A block that started and does nothing visible is
+    // indistinguishable from one that never loaded without it.
+    this.ctx.logger.info('core block started', {
+      meta: { blockId: BLOCK_ID, name: BLOCK_NAME, hasDisposer: this.disposer !== null },
+    })
+    return []
+  }
+
+  async onShutdown() {
+    if (this.disposer === null) return
+    const dispose = this.disposer
+    this.disposer = null
+    await dispose()
+  }
+}
+`;
+/** Build the wrapper for one block. Exported for the test that asserts the
+*  generated source actually carries the block's identity. */
+function renderBlockWrapper(blockId, blockName) {
+	return WRAPPER_SOURCE.replace("__BLOCK_ID__", JSON.stringify(blockId)).replace("__BLOCK_NAME__", JSON.stringify(blockName));
+}
+/** The package manifest the addon runner reads to find the entry point. */
+function renderBlockManifest(blockId, blockName) {
+	return `${JSON.stringify({
+		name: `@camstack/${blockAddonId(blockId)}`,
+		version: "0.0.0",
+		private: true,
+		type: "module",
+		main: "./dist/index.js",
+		camstack: { addons: [{
+			id: blockAddonId(blockId),
+			name: blockName,
+			category: "system",
+			description: "A user-authored core block.",
+			entry: "./dist/index.js",
+			capabilities: []
+		}] }
+	}, null, 2)}\n`;
+}
+/**
+* Write (or rewrite) a block's package. Idempotent, and deliberately a full
+* rewrite: the author's code is the thing that changes, and a partial update
+* that left a stale `block.js` behind would run yesterday's code while the
+* editor showed today's.
+*/
+async function materializeBlock(input) {
+	const addonDir = path$1.join(input.root, input.blockId);
+	const distDir = path$1.join(addonDir, "dist");
+	await fs.mkdir(distDir, { recursive: true });
+	await Promise.all([
+		fs.writeFile(path$1.join(addonDir, "package.json"), renderBlockManifest(input.blockId, input.blockName), "utf-8"),
+		fs.writeFile(path$1.join(distDir, "block.js"), input.js, "utf-8"),
+		fs.writeFile(path$1.join(distDir, "index.js"), renderBlockWrapper(input.blockId, input.blockName), "utf-8")
+	]);
+	return {
+		addonDir,
+		addonId: blockAddonId(input.blockId)
+	};
+}
+/** Remove a block's package. Idempotent — a missing directory is the desired
+*  end state, not an error. */
+async function removeBlockPackage(root, blockId) {
+	await fs.rm(path$1.join(root, blockId), {
+		recursive: true,
+		force: true
+	});
+}
+//#endregion
+//#region src/builtins/core-blocks/block-supervisor.ts
+/** Runner state → what the author should read. `crashed` is the window between
+*  an exit and the scheduled respawn, so it reads as `starting` with the reason
+*  attached rather than as a terminal failure it is not. */
+var RUNNER_STATE_TO_STATUS = {
+	starting: "starting",
+	running: "running",
+	crashed: "starting",
+	failed: "failed",
+	stopping: null,
+	stopped: null
+};
+var BlockSupervisor = class {
+	deps;
+	/**
+	* `blockId → updatedAt` of the source this supervisor last materialised.
+	* The only way to know a running block is running YESTERDAY'S code: the
+	* process is alive either way, and nothing on disk carries the version.
+	* In-memory is correct — a hub restart takes every child with it.
+	*/
+	materialized = /* @__PURE__ */ new Map();
+	timer = null;
+	/** Serialises passes so a timer tick cannot interleave with a write-driven
+	*  converge and spawn the same runner twice. */
+	inFlight = Promise.resolve();
+	constructor(deps) {
+		this.deps = deps;
+	}
+	/** Start the reconcile timer. The first pass runs immediately. */
+	start(intervalMs) {
+		if (this.timer !== null) return;
+		this.converge();
+		this.timer = setInterval(() => void this.converge(), intervalMs);
+		this.timer.unref?.();
+	}
+	stop() {
+		if (this.timer === null) return;
+		clearInterval(this.timer);
+		this.timer = null;
+	}
+	/** One reconcile pass. Never throws — a pass that failed must not stop the
+	*  next one, and the reason belongs in the log, not in a rejected promise
+	*  nobody awaits. */
+	converge() {
+		this.inFlight = this.inFlight.then(() => this.runPass(), () => this.runPass());
+		return this.inFlight;
+	}
+	async runPass() {
+		try {
+			await this.reconcile();
+		} catch (err) {
+			this.deps.logger.error("core-blocks converge failed", { meta: { error: err instanceof Error ? err.message : String(err) } });
+		}
+	}
+	async reconcile() {
+		const blocks = this.deps.store.list();
+		const mine = blocks.filter((b) => b.enabled && this.isPlacedHere(b));
+		const runners = new Map((await this.deps.host.list()).map((r) => [blockIdFromAddonId(r.name), r]).filter((pair) => pair[0] !== null));
+		for (const block of blocks) {
+			if (!block.enabled || this.isPlacedHere(block)) continue;
+			await this.report(block.id, "failed", `no core-block supervisor runs on "${block.placement}" — this block is not running anywhere. Move it to "${this.deps.nodeId}" to run it.`);
+		}
+		const wanted = new Set(mine.map((b) => b.id));
+		for (const [blockId, runner] of runners) {
+			if (wanted.has(blockId)) continue;
+			this.deps.logger.info("stopping core block runner", { meta: {
+				blockId,
+				runnerState: runner.state,
+				reason: this.stopReason(blockId)
+			} });
+			await this.deps.host.stop(blockAddonId(blockId));
+			this.materialized.delete(blockId);
+			if (this.deps.store.get(blockId) !== null) await this.report(blockId, "stopped");
+			else await removeBlockPackage(this.deps.root, blockId);
+		}
+		for (const block of mine) {
+			const runner = runners.get(block.id);
+			const stale = runner !== void 0 && this.materialized.get(block.id) !== block.updatedAt;
+			if (runner !== void 0 && !stale) {
+				await this.reportRunnerState(block, runner);
+				continue;
+			}
+			if (stale) {
+				this.deps.logger.info("core block code changed — restarting its runner", { meta: {
+					blockId: block.id,
+					name: block.name
+				} });
+				await this.deps.host.stop(blockAddonId(block.id));
+				this.materialized.delete(block.id);
+			}
+			await this.launch(block);
+		}
+	}
+	/** Compile, write the package, spawn. Each failure is reported ON the block
+	*  — the author asked for this to run, so they are owed the reason it does
+	*  not. */
+	async launch(block) {
+		const compiled = await this.deps.compile(block.code);
+		if (!compiled.ok || compiled.js === void 0) {
+			await this.report(block.id, "failed", `the block does not compile: ${compiled.error ?? "unknown"}`);
+			return;
+		}
+		try {
+			const pkg = await materializeBlock({
+				root: this.deps.root,
+				blockId: block.id,
+				blockName: block.name,
+				js: compiled.js
+			});
+			await this.deps.host.spawn({
+				runnerId: pkg.addonId,
+				addonId: pkg.addonId,
+				addonDir: pkg.addonDir
+			});
+			this.materialized.set(block.id, block.updatedAt);
+			this.deps.logger.info("core block runner spawned", { meta: {
+				blockId: block.id,
+				name: block.name,
+				runnerId: pkg.addonId
+			} });
+			await this.report(block.id, "starting");
+		} catch (err) {
+			const message = err instanceof Error ? err.message : String(err);
+			if (/already running/i.test(message)) {
+				this.materialized.set(block.id, block.updatedAt);
+				await this.report(block.id, "starting");
+				return;
+			}
+			this.deps.logger.error("core block failed to start", { meta: {
+				blockId: block.id,
+				name: block.name,
+				error: message
+			} });
+			await this.report(block.id, "failed", `could not start the block: ${message}`);
+		}
+	}
+	async reportRunnerState(block, runner) {
+		const status = RUNNER_STATE_TO_STATUS[runner.state];
+		if (status === null) return;
+		if (runner.state === "failed") {
+			await this.report(block.id, "failed", "the crash circuit-breaker tripped — the block crashed repeatedly and will not be respawned. Fix it and save, or disable and re-enable it.");
+			return;
+		}
+		if (runner.state === "crashed") {
+			await this.report(block.id, "starting", "the block crashed — a respawn is scheduled");
+			return;
+		}
+		await this.report(block.id, status);
+	}
+	/**
+	* Write a status only when it actually changed.
+	*
+	* A reconcile pass runs on a timer, and every write rewrites the row AND
+	* moves `lastChangedAt` — which is the only thing telling an operator WHEN a
+	* block last did something. Rewriting it every tick would make it read as
+	* "just now", forever.
+	*/
+	async report(blockId, status, error) {
+		const current = this.deps.store.get(blockId);
+		if (current !== null && current.status === status && current.lastError === error) return;
+		await this.deps.store.setStatus(blockId, status, error);
+	}
+	isPlacedHere(block) {
+		return block.placement === this.deps.nodeId;
+	}
+	stopReason(blockId) {
+		const block = this.deps.store.get(blockId);
+		if (block === null) return "deleted";
+		if (!block.enabled) return "disabled";
+		return `moved to "${block.placement}"`;
+	}
+};
+//#endregion
+//#region src/builtins/core-blocks/block-type-defs.ts
+/**
+* The declaration files a block is authored against.
+*
+* Served from the node rather than bundled into the admin UI: the graph is
+* 3.4 MB across 344 files. Served rather than hand-stubbed: a block runs with
+* the same `ctx` an addon gets, so a stub would drift from it and the editor
+* would confidently autocomplete methods that do not exist.
+*
+* The paths matter more than they look. Monaco resolves imports against the
+* extra-lib paths, so a file registered as anything other than
+* `file:///node_modules/@camstack/types/…` loads and then resolves NOTHING —
+* the failure that looks most like success, because the editor keeps working
+* and simply stops knowing anything.
+*/
+/** Where Monaco must think the files live for `@camstack/types` to resolve. */
+var VIRTUAL_ROOT = "file:///node_modules/@camstack/types";
+/**
+* Read every `.d.ts` under the installed `@camstack/types` dist.
+*
+* Best-effort by design: a node that cannot find them serves an EMPTY list, and
+* the editor then registers an empty lib set rather than keeping a stale one —
+* so an author sees "no types" instead of validating against a contract that
+* has moved.
+*/
+async function loadBlockTypeDefs(logger) {
+	const root = await resolveTypesDist();
+	if (root === null) {
+		logger.warn("core-blocks: @camstack/types declarations not found — the editor gets no types");
+		return [];
+	}
+	const out = [];
+	await walk(root, root, out);
+	return out;
+}
+async function resolveTypesDist() {
+	try {
+		const entry = await import.meta.resolve?.("@camstack/types");
+		if (typeof entry === "string") {
+			const dir = path$1.dirname(entry.replace("file://", ""));
+			if (await exists(path$1.join(dir, "index.d.ts"))) return dir;
+		}
+	} catch {}
+	const guess = path$1.resolve(process.cwd(), "node_modules/@camstack/types/dist");
+	return await exists(guess) ? guess : null;
+}
+async function exists(p) {
+	try {
+		await fs.access(p);
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function walk(root, dir, out) {
+	const entries = await fs.readdir(dir, { withFileTypes: true });
+	for (const entry of entries) {
+		const full = path$1.join(dir, entry.name);
+		if (entry.isDirectory()) {
+			await walk(root, full, out);
+			continue;
+		}
+		if (!entry.name.endsWith(".d.ts")) continue;
+		const content = await fs.readFile(full, "utf-8");
+		const relative = path$1.relative(root, full).split(path$1.sep).join("/");
+		out.push({
+			filePath: `${VIRTUAL_ROOT}/${relative}`,
+			content
+		});
+	}
+}
+//#endregion
 //#region src/builtins/core-blocks/compile-block.ts
 /** An esbuild error carries the position; the shape is narrow enough to read
 *  defensively rather than to type against the package. */
@@ -55,6 +454,19 @@ async function compileBlock(transpiler, code) {
 }
 //#endregion
 //#region src/builtins/core-blocks/core-block-store.ts
+/**
+* Durable storage for core blocks.
+*
+* A kernel table, not an addon's: a block is not owned by any addon — it is
+* user code the kernel runs. The name is bare for the same reason `users` and
+* `system-settings` are (the collection-namespacing guard scans
+* `packages/addon-*` only, and this is deliberately not one).
+*
+* The write path is the interesting part. **Source is never stored without
+* compiling it first.** A block that does not compile is not a broken row, it
+* is a fork failure the operator meets minutes later inside a log — so the
+* compile happens where they are still looking at the editor.
+*/
 var CORE_BLOCKS_COLLECTION = "core_blocks";
 var CORE_BLOCKS_COLUMNS = [
 	{
@@ -200,7 +612,7 @@ var CoreBlockStore = class {
 			lastChangedAt: this.now(),
 			...error !== void 0 ? { lastError: error } : {}
 		};
-		if (error === void 0 && next.lastError !== void 0 && status === "running") delete next.lastError;
+		if (error === void 0 && next.lastError !== void 0) delete next.lastError;
 		await this.persist(next);
 		this.byId.set(blockId, next);
 	}
@@ -227,78 +639,34 @@ var CoreBlockStore = class {
 	}
 };
 //#endregion
-//#region src/builtins/core-blocks/block-type-defs.ts
-/** Where Monaco must think the files live for `@camstack/types` to resolve. */
-var VIRTUAL_ROOT = "file:///node_modules/@camstack/types";
-/**
-* Read every `.d.ts` under the installed `@camstack/types` dist.
-*
-* Best-effort by design: a node that cannot find them serves an EMPTY list, and
-* the editor then registers an empty lib set rather than keeping a stale one —
-* so an author sees "no types" instead of validating against a contract that
-* has moved.
-*/
-async function loadBlockTypeDefs(logger) {
-	const root = await resolveTypesDist();
-	if (root === null) {
-		logger.warn("core-blocks: @camstack/types declarations not found — the editor gets no types");
-		return [];
-	}
-	const out = [];
-	await walk(root, root, out);
-	return out;
-}
-async function resolveTypesDist() {
-	try {
-		const entry = await import.meta.resolve?.("@camstack/types");
-		if (typeof entry === "string") {
-			const dir = path$1.dirname(entry.replace("file://", ""));
-			if (await exists(path$1.join(dir, "index.d.ts"))) return dir;
-		}
-	} catch {}
-	const guess = path$1.resolve(process.cwd(), "node_modules/@camstack/types/dist");
-	return await exists(guess) ? guess : null;
-}
-async function exists(p) {
-	try {
-		await fs.access(p);
-		return true;
-	} catch {
-		return false;
-	}
-}
-async function walk(root, dir, out) {
-	const entries = await fs.readdir(dir, { withFileTypes: true });
-	for (const entry of entries) {
-		const full = path$1.join(dir, entry.name);
-		if (entry.isDirectory()) {
-			await walk(root, full, out);
-			continue;
-		}
-		if (!entry.name.endsWith(".d.ts")) continue;
-		const content = await fs.readFile(full, "utf-8");
-		const relative = path$1.relative(root, full).split(path$1.sep).join("/");
-		out.push({
-			filePath: `${VIRTUAL_ROOT}/${relative}`,
-			content
-		});
-	}
-}
-//#endregion
 //#region src/builtins/core-blocks/core-blocks.addon.ts
 /**
 * The `core-blocks` provider — CRUD over user-authored TypeScript, with the
-* compile gate in front of every write.
+* compile gate in front of every write, and the supervisor that turns a stored
+* block into a running process.
 *
 * A builtin because a block belongs to the kernel, not to an addon: it is user
 * code the node runs, and it must exist on every install with no opt-in step.
 *
-* **This slice stores and serves. It does not EXECUTE.** The runner (fork per
-* block, `ctx` over UDS, `CrashSupervisor`) is the next piece, and a block
-* therefore sits at `status: 'stopped'` no matter what it says. That is stated
-* here rather than implied because a system that accepted code and quietly
-* never ran it would be the exact failure this repo keeps paying for.
+* **Execution is HUB-ONLY for now**, and that limit is loud rather than
+* implied: a block placed on any other node is reported `failed` with a message
+* naming the node, because an enabled block nothing runs must never look like
+* an idle one. The supervisor is already written per-node (`converge()` only
+* ever considers blocks placed on `nodeId`), so the agent case is an
+* implementation of `BlockProcessHost` plus a way to reach the hub's store —
+* not a redesign.
+*/
+/**
+* How often the supervisor re-reads the world.
+*
+* It is not the primary trigger — every write converges immediately — but the
+* one that catches what a write cannot: a runner that crashed, a breaker that
+* tripped, a spawn that never landed. D8: events may be dropped, so the
+* reconcile is what makes the outcome eventually true.
 */
+var CONVERGE_INTERVAL_MS = 15e3;
+/** Where block packages are materialised, under this node's data root. */
+var BLOCK_PACKAGE_DIRNAME = "core-blocks";
 var CoreBlocksAddon = class extends BaseAddon {
 	/**
 	* `super({})` is NOT optional, and its absence is invisible until runtime:
@@ -313,6 +681,7 @@ var CoreBlocksAddon = class extends BaseAddon {
 	store = null;
 	transpiler = null;
 	typeDefs = null;
+	supervisor = null;
 	async onInitialize() {
 		const settingsStore = this.ctx.api?.settingsStore;
 		if (!settingsStore) throw new Error("core-blocks: settings-store API not available — refusing to register the cap");
@@ -323,9 +692,12 @@ var CoreBlocksAddon = class extends BaseAddon {
 		});
 		await this.store.load();
 		this.transpiler = await loadTranspiler(this.ctx.logger);
+		this.supervisor = this.buildSupervisor();
+		this.supervisor?.start(CONVERGE_INTERVAL_MS);
 		this.ctx.logger.info("core-blocks ready", { meta: {
 			blocks: this.store.list().length,
-			compile: this.transpiler !== null
+			compile: this.transpiler !== null,
+			supervising: this.supervisor !== null
 		} });
 		return [{
 			capability: coreBlocksCapability,
@@ -333,10 +705,65 @@ var CoreBlocksAddon = class extends BaseAddon {
 		}];
 	}
 	async onShutdown() {
+		this.supervisor?.stop();
+		this.supervisor = null;
 		this.store = null;
 		this.transpiler = null;
 		this.typeDefs = null;
 	}
+	/**
+	* Build the supervisor, or explain in one line why this node runs no blocks.
+	*
+	* Two ways to end up with none, and both are logged rather than inferred:
+	* this is not the hub (execution is hub-only for now), or the kernel exposed
+	* no cluster broker, which is the only door to `$process.*`.
+	*/
+	buildSupervisor() {
+		const rawNodeId = this.ctx.kernel.localNodeId ?? "hub";
+		const nodeId = rawNodeId.includes("/") ? rawNodeId.split("/")[0] ?? "hub" : rawNodeId;
+		if (nodeId !== "hub") {
+			this.ctx.logger.info("core-blocks execution is hub-only — no blocks will run on this node", { meta: {
+				nodeId,
+				rawNodeId
+			} });
+			return null;
+		}
+		const broker = this.ctx.kernel.cluster?.broker;
+		if (!broker) {
+			this.ctx.logger.warn("core-blocks: no cluster broker — blocks can be stored and compiled, but nothing can run them");
+			return null;
+		}
+		const store = this.requireStore();
+		return new BlockSupervisor({
+			nodeId,
+			root: path$1.join(this.ctx.nodeDataDir, BLOCK_PACKAGE_DIRNAME),
+			store: {
+				list: () => store.list(),
+				get: (blockId) => store.get(blockId),
+				setStatus: (blockId, status, error) => store.setStatus(blockId, status, error)
+			},
+			host: createBrokerProcessHost(broker),
+			compile: async (code) => {
+				if (this.transpiler === null) return {
+					ok: false,
+					error: "the compiler is unavailable on this node"
+				};
+				return compileBlock(this.transpiler, code);
+			},
+			logger: this.ctx.logger.child("supervisor")
+		});
+	}
+	/**
+	* Reconcile now, after a write.
+	*
+	* The timer would get there on its own, but an operator who presses Save and
+	* watches a block sit at `stopped` for fifteen seconds has been told nothing
+	* happened. Deliberately NOT awaited by the cap method: converging forks a
+	* process, and the write is already durable.
+	*/
+	convergeSoon() {
+		this.supervisor?.converge();
+	}
 	requireStore() {
 		if (this.store === null) throw new Error("core-blocks: not initialized");
 		return this.store;
@@ -368,6 +795,7 @@ var CoreBlocksAddon = class extends BaseAddon {
 					name: created.name,
 					by: caller.userId
 				} });
+				this.convergeSoon();
 				return { block: created };
 			},
 			update: async ({ blockId, block, caller }) => {
@@ -377,14 +805,18 @@ var CoreBlocksAddon = class extends BaseAddon {
 					blockId,
 					by: caller.userId
 				} });
+				this.convergeSoon();
 				return { block: updated };
 			},
 			delete: async ({ blockId }) => {
 				await this.requireStore().delete(blockId);
+				this.convergeSoon();
 				return { success: true };
 			},
 			setEnabled: async ({ blockId, enabled }) => {
-				return { block: await this.requireStore().update(blockId, { enabled }) };
+				const updated = await this.requireStore().update(blockId, { enabled });
+				this.convergeSoon();
+				return { block: updated };
 			},
 			compile: async ({ code }) => {
 				if (this.transpiler === null) return {
@@ -404,6 +836,33 @@ var CoreBlocksAddon = class extends BaseAddon {
 		};
 	}
 };
+/**
+* The process plane, over the kernel's cluster broker.
+*
+* `$process.*` is the SAME infrastructure every addon runner uses — no new
+* Moleculer action, no second spawner, no parallel supervisor. That is the
+* whole point: a block gets fork, the UDS `ctx`, `CrashSupervisor` (D6) and
+* `execution.placement` because it is spawned exactly like an addon.
+*/
+function createBrokerProcessHost(broker) {
+	return {
+		list: async () => {
+			return await broker.call("$process.list");
+		},
+		spawn: async ({ runnerId, addonId, addonDir }) => {
+			await broker.call("$process.spawnRunner", {
+				runnerId,
+				addons: [{
+					addonId,
+					addonDir
+				}]
+			});
+		},
+		stop: async (runnerId) => {
+			await broker.call("$process.stop", { name: runnerId });
+		}
+	};
+}
 /** Load esbuild lazily. Returns null — never throws — so a node without it
 *  still boots, with the compile gate refusing writes rather than the node
 *  refusing to start. */
@@ -418,4 +877,4 @@ async function loadTranspiler(logger) {
 	}
 }
 //#endregion
-export { CoreBlocksAddon, compileBlock as i, CORE_BLOCKS_COLLECTION as n, CoreBlockStore as r, loadBlockTypeDefs as t };
+export { CoreBlocksAddon, BlockSupervisor as a, blockIdFromAddonId as c, loadBlockTypeDefs as i, materializeBlock as l, CoreBlockStore as n, BLOCK_ADDON_PREFIX as o, compileBlock as r, blockAddonId as s, CORE_BLOCKS_COLLECTION as t, removeBlockPackage as u };

package/dist/builtins/core-blocks/index.d.ts

@@ -1,4 +1,6 @@
+export { BLOCK_ADDON_PREFIX, blockAddonId, blockIdFromAddonId, materializeBlock, removeBlockPackage, } from './block-package.js';
+export { type BlockProcessHost, type BlockRunnerSnapshot, type BlockRunnerState, BlockSupervisor, } from './block-supervisor.js';
+export { type BlockTypeLib, loadBlockTypeDefs } from './block-type-defs.js';
+export { type BlockTranspiler, compileBlock } from './compile-block.js';
+export { CORE_BLOCKS_COLLECTION, CoreBlockStore } from './core-block-store.js';
 export { CoreBlocksAddon as default, CoreBlocksAddon } from './core-blocks.addon.js';
-export { CoreBlockStore, CORE_BLOCKS_COLLECTION } from './core-block-store.js';
-export { compileBlock, type BlockTranspiler } from './compile-block.js';
-export { loadBlockTypeDefs, type BlockTypeLib } from './block-type-defs.js';