@camstack/system 1.2.34 → 1.2.36

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-Bqyu3d1X.js");
+const require_dist = require("../../dist-CFinlH7b.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 { Mt as EventCategory, at as errMsg, ot as BaseAddon, p as addonPagesCapability } from "../../dist-BjUYsgkj.mjs";
+import { Pt as EventCategory, ct as BaseAddon, m as addonPagesCapability, st as errMsg } from "../../dist-DO76YVO2.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-Bqyu3d1X.js");
+const require_dist = require("../../dist-CFinlH7b.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 { Mt as EventCategory, at as errMsg, h as addonWidgetsCapability, ot as BaseAddon } from "../../dist-BjUYsgkj.mjs";
+import { Pt as EventCategory, ct as BaseAddon, g as addonWidgetsCapability, st as errMsg } from "../../dist-DO76YVO2.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-Bqyu3d1X.js");
+const require_dist = require("../../dist-CFinlH7b.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 { Mt as EventCategory, at as errMsg, g as alertsCapability, n as AlertSchema, ot as BaseAddon, yt as createEvent } from "../../dist-BjUYsgkj.mjs";
+import { Pt as EventCategory, _ as alertsCapability, ct as BaseAddon, n as AlertSchema, st as errMsg, xt as createEvent } from "../../dist-DO76YVO2.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-Bqyu3d1X.js");
+const require_dist = require("../../dist-CFinlH7b.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 { Mt as EventCategory, ot as BaseAddon, y as backupCapability } from "../../dist-BjUYsgkj.mjs";
+import { Pt as EventCategory, b as backupCapability, ct as BaseAddon } from "../../dist-DO76YVO2.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-Bqyu3d1X.js");
+const require_dist = require("../../dist-CFinlH7b.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 { B as logDestinationCapability, ot as BaseAddon } from "../../dist-BjUYsgkj.mjs";
+import { H as logDestinationCapability, ct as BaseAddon } from "../../dist-DO76YVO2.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-type-defs.d.ts

@@ -0,0 +1,14 @@
+import { IScopedLogger } from '@camstack/types';
+export interface BlockTypeLib {
+    readonly filePath: string;
+    readonly content: string;
+}
+/**
+ * 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.
+ */
+export declare function loadBlockTypeDefs(logger: IScopedLogger): Promise<readonly BlockTypeLib[]>;

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

@@ -0,0 +1,21 @@
+import { CoreBlockCompileResult } from '@camstack/types';
+/** The esbuild surface this needs — injected so the compile is testable and so
+ *  the kernel does not hard-depend on a bundler at import time. */
+export interface BlockTranspiler {
+    transform(code: string, options: {
+        loader: 'ts';
+        format: 'esm';
+        target: string;
+    }): Promise<{
+        code: string;
+    }>;
+}
+export interface CompileBlockResult extends CoreBlockCompileResult {
+    /** The emitted JavaScript, when it compiled. */
+    readonly js?: string;
+}
+/**
+ * Never throws. A compile failure is an ANSWER — the author needs to read it,
+ * and a thrown error at this layer becomes a 500 with the useful part buried.
+ */
+export declare function compileBlock(transpiler: BlockTranspiler, code: string): Promise<CompileBlockResult>;

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

@@ -0,0 +1,73 @@
+import { CoreBlock, CoreBlockInput, IScopedLogger, SettingsStoreClient } from '@camstack/types';
+export declare const CORE_BLOCKS_COLLECTION = "core_blocks";
+export declare const CORE_BLOCKS_COLUMNS: readonly [{
+    readonly name: "id";
+    readonly type: "TEXT";
+    readonly primaryKey: true;
+    readonly notNull: true;
+}, {
+    readonly name: "name";
+    readonly type: "TEXT";
+    readonly notNull: true;
+}, {
+    readonly name: "enabled";
+    readonly type: "BOOLEAN";
+    readonly notNull: true;
+}, {
+    readonly name: "placement";
+    readonly type: "TEXT";
+    readonly notNull: true;
+}, {
+    readonly name: "updatedAt";
+    readonly type: "INTEGER";
+    readonly notNull: true;
+}, {
+    readonly name: "block";
+    readonly type: "JSON";
+    readonly notNull: true;
+}];
+export declare const CORE_BLOCKS_INDEXES: readonly [{
+    readonly name: "idx_core_blocks_enabled";
+    readonly columns: readonly ["enabled"];
+}];
+export interface CoreBlockStoreDeps {
+    readonly store: SettingsStoreClient;
+    readonly logger: IScopedLogger;
+    readonly now?: () => number;
+    readonly newId?: () => string;
+}
+export declare class CoreBlockStore {
+    private readonly byId;
+    private readonly store;
+    private readonly logger;
+    private readonly now;
+    private readonly newId;
+    constructor(deps: CoreBlockStoreDeps);
+    static declare(store: SettingsStoreClient): Promise<void>;
+    /**
+     * Hydrate every block.
+     *
+     * A row whose JSON no longer validates is SKIPPED with a warning rather than
+     * dropped or repaired: it is somebody's code, and the honest answer to "I
+     * cannot read this" is to leave it on disk and say so.
+     */
+    load(): Promise<void>;
+    list(): readonly CoreBlock[];
+    get(blockId: string): CoreBlock | null;
+    /** Blocks that should be running here. The runner's input. */
+    enabledFor(nodeId: string): readonly CoreBlock[];
+    create(input: CoreBlockInput, createdBy: string): Promise<CoreBlock>;
+    /** Apply a partial patch. Immutable: returns the NEW block. */
+    update(blockId: string, patch: Partial<CoreBlockInput>): Promise<CoreBlock>;
+    /**
+     * Record what the runner did with this block.
+     *
+     * Separate from {@link update} on purpose: status is the RUNNER's to write
+     * and the author's to read, and letting an edit set it would let the UI claim
+     * a block is running because somebody renamed it.
+     */
+    setStatus(blockId: string, status: CoreBlock['status'], error?: string): Promise<void>;
+    /** Idempotent delete — an unknown id is a no-op. */
+    delete(blockId: string): Promise<void>;
+    private persist;
+}

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

@@ -0,0 +1,19 @@
+import { BaseAddon, CoreBlock, ProviderRegistration } from '@camstack/types';
+export declare class CoreBlocksAddon extends BaseAddon {
+    private store;
+    private transpiler;
+    private typeDefs;
+    protected onInitialize(): Promise<ProviderRegistration[]>;
+    protected onShutdown(): Promise<void>;
+    private requireStore;
+    /**
+     * Compile, or explain why not.
+     *
+     * A missing transpiler REFUSES the write rather than waving it through: code
+     * that reached disk uncompiled is code the runner will fail on, far from the
+     * person who wrote it.
+     */
+    private gate;
+    private buildProvider;
+}
+export type { CoreBlock };

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

@@ -0,0 +1,418 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_chunk = require("../../chunk-Cek0wNdY.js");
+const require_dist = require("../../dist-CFinlH7b.js");
+let node_path = require("node:path");
+node_path = require_chunk.__toESM(node_path);
+let node_crypto = require("node:crypto");
+let node_fs_promises = require("node:fs/promises");
+node_fs_promises = require_chunk.__toESM(node_fs_promises);
+//#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. */
+function positionOf(err) {
+	if (err === null || typeof err !== "object") return {};
+	const errors = err.errors;
+	if (!Array.isArray(errors) || errors.length === 0) return {};
+	const location = errors[0].location;
+	if (location === null || typeof location !== "object") return {};
+	const l = location;
+	return {
+		...typeof l.line === "number" ? { line: l.line } : {},
+		...typeof l.column === "number" ? { column: l.column } : {}
+	};
+}
+function messageOf(err) {
+	if (err === null || typeof err !== "object") return String(err);
+	const errors = err.errors;
+	if (Array.isArray(errors) && errors.length > 0) {
+		const text = errors[0].text;
+		if (typeof text === "string") return text;
+	}
+	return err instanceof Error ? err.message : String(err);
+}
+/**
+* Never throws. A compile failure is an ANSWER — the author needs to read it,
+* and a thrown error at this layer becomes a 500 with the useful part buried.
+*/
+async function compileBlock(transpiler, code) {
+	if (code.trim().length === 0) return {
+		ok: false,
+		error: "the block is empty — it must export a default function"
+	};
+	try {
+		return {
+			ok: true,
+			js: (await transpiler.transform(code, {
+				loader: "ts",
+				format: "esm",
+				target: "node22"
+			})).code
+		};
+	} catch (err) {
+		return {
+			ok: false,
+			error: messageOf(err),
+			...positionOf(err)
+		};
+	}
+}
+//#endregion
+//#region src/builtins/core-blocks/core-block-store.ts
+var CORE_BLOCKS_COLLECTION = "core_blocks";
+var CORE_BLOCKS_COLUMNS = [
+	{
+		name: "id",
+		type: "TEXT",
+		primaryKey: true,
+		notNull: true
+	},
+	{
+		name: "name",
+		type: "TEXT",
+		notNull: true
+	},
+	{
+		name: "enabled",
+		type: "BOOLEAN",
+		notNull: true
+	},
+	{
+		name: "placement",
+		type: "TEXT",
+		notNull: true
+	},
+	{
+		name: "updatedAt",
+		type: "INTEGER",
+		notNull: true
+	},
+	(
+	/** The FULL block, Zod-validated on read; the scalars above are indexed
+	*  projections for the list view. */
+	{
+		name: "block",
+		type: "JSON",
+		notNull: true
+	})
+];
+var CORE_BLOCKS_INDEXES = [{
+	name: "idx_core_blocks_enabled",
+	columns: ["enabled"]
+}];
+var CoreBlockStore = class {
+	byId = /* @__PURE__ */ new Map();
+	store;
+	logger;
+	now;
+	newId;
+	constructor(deps) {
+		this.store = deps.store;
+		this.logger = deps.logger;
+		this.now = deps.now ?? (() => Date.now());
+		this.newId = deps.newId ?? (() => (0, node_crypto.randomUUID)());
+	}
+	static async declare(store) {
+		await store.declareCollection.mutate({
+			collection: CORE_BLOCKS_COLLECTION,
+			columns: [...CORE_BLOCKS_COLUMNS],
+			indexes: [...CORE_BLOCKS_INDEXES]
+		});
+	}
+	/**
+	* Hydrate every block.
+	*
+	* A row whose JSON no longer validates is SKIPPED with a warning rather than
+	* dropped or repaired: it is somebody's code, and the honest answer to "I
+	* cannot read this" is to leave it on disk and say so.
+	*/
+	async load() {
+		try {
+			const rows = await this.store.query.query({
+				collection: CORE_BLOCKS_COLLECTION,
+				filter: { limit: 1e3 }
+			});
+			this.byId.clear();
+			let skipped = 0;
+			for (const row of rows) {
+				const parsed = require_dist.CoreBlockSchema.safeParse(row.data["block"]);
+				if (!parsed.success) {
+					skipped += 1;
+					continue;
+				}
+				this.byId.set(parsed.data.id, parsed.data);
+			}
+			if (skipped > 0) this.logger.warn("core blocks skipped as unreadable — left on disk, not repaired", { meta: { skipped } });
+		} catch (err) {
+			this.logger.warn("core block load failed", { meta: { error: String(err) } });
+		}
+	}
+	list() {
+		return [...this.byId.values()].toSorted((a, b) => a.name.localeCompare(b.name));
+	}
+	get(blockId) {
+		return this.byId.get(blockId) ?? null;
+	}
+	/** Blocks that should be running here. The runner's input. */
+	enabledFor(nodeId) {
+		return this.list().filter((b) => b.enabled && b.placement === nodeId);
+	}
+	async create(input, createdBy) {
+		const now = this.now();
+		const block = require_dist.CoreBlockSchema.parse({
+			...input,
+			id: this.newId(),
+			createdBy,
+			createdAt: now,
+			updatedAt: now,
+			status: "stopped",
+			lastChangedAt: now
+		});
+		await this.persist(block);
+		this.byId.set(block.id, block);
+		return block;
+	}
+	/** Apply a partial patch. Immutable: returns the NEW block. */
+	async update(blockId, patch) {
+		const existing = this.byId.get(blockId);
+		if (!existing) throw new Error(`core block not found: ${blockId}`);
+		const updated = require_dist.CoreBlockSchema.parse({
+			...existing,
+			...patch,
+			id: existing.id,
+			createdBy: existing.createdBy,
+			createdAt: existing.createdAt,
+			updatedAt: this.now()
+		});
+		await this.persist(updated);
+		this.byId.set(updated.id, updated);
+		return updated;
+	}
+	/**
+	* Record what the runner did with this block.
+	*
+	* Separate from {@link update} on purpose: status is the RUNNER's to write
+	* and the author's to read, and letting an edit set it would let the UI claim
+	* a block is running because somebody renamed it.
+	*/
+	async setStatus(blockId, status, error) {
+		const existing = this.byId.get(blockId);
+		if (!existing) return;
+		const next = {
+			...existing,
+			status,
+			lastChangedAt: this.now(),
+			...error !== void 0 ? { lastError: error } : {}
+		};
+		if (error === void 0 && next.lastError !== void 0 && status === "running") delete next.lastError;
+		await this.persist(next);
+		this.byId.set(blockId, next);
+	}
+	/** Idempotent delete — an unknown id is a no-op. */
+	async delete(blockId) {
+		this.byId.delete(blockId);
+		await this.store.delete.mutate({
+			collection: CORE_BLOCKS_COLLECTION,
+			key: blockId
+		});
+	}
+	async persist(block) {
+		await this.store.set.mutate({
+			collection: CORE_BLOCKS_COLLECTION,
+			key: block.id,
+			value: {
+				name: block.name,
+				enabled: block.enabled,
+				placement: block.placement,
+				updatedAt: block.updatedAt,
+				block
+			}
+		});
+	}
+};
+//#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 {}.resolve?.("@camstack/types");
+		if (typeof entry === "string") {
+			const dir = node_path.dirname(entry.replace("file://", ""));
+			if (await exists(node_path.join(dir, "index.d.ts"))) return dir;
+		}
+	} catch {}
+	const guess = node_path.resolve(process.cwd(), "node_modules/@camstack/types/dist");
+	return await exists(guess) ? guess : null;
+}
+async function exists(p) {
+	try {
+		await node_fs_promises.access(p);
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function walk(root, dir, out) {
+	const entries = await node_fs_promises.readdir(dir, { withFileTypes: true });
+	for (const entry of entries) {
+		const full = node_path.join(dir, entry.name);
+		if (entry.isDirectory()) {
+			await walk(root, full, out);
+			continue;
+		}
+		if (!entry.name.endsWith(".d.ts")) continue;
+		const content = await node_fs_promises.readFile(full, "utf-8");
+		const relative = node_path.relative(root, full).split(node_path.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.
+*
+* 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.
+*/
+var CoreBlocksAddon = class extends require_dist.BaseAddon {
+	store = null;
+	transpiler = null;
+	typeDefs = 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");
+		await CoreBlockStore.declare(settingsStore);
+		this.store = new CoreBlockStore({
+			store: settingsStore,
+			logger: this.ctx.logger.child("store")
+		});
+		await this.store.load();
+		this.transpiler = await loadTranspiler(this.ctx.logger);
+		this.ctx.logger.info("core-blocks ready", { meta: {
+			blocks: this.store.list().length,
+			compile: this.transpiler !== null
+		} });
+		return [{
+			capability: require_dist.coreBlocksCapability,
+			provider: this.buildProvider()
+		}];
+	}
+	async onShutdown() {
+		this.store = null;
+		this.transpiler = null;
+		this.typeDefs = null;
+	}
+	requireStore() {
+		if (this.store === null) throw new Error("core-blocks: not initialized");
+		return this.store;
+	}
+	/**
+	* Compile, or explain why not.
+	*
+	* A missing transpiler REFUSES the write rather than waving it through: code
+	* that reached disk uncompiled is code the runner will fail on, far from the
+	* person who wrote it.
+	*/
+	async gate(code) {
+		if (this.transpiler === null) throw new Error("core-blocks: the compiler is unavailable — refusing to store unchecked code");
+		const result = await compileBlock(this.transpiler, code);
+		if (!result.ok) {
+			const where = result.line !== void 0 ? ` (line ${result.line})` : "";
+			throw new Error(`core-blocks: the code does not compile${where}: ${result.error ?? "unknown"}`);
+		}
+	}
+	buildProvider() {
+		return {
+			list: async () => ({ blocks: [...this.requireStore().list()] }),
+			get: async ({ blockId }) => ({ block: this.requireStore().get(blockId) }),
+			create: async ({ block, caller }) => {
+				await this.gate(block.code);
+				const created = await this.requireStore().create(block, caller.userId);
+				this.ctx.logger.info("core block created", { meta: {
+					blockId: created.id,
+					name: created.name,
+					by: caller.userId
+				} });
+				return { block: created };
+			},
+			update: async ({ blockId, block, caller }) => {
+				if (block.code !== void 0) await this.gate(block.code);
+				const updated = await this.requireStore().update(blockId, block);
+				this.ctx.logger.info("core block updated", { meta: {
+					blockId,
+					by: caller.userId
+				} });
+				return { block: updated };
+			},
+			delete: async ({ blockId }) => {
+				await this.requireStore().delete(blockId);
+				return { success: true };
+			},
+			setEnabled: async ({ blockId, enabled }) => {
+				return { block: await this.requireStore().update(blockId, { enabled }) };
+			},
+			compile: async ({ code }) => {
+				if (this.transpiler === null) return {
+					ok: false,
+					error: "the compiler is unavailable on this node"
+				};
+				const { js: _js, ...verdict } = await compileBlock(this.transpiler, code);
+				return verdict;
+			},
+			getTypeDefs: async () => {
+				this.typeDefs ??= await loadBlockTypeDefs(this.ctx.logger);
+				return { libs: this.typeDefs.map((l) => ({
+					filePath: l.filePath,
+					content: l.content
+				})) };
+			}
+		};
+	}
+};
+/** 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. */
+async function loadTranspiler(logger) {
+	try {
+		const transform = (await Promise.resolve().then(() => /* @__PURE__ */ require_chunk.__toESM(require("../../main-CVLq8IzA.js").default))).transform;
+		if (typeof transform !== "function") return null;
+		return { transform };
+	} catch (err) {
+		logger.warn("core-blocks: esbuild unavailable — code cannot be compiled on this node", { meta: { error: err instanceof Error ? err.message : String(err) } });
+		return null;
+	}
+}
+//#endregion
+exports.CORE_BLOCKS_COLLECTION = CORE_BLOCKS_COLLECTION;
+exports.CoreBlockStore = CoreBlockStore;
+exports.CoreBlocksAddon = CoreBlocksAddon;
+exports.compileBlock = compileBlock;
+exports.loadBlockTypeDefs = loadBlockTypeDefs;