@camstack/system 1.2.39 → 1.2.40

package/dist/builtins/addon-pages-aggregator/addon-pages-aggregator.addon.js

@@ -3,7 +3,7 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 const require_chunk = require("../../chunk-Cek0wNdY.js");
-const require_dist = require("../../dist-CFinlH7b.js");
+const require_dist = require("../../dist-Cj0LAuXi.js");
 const require_settle_sources = require("../../settle-sources-Bhsy57y-.js");
 let node_fs = require("node:fs");
 node_fs = require_chunk.__toESM(node_fs);

package/dist/builtins/addon-pages-aggregator/addon-pages-aggregator.addon.mjs

@@ -1,4 +1,4 @@
-import { Pt as EventCategory, ct as BaseAddon, m as addonPagesCapability, st as errMsg } from "../../dist-DO76YVO2.mjs";
+import { Pt as EventCategory, ct as BaseAddon, m as addonPagesCapability, st as errMsg } from "../../dist-BXS0DP92.mjs";
 import { t as settleSourcesWithTimeout } from "../../settle-sources-CDtNC8ub.mjs";
 import * as fs from "node:fs";
 import * as path$1 from "node:path";

package/dist/builtins/addon-widgets-aggregator/addon-widgets-aggregator.addon.js

@@ -3,7 +3,7 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 const require_chunk = require("../../chunk-Cek0wNdY.js");
-const require_dist = require("../../dist-CFinlH7b.js");
+const require_dist = require("../../dist-Cj0LAuXi.js");
 const require_settle_sources = require("../../settle-sources-Bhsy57y-.js");
 let node_fs = require("node:fs");
 node_fs = require_chunk.__toESM(node_fs);

package/dist/builtins/addon-widgets-aggregator/addon-widgets-aggregator.addon.mjs

@@ -1,4 +1,4 @@
-import { Pt as EventCategory, ct as BaseAddon, g as addonWidgetsCapability, st as errMsg } from "../../dist-DO76YVO2.mjs";
+import { Pt as EventCategory, ct as BaseAddon, g as addonWidgetsCapability, st as errMsg } from "../../dist-BXS0DP92.mjs";
 import { t as settleSourcesWithTimeout } from "../../settle-sources-CDtNC8ub.mjs";
 import * as fs from "node:fs";
 import * as path$1 from "node:path";

package/dist/builtins/alerts/alerts.addon.js

@@ -3,7 +3,7 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 require("../../chunk-Cek0wNdY.js");
-const require_dist = require("../../dist-CFinlH7b.js");
+const require_dist = require("../../dist-Cj0LAuXi.js");
 //#region src/builtins/alerts/prune-policy.ts
 /**
 * Ids older than `cutoffMs`, oldest first.

package/dist/builtins/alerts/alerts.addon.mjs

@@ -1,4 +1,4 @@
-import { Pt as EventCategory, _ as alertsCapability, ct as BaseAddon, n as AlertSchema, st as errMsg, xt as createEvent } from "../../dist-DO76YVO2.mjs";
+import { Pt as EventCategory, _ as alertsCapability, ct as BaseAddon, n as AlertSchema, st as errMsg, xt as createEvent } from "../../dist-BXS0DP92.mjs";
 //#region src/builtins/alerts/prune-policy.ts
 /**
 * Ids older than `cutoffMs`, oldest first.

package/dist/builtins/backup-orchestrator/backup-orchestrator.addon.js

@@ -3,7 +3,7 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 const require_chunk = require("../../chunk-Cek0wNdY.js");
-const require_dist = require("../../dist-CFinlH7b.js");
+const require_dist = require("../../dist-Cj0LAuXi.js");
 let node_fs = require("node:fs");
 let node_fs$1 = require_chunk.__toESM(node_fs, 1);
 node_fs = require_chunk.__toESM(node_fs);

package/dist/builtins/backup-orchestrator/backup-orchestrator.addon.mjs

@@ -1,4 +1,4 @@
-import { Pt as EventCategory, b as backupCapability, ct as BaseAddon } from "../../dist-DO76YVO2.mjs";
+import { Pt as EventCategory, b as backupCapability, ct as BaseAddon } from "../../dist-BXS0DP92.mjs";
 import * as fs from "node:fs";
 import Kt from "node:fs";
 import * as path$1 from "node:path";

package/dist/builtins/console-logging/index.js

@@ -3,7 +3,7 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 require("../../chunk-Cek0wNdY.js");
-const require_dist = require("../../dist-CFinlH7b.js");
+const require_dist = require("../../dist-Cj0LAuXi.js");
 const require_formatter = require("../../formatter-DqAKDlvN.js");
 //#region src/builtins/console-logging/console-destination.ts
 var LEVEL_RANK = {

package/dist/builtins/console-logging/index.mjs

@@ -1,4 +1,4 @@
-import { H as logDestinationCapability, ct as BaseAddon } from "../../dist-DO76YVO2.mjs";
+import { H as logDestinationCapability, ct as BaseAddon } from "../../dist-BXS0DP92.mjs";
 import { t as formatLogLine } from "../../formatter-B7qW8bPJ.mjs";
 //#region src/builtins/console-logging/console-destination.ts
 var LEVEL_RANK = {

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

@@ -0,0 +1,59 @@
+/**
+ * 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. */
+export declare const BLOCK_ADDON_PREFIX = "core-block-";
+/** The generated addon/runner id for a block. */
+export declare function blockAddonId(blockId: string): string;
+/** 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. */
+export declare function blockIdFromAddonId(addonId: string): string | null;
+export interface MaterializeBlockInput {
+    /** Root under which every block package lives — one directory per block. */
+    readonly root: string;
+    readonly blockId: string;
+    readonly blockName: string;
+    /** The block's transpiled JavaScript. */
+    readonly js: string;
+}
+export interface MaterializedBlock {
+    /** What `$process.spawnRunner` gets as `addonDir` — the package root. */
+    readonly addonDir: string;
+    readonly addonId: string;
+}
+/** Build the wrapper for one block. Exported for the test that asserts the
+ *  generated source actually carries the block's identity. */
+export declare function renderBlockWrapper(blockId: string, blockName: string): string;
+/** The package manifest the addon runner reads to find the entry point. */
+export declare function renderBlockManifest(blockId: string, blockName: string): string;
+/**
+ * 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.
+ */
+export declare function materializeBlock(input: MaterializeBlockInput): Promise<MaterializedBlock>;
+/** Remove a block's package. Idempotent — a missing directory is the desired
+ *  end state, not an error. */
+export declare function removeBlockPackage(root: string, blockId: string): Promise<void>;

package/dist/builtins/core-blocks/block-supervisor.d.ts

@@ -0,0 +1,86 @@
+import { CoreBlock, IScopedLogger } from '@camstack/types';
+/** The runner lifecycle states `$process.list` reports. `stopping`/`stopped`
+ *  are transient states of a runner on its way out and are treated as absent. */
+export type BlockRunnerState = 'starting' | 'running' | 'stopping' | 'stopped' | 'crashed' | 'failed';
+export interface BlockRunnerSnapshot {
+    /** The runner id — equal to the generated addon id for a block runner. */
+    readonly name: string;
+    readonly state: BlockRunnerState;
+}
+/**
+ * The process plane, narrowed to the three things a block needs.
+ *
+ * Injected rather than reached for, so the decision logic above is testable
+ * without a broker — and so the day a block runs on an agent, only this
+ * implementation changes.
+ */
+export interface BlockProcessHost {
+    list(): Promise<readonly BlockRunnerSnapshot[]>;
+    spawn(input: {
+        runnerId: string;
+        addonId: string;
+        addonDir: string;
+    }): Promise<void>;
+    stop(runnerId: string): Promise<void>;
+}
+export interface BlockCompileOutcome {
+    readonly ok: boolean;
+    readonly error?: string;
+    readonly js?: string;
+}
+export interface BlockSupervisorDeps {
+    /** This node's id, already stripped of any `/<addon>` runner suffix. */
+    readonly nodeId: string;
+    /** Where block packages are materialised — one directory per block. */
+    readonly root: string;
+    readonly store: BlockStoreView;
+    readonly host: BlockProcessHost;
+    readonly compile: (code: string) => Promise<BlockCompileOutcome>;
+    readonly logger: IScopedLogger;
+}
+/** The slice of `CoreBlockStore` the supervisor uses. */
+export interface BlockStoreView {
+    list(): readonly CoreBlock[];
+    get(blockId: string): CoreBlock | null;
+    setStatus(blockId: string, status: CoreBlock['status'], error?: string): Promise<void>;
+}
+export declare class BlockSupervisor {
+    private readonly 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.
+     */
+    private readonly materialized;
+    private timer;
+    /** Serialises passes so a timer tick cannot interleave with a write-driven
+     *  converge and spawn the same runner twice. */
+    private inFlight;
+    constructor(deps: BlockSupervisorDeps);
+    /** Start the reconcile timer. The first pass runs immediately. */
+    start(intervalMs: number): void;
+    stop(): void;
+    /** 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(): Promise<void>;
+    private runPass;
+    private reconcile;
+    /** 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. */
+    private launch;
+    private reportRunnerState;
+    /**
+     * 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.
+     */
+    private report;
+    private isPlacedHere;
+    private stopReason;
+}

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

@@ -11,8 +11,26 @@ export declare class CoreBlocksAddon extends BaseAddon {
     private store;
     private transpiler;
     private typeDefs;
+    private supervisor;
     protected onInitialize(): Promise<ProviderRegistration[]>;
     protected onShutdown(): Promise<void>;
+    /**
+     * 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.*`.
+     */
+    private buildSupervisor;
+    /**
+     * 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.
+     */
+    private convergeSoon;
     private requireStore;
     /**
      * Compile, or explain why not.