@camstack/system 1.2.347 → 1.2.348

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

@@ -1,9 +1,11 @@
-import { Gn as BaseAddon, Ln as compositionSourceKey, Mn as composedDeviceRef, Wn as errMsg, Y as buildCapabilityLookup, at as coreBlockIdFromAddonId, d as CORE_BLOCK_ADDON_PREFIX, f as CoreBlockSchema, ht as describeComposableCaps, it as coreBlockComposition, l as COMPOSER_RUNNER_ID, nt as compositionSourceRefs, on as replacedFieldKeys, ot as coreBlockSourceKind, rt as coreBlockAddonId, st as coreBlocksCapability, t as ALL_CAPABILITY_DEFINITIONS, tn as planComposition, u as CORE_BLOCKS_ADDON_ID, v as DeclaredDevices, wn as validateComposition } from "../../dist-BUFcHq7H.mjs";
-import { t as describeCompositionSources } from "../../composition-sources-pQsmMdpR.mjs";
+import { In as composedDeviceRef, Jn as errMsg, On as validateComposition, Qt as normalizeCoreBlockWrite, Vn as compositionSourceKey, X as buildCapabilityLookup, Yn as BaseAddon, at as coreBlockComposition, cn as replacedFieldKeys, ct as coreBlocksCapability, d as CORE_BLOCK_ADDON_PREFIX, dn as resolveCoreBlockFiles, gt as describeComposableCaps, it as coreBlockAddonId, l as COMPOSER_RUNNER_ID, lr as hydrateSchema, ot as coreBlockIdFromAddonId, p as CoreBlockSchema, rn as planComposition, rt as compositionSourceRefs, st as coreBlockSourceKind, t as ALL_CAPABILITY_DEFINITIONS, u as CORE_BLOCKS_ADDON_ID, un as resolveCoreBlockEntry, y as DeclaredDevices } from "../../dist-nUn3vto_.mjs";
+import { t as describeCompositionSources } from "../../composition-sources-D7cxA4Yv.mjs";
 import { randomUUID } from "node:crypto";
 import { customizationBlockName } from "@camstack/types/node";
 import * as fs from "node:fs/promises";
 import * as path$1 from "node:path";
+import * as os from "node:os";
+import { pathToFileURL } from "node:url";
 //#region src/builtins/core-blocks/block-package.ts
 /**
 * Turning a stored block into something the addon runner can fork.
@@ -129,11 +131,27 @@ function renderBlockManifest(blockId, blockName) {
 * 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.
+*
+* Layout:
+*   `src/<path>`     — author TypeScript when `files` is provided
+*   `dist/block.js`  — bundled / transpiled entry (what the wrapper imports)
+*   `dist/index.js`  — generated BaseAddon wrapper
 */
 async function materializeBlock(input) {
 	const addonDir = path$1.join(input.root, input.blockId);
 	const distDir = path$1.join(addonDir, "dist");
+	const srcDir = path$1.join(addonDir, "src");
+	await fs.rm(srcDir, {
+		recursive: true,
+		force: true
+	});
 	await fs.mkdir(distDir, { recursive: true });
+	if (input.files !== void 0) for (const [rel, content] of Object.entries(input.files)) {
+		const abs = path$1.resolve(srcDir, rel);
+		if (!abs.startsWith(srcDir + path$1.sep) && abs !== srcDir) throw new Error(`refusing path outside the block package: ${rel}`);
+		await fs.mkdir(path$1.dirname(abs), { recursive: true });
+		await fs.writeFile(abs, content, "utf-8");
+	}
 	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"),
@@ -384,7 +402,12 @@ var BlockSupervisor = class {
 	*  — 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);
+		const { files, entry } = resolveCoreBlockFiles(block);
+		const compiled = await this.deps.compile({
+			code: block.code,
+			files,
+			entry
+		});
 		if (!compiled.ok || compiled.js === void 0) {
 			await this.report(block.id, "failed", `the block does not compile: ${compiled.error ?? "unknown"}`);
 			return;
@@ -394,7 +417,8 @@ var BlockSupervisor = class {
 				root: this.deps.root,
 				blockId: block.id,
 				blockName: block.name,
-				js: compiled.js
+				js: compiled.js,
+				files
 			});
 			await this.deps.host.spawn({
 				runnerId: pkg.addonId,
@@ -460,6 +484,73 @@ var BlockSupervisor = class {
 	}
 };
 //#endregion
+//#region src/builtins/core-blocks/block-settings-store.ts
+var CORE_BLOCK_SETTINGS_COLLECTION = "core-blocks:settings";
+var CORE_BLOCK_SETTINGS_COLUMNS = [{
+	name: "id",
+	type: "TEXT",
+	primaryKey: true,
+	notNull: true
+}, {
+	name: "values",
+	type: "JSON",
+	notNull: true,
+	defaultValue: "{}"
+}];
+var BlockSettingsStore = class {
+	store;
+	constructor(deps) {
+		this.store = deps.store;
+	}
+	static async declare(store) {
+		await store.declareCollection.mutate({
+			collection: CORE_BLOCK_SETTINGS_COLLECTION,
+			columns: [...CORE_BLOCK_SETTINGS_COLUMNS]
+		});
+	}
+	async getValues(blockId) {
+		const row = await this.store.get.query({
+			collection: CORE_BLOCK_SETTINGS_COLLECTION,
+			key: blockId
+		});
+		if (row === null || typeof row !== "object") return {};
+		const values = row.values;
+		if (values !== null && typeof values === "object" && !Array.isArray(values)) return { ...values };
+		if (!("values" in row)) return { ...row };
+		return {};
+	}
+	async mergeValues(blockId, patch) {
+		const next = {
+			...await this.getValues(blockId),
+			...patch
+		};
+		await this.store.set.mutate({
+			collection: CORE_BLOCK_SETTINGS_COLLECTION,
+			key: blockId,
+			value: { values: next }
+		});
+		await this.mirrorToBlockAddon(blockId, next);
+		return next;
+	}
+	async delete(blockId) {
+		await this.store.delete.mutate({
+			collection: CORE_BLOCK_SETTINGS_COLLECTION,
+			key: blockId
+		});
+	}
+	async mirrorToBlockAddon(blockId, values) {
+		const namespace = coreBlockAddonId(blockId);
+		try {
+			await this.store.set.mutate({
+				namespace,
+				collection: "addon-settings",
+				key: "root",
+				value: values
+			});
+		} catch {}
+	}
+};
+//#endregion
 //#region src/builtins/core-blocks/block-type-defs.ts
 /**
 * The declaration files a block is authored against.
@@ -533,6 +624,24 @@ async function walk(root, dir, out) {
 }
 //#endregion
 //#region src/builtins/core-blocks/compile-block.ts
+/**
+* Compiling a core block's TypeScript before it is stored or run.
+*
+* Two callers, one implementation on purpose: the editor asks as the author
+* types, and the store asks before it writes. **The verdict has to be the same
+* one**, or the editor green-lights code the server later refuses — the failure
+* shape where a person is told everything is fine by the thing they are looking
+* at.
+*
+* This is a TRANSPILE / BUNDLE, not a typecheck: esbuild strips types and
+* reports syntax errors, which is what stops unrunnable source from reaching
+* disk. Type errors are the editor's job (Monaco runs the real compiler against
+* the real `.d.ts` graph); doing it again here would mean shipping tsc into the
+* hub for an answer the author already has.
+*
+* Single-file blocks use `transform`. Multi-file projects write sources to a
+* temp dir and `build` from `entry` so relative imports resolve.
+*/
 /** An esbuild error carries the position; the shape is narrow enough to read
 *  defensively rather than to type against the package. */
 function positionOf(err) {
@@ -556,11 +665,18 @@ function messageOf(err) {
 	}
 	return err instanceof Error ? err.message : String(err);
 }
+function isFilesInput(source) {
+	return typeof source === "object" && source !== null && "files" in source;
+}
 /**
 * 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) {
+async function compileBlock(transpiler, source) {
+	if (isFilesInput(source)) return compileFiles(transpiler, source.files, source.entry);
+	return compileSingle(transpiler, source);
+}
+async function compileSingle(transpiler, code) {
 	if (code.trim().length === 0) return {
 		ok: false,
 		error: "the block is empty — it must export a default function"
@@ -582,6 +698,79 @@ async function compileBlock(transpiler, code) {
 		};
 	}
 }
+async function compileFiles(transpiler, files, entryPath) {
+	const entry = resolveCoreBlockEntry(entryPath);
+	const entrySource = files[entry];
+	if (entrySource === void 0) return {
+		ok: false,
+		error: `files must include the entry "${entry}"`
+	};
+	if (entrySource.trim().length === 0 && Object.keys(files).length === 1) return {
+		ok: false,
+		error: "the block is empty — it must export a default function"
+	};
+	if (Object.keys(files).length === 1 && !/\bfrom\s+['"]\.\.?\//.test(entrySource)) return compileSingle(transpiler, entrySource);
+	if (typeof transpiler.build !== "function") return {
+		ok: false,
+		error: "the multi-file bundler is unavailable on this node"
+	};
+	const work = await fs.mkdtemp(path$1.join(os.tmpdir(), "core-block-compile-"));
+	try {
+		for (const [rel, content] of Object.entries(files)) {
+			const abs = path$1.resolve(work, rel);
+			if (!abs.startsWith(work + path$1.sep) && abs !== work) return {
+				ok: false,
+				error: `refusing path outside the block package: ${rel}`
+			};
+			await fs.mkdir(path$1.dirname(abs), { recursive: true });
+			await fs.writeFile(abs, content, "utf-8");
+		}
+		const outfile = path$1.join(work, ".bundle", "block.js");
+		await fs.mkdir(path$1.dirname(outfile), { recursive: true });
+		const result = await transpiler.build({
+			absWorkingDir: work,
+			entryPoints: [entry],
+			outfile,
+			bundle: true,
+			format: "esm",
+			platform: "node",
+			target: "node22",
+			write: true,
+			logLevel: "silent"
+		});
+		if (result.errors.length > 0) {
+			const first = result.errors[0];
+			return {
+				ok: false,
+				error: first.text,
+				...first.location ? {
+					line: first.location.line,
+					column: first.location.column
+				} : {}
+			};
+		}
+		const js = await fs.readFile(outfile, "utf-8");
+		if (js.trim().length === 0) return {
+			ok: false,
+			error: "the block is empty — it must export a default function"
+		};
+		return {
+			ok: true,
+			js
+		};
+	} catch (err) {
+		return {
+			ok: false,
+			error: messageOf(err),
+			...positionOf(err)
+		};
+	} finally {
+		await fs.rm(work, {
+			recursive: true,
+			force: true
+		}).catch(() => void 0);
+	}
+}
 //#endregion
 //#region src/builtins/core-blocks/core-block-store.ts
 /**
@@ -777,8 +966,10 @@ var CoreBlockStore = class {
 	async create(input, createdBy) {
 		this.requireLoaded();
 		const now = this.now();
+		const normalized = normalizeCoreBlockWrite(input);
 		const block = CoreBlockSchema.parse({
 			...input,
+			...normalized,
 			id: this.newId(),
 			createdBy,
 			createdAt: now,
@@ -794,11 +985,23 @@ var CoreBlockStore = class {
 	async update(blockId, patch) {
 		const existing = this.byId.get(blockId);
 		if (!existing) throw new Error(`core block not found: ${blockId}`);
-		if ((patch.code !== void 0 && patch.code !== existing.code || patch.placement !== void 0 && patch.placement !== existing.placement || patch.integrationId !== void 0 && patch.integrationId !== existing.integrationId) && coreBlockSourceKind(existing) !== "code") throw new Error(`core block "${existing.name}" is a composition — its code, placement and integration are fixed; edit it with updateComposition`);
+		const sourcePatch = this.normalizeSourcePatch(existing, patch);
+		const nextCode = sourcePatch?.code ?? existing.code;
+		const nextFiles = sourcePatch !== null ? sourcePatch.files : existing.files;
+		const nextEntry = sourcePatch !== null ? sourcePatch.entry : existing.entry;
+		const codeChanged = nextCode !== existing.code;
+		const filesChanged = JSON.stringify(nextFiles ?? null) !== JSON.stringify(existing.files ?? null);
+		const entryChanged = (nextEntry ?? void 0) !== (existing.entry ?? void 0);
+		if ((codeChanged || filesChanged || entryChanged || patch.placement !== void 0 && patch.placement !== existing.placement || patch.integrationId !== void 0 && patch.integrationId !== existing.integrationId) && coreBlockSourceKind(existing) !== "code") throw new Error(`core block "${existing.name}" is a composition — its code, placement and integration are fixed; edit it with updateComposition`);
 		if (patch.name !== void 0 && patch.name !== existing.name && coreBlockSourceKind(existing) !== "code") throw new Error(`core block "${existing.name}" is a composition — rename it with updateComposition, which checks expectedUpdatedAt`);
 		const updated = CoreBlockSchema.parse({
 			...existing,
 			...patch,
+			...sourcePatch !== null ? {
+				code: nextCode,
+				files: nextFiles,
+				entry: nextEntry
+			} : {},
 			id: existing.id,
 			createdBy: existing.createdBy,
 			createdAt: existing.createdAt,
@@ -903,6 +1106,32 @@ var CoreBlockStore = class {
 			}
 		});
 	}
+	/**
+	* Resolve a source-affecting patch into the normalized `{ code, files?, entry? }`
+	* that will be stored. `null` when the patch does not touch source.
+	*/
+	normalizeSourcePatch(existing, patch) {
+		if (patch.files !== void 0) return normalizeCoreBlockWrite({
+			code: patch.code,
+			files: patch.files,
+			entry: patch.entry ?? existing.entry
+		});
+		if (patch.code === void 0 && patch.entry === void 0) return null;
+		if (existing.files !== void 0) {
+			const entry = resolveCoreBlockEntry(patch.entry ?? existing.entry);
+			return normalizeCoreBlockWrite({
+				files: {
+					...existing.files,
+					[entry]: patch.code ?? existing.files[entry] ?? existing.code
+				},
+				entry
+			});
+		}
+		return normalizeCoreBlockWrite({
+			code: patch.code ?? existing.code,
+			entry: patch.entry
+		});
+	}
 };
 //#endregion
 //#region src/builtins/core-blocks/blocks-integration.ts
@@ -1408,6 +1637,47 @@ function buildCompositionApi(deps) {
 	};
 }
 //#endregion
+//#region src/builtins/core-blocks/extract-settings-schema.ts
+/**
+* Read an optional `settingsSchema` named export from a compiled block bundle.
+*
+* The author declares the form next to their default export:
+*
+*   export const settingsSchema = { sections: [...] }
+*   export default async function (ctx) { … }
+*
+* Until the first successful extract, `getBlockSettings` returns null. A
+* failed import is NOT a compile failure — the block can still run; the
+* settings UI simply stays absent.
+*/
+function looksLikeSchema(value) {
+	if (value === null || typeof value !== "object") return false;
+	const sections = value.sections;
+	return Array.isArray(sections);
+}
+/**
+* Import the bundled module and return its `settingsSchema` export, or null.
+* Never throws.
+*/
+async function extractSettingsSchema(js) {
+	const dir = await fs.mkdtemp(path$1.join(os.tmpdir(), "core-block-schema-"));
+	const file = path$1.join(dir, "block.mjs");
+	try {
+		await fs.writeFile(file, js, "utf-8");
+		const mod = await import(pathToFileURL(file).href);
+		if (mod === null || typeof mod !== "object") return null;
+		const schema = mod.settingsSchema;
+		return looksLikeSchema(schema) ? schema : null;
+	} catch {
+		return null;
+	} finally {
+		await fs.rm(dir, {
+			recursive: true,
+			force: true
+		}).catch(() => void 0);
+	}
+}
+//#endregion
 //#region src/builtins/core-blocks/core-blocks.addon.ts
 /**
 * The `core-blocks` provider — CRUD over user-authored TypeScript, with the
@@ -1448,6 +1718,7 @@ var CoreBlocksAddon = class extends BaseAddon {
 		super({});
 	}
 	store = null;
+	prefs = null;
 	transpiler = null;
 	typeDefs = null;
 	supervisor = null;
@@ -1457,10 +1728,12 @@ var CoreBlocksAddon = class extends BaseAddon {
 		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);
+		await BlockSettingsStore.declare(settingsStore);
 		this.store = new CoreBlockStore({
 			store: settingsStore,
 			logger: this.ctx.logger.child("store")
 		});
+		this.prefs = new BlockSettingsStore({ store: settingsStore });
 		await this.store.load();
 		this.transpiler = await loadTranspiler(this.ctx.logger);
 		armBlocksIntegration({
@@ -1487,6 +1760,7 @@ var CoreBlocksAddon = class extends BaseAddon {
 		this.supervisor?.stop();
 		this.supervisor = null;
 		this.store = null;
+		this.prefs = null;
 		this.transpiler = null;
 		this.typeDefs = null;
 	}
@@ -1523,12 +1797,16 @@ var CoreBlocksAddon = class extends BaseAddon {
 				setStatus: (blockId, status, error) => store.setStatus(blockId, status, error)
 			},
 			host: createBrokerProcessHost(broker),
-			compile: async (code) => {
+			compile: async (source) => {
 				if (this.transpiler === null) return {
 					ok: false,
 					error: "the compiler is unavailable on this node"
 				};
-				return compileBlock(this.transpiler, code);
+				const input = source.files !== void 0 ? {
+					files: { ...source.files },
+					entry: source.entry
+				} : source.code;
+				return compileBlock(this.transpiler, input);
 			},
 			logger: this.ctx.logger.child("supervisor"),
 			composer: { apply: async (input) => {
@@ -1590,27 +1868,51 @@ var CoreBlocksAddon = class extends BaseAddon {
 		return this.store;
 	}
 	/**
-	* Compile, or explain why not.
+	* Compile, or explain why not. Returns the emitted JS so a successful gate
+	* can also extract `settingsSchema` without compiling twice.
 	*
 	* 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) {
+	async gate(input) {
 		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 normalized = normalizeCoreBlockWrite(input);
+		const source = normalized.files !== void 0 ? {
+			files: normalized.files,
+			entry: normalized.entry
+		} : normalized.code;
+		const result = await compileBlock(this.transpiler, source);
+		if (!result.ok || result.js === void 0) {
 			const where = result.line !== void 0 ? ` (line ${result.line})` : "";
 			throw new Error(`core-blocks: the code does not compile${where}: ${result.error ?? "unknown"}`);
 		}
+		return result.js;
+	}
+	requirePrefs() {
+		if (this.prefs === null) throw new Error("core-blocks: not initialized");
+		return this.prefs;
+	}
+	/**
+	* After a successful compile, cache the entry's `settingsSchema` export on
+	* the block when the author did not set one by hand. Never overwrites an
+	* explicit schema the editor already stored.
+	*/
+	async maybeCacheSettingsSchema(blockId, js, existingSchema) {
+		if (existingSchema !== void 0) return null;
+		const schema = await extractSettingsSchema(js);
+		if (schema === null) return null;
+		return this.requireStore().update(blockId, { settingsSchema: schema });
 	}
 	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);
+				const js = await this.gate(block);
+				let created = await this.requireStore().create(block, caller.userId);
+				const withSchema = await this.maybeCacheSettingsSchema(created.id, js, created.settingsSchema);
+				if (withSchema !== null) created = withSchema;
 				this.ctx.logger.info("core block created", { meta: {
 					blockId: created.id,
 					name: created.name,
@@ -1620,8 +1922,21 @@ var CoreBlocksAddon = class extends BaseAddon {
 				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);
+				const sourceChanged = block.code !== void 0 || block.files !== void 0 || block.entry !== void 0;
+				let js = null;
+				if (sourceChanged) {
+					const existing = this.requireStore().get(blockId);
+					js = await this.gate({
+						code: block.code ?? existing?.code,
+						files: block.files ?? existing?.files,
+						entry: block.entry ?? existing?.entry
+					});
+				}
+				let updated = await this.requireStore().update(blockId, block);
+				if (js !== null && block.settingsSchema === void 0) {
+					const withSchema = await this.maybeCacheSettingsSchema(blockId, js, void 0);
+					if (withSchema !== null) updated = withSchema;
+				}
 				this.ctx.logger.info("core block updated", { meta: {
 					blockId,
 					by: caller.userId
@@ -1631,6 +1946,7 @@ var CoreBlocksAddon = class extends BaseAddon {
 			},
 			delete: async ({ blockId }) => {
 				await this.requireStore().delete(blockId);
+				await this.requirePrefs().delete(blockId);
 				this.convergeSoon();
 				return { success: true };
 			},
@@ -1660,14 +1976,30 @@ var CoreBlocksAddon = class extends BaseAddon {
 				await this.supervisor.restart(blockId);
 				return { block: store.get(blockId) ?? block };
 			},
-			compile: async ({ code }) => {
+			compile: async (input) => {
 				if (this.transpiler === null) return {
 					ok: false,
 					error: "the compiler is unavailable on this node"
 				};
-				const { js: _js, ...verdict } = await compileBlock(this.transpiler, code);
+				const source = input.files !== void 0 ? {
+					files: input.files,
+					entry: input.entry
+				} : input.code ?? "";
+				const { js: _js, ...verdict } = await compileBlock(this.transpiler, source);
 				return verdict;
 			},
+			getBlockSettings: async ({ blockId }) => {
+				const block = this.requireStore().get(blockId);
+				if (block === null) return null;
+				const schema = block.settingsSchema;
+				if (schema === void 0) return null;
+				return hydrateSchema(schema, await this.requirePrefs().getValues(blockId));
+			},
+			updateBlockSettings: async ({ blockId, patch }) => {
+				if (this.requireStore().get(blockId) === null) throw new Error(`core-blocks: no block "${blockId}"`);
+				await this.requirePrefs().mergeValues(blockId, patch);
+				return { success: true };
+			},
 			getTypeDefs: async () => {
 				this.typeDefs ??= await loadBlockTypeDefs(this.ctx.logger);
 				return { libs: this.typeDefs.map((l) => ({
@@ -1754,9 +2086,16 @@ function createBrokerProcessHost(broker) {
 */
 async function loadTranspiler(logger) {
 	try {
-		const transform = (await import("esbuild")).transform;
+		const mod = await import("esbuild");
+		const transform = mod.transform;
+		const build = mod.build;
 		if (typeof transform !== "function") return null;
-		const transpiler = { transform };
+		const transpiler = {
+			transform,
+			...typeof build === "function" ? { build: async (options) => {
+				return { errors: (await build(options)).errors };
+			} } : {}
+		};
 		await transpiler.transform("export default 0", {
 			loader: "ts",
 			format: "esm",
@@ -1769,4 +2108,4 @@ async function loadTranspiler(logger) {
 	}
 }
 //#endregion
-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 };
+export { CoreBlocksAddon, loadBlockTypeDefs as a, BlockSupervisor as c, blockIdFromAddonId as d, materializeBlock as f, compileBlock as i, BLOCK_ADDON_PREFIX as l, CORE_BLOCKS_COLLECTION as n, BlockSettingsStore as o, removeBlockPackage as p, CoreBlockStore as r, CORE_BLOCK_SETTINGS_COLLECTION as s, extractSettingsSchema as t, blockAddonId as u };

package/dist/builtins/core-blocks/extract-settings-schema.d.ts

@@ -0,0 +1,6 @@
+import { ConfigUISchema } from '@camstack/types';
+/**
+ * Import the bundled module and return its `settingsSchema` export, or null.
+ * Never throws.
+ */
+export declare function extractSettingsSchema(js: string): Promise<ConfigUISchema | null>;

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

@@ -1,6 +1,8 @@
 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 { BlockSettingsStore, CORE_BLOCK_SETTINGS_COLLECTION, } from './block-settings-store.js';
 export { type BlockTypeLib, loadBlockTypeDefs } from './block-type-defs.js';
-export { type BlockTranspiler, compileBlock } from './compile-block.js';
+export { type BlockTranspiler, type CompileBlockSource, 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 { extractSettingsSchema } from './extract-settings-schema.js';

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

@@ -5,14 +5,17 @@ Object.defineProperties(exports, {
 require("../../chunk-Cek0wNdY.js");
 const require_builtins_core_blocks_core_blocks_addon = require("./core-blocks.addon.js");
 exports.BLOCK_ADDON_PREFIX = require_builtins_core_blocks_core_blocks_addon.BLOCK_ADDON_PREFIX;
+exports.BlockSettingsStore = require_builtins_core_blocks_core_blocks_addon.BlockSettingsStore;
 exports.BlockSupervisor = require_builtins_core_blocks_core_blocks_addon.BlockSupervisor;
 exports.CORE_BLOCKS_COLLECTION = require_builtins_core_blocks_core_blocks_addon.CORE_BLOCKS_COLLECTION;
+exports.CORE_BLOCK_SETTINGS_COLLECTION = require_builtins_core_blocks_core_blocks_addon.CORE_BLOCK_SETTINGS_COLLECTION;
 exports.CoreBlockStore = require_builtins_core_blocks_core_blocks_addon.CoreBlockStore;
 exports.CoreBlocksAddon = require_builtins_core_blocks_core_blocks_addon.CoreBlocksAddon;
 exports.blockAddonId = require_builtins_core_blocks_core_blocks_addon.blockAddonId;
 exports.blockIdFromAddonId = require_builtins_core_blocks_core_blocks_addon.blockIdFromAddonId;
 exports.compileBlock = require_builtins_core_blocks_core_blocks_addon.compileBlock;
 exports.default = require_builtins_core_blocks_core_blocks_addon.CoreBlocksAddon;
+exports.extractSettingsSchema = require_builtins_core_blocks_core_blocks_addon.extractSettingsSchema;
 exports.loadBlockTypeDefs = require_builtins_core_blocks_core_blocks_addon.loadBlockTypeDefs;
 exports.materializeBlock = require_builtins_core_blocks_core_blocks_addon.materializeBlock;
 exports.removeBlockPackage = require_builtins_core_blocks_core_blocks_addon.removeBlockPackage;

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

@@ -1,2 +1,2 @@
-import { CoreBlocksAddon, a as BlockSupervisor, c as blockIdFromAddonId, i as loadBlockTypeDefs, l as materializeBlock, n as CoreBlockStore, o as BLOCK_ADDON_PREFIX, r as compileBlock, s as blockAddonId, t as CORE_BLOCKS_COLLECTION, u as removeBlockPackage } from "./core-blocks.addon.mjs";
-export { BLOCK_ADDON_PREFIX, BlockSupervisor, CORE_BLOCKS_COLLECTION, CoreBlockStore, CoreBlocksAddon, CoreBlocksAddon as default, blockAddonId, blockIdFromAddonId, compileBlock, loadBlockTypeDefs, materializeBlock, removeBlockPackage };
+import { CoreBlocksAddon, a as loadBlockTypeDefs, c as BlockSupervisor, d as blockIdFromAddonId, f as materializeBlock, i as compileBlock, l as BLOCK_ADDON_PREFIX, n as CORE_BLOCKS_COLLECTION, o as BlockSettingsStore, p as removeBlockPackage, r as CoreBlockStore, s as CORE_BLOCK_SETTINGS_COLLECTION, t as extractSettingsSchema, u as blockAddonId } from "./core-blocks.addon.mjs";
+export { BLOCK_ADDON_PREFIX, BlockSettingsStore, BlockSupervisor, CORE_BLOCKS_COLLECTION, CORE_BLOCK_SETTINGS_COLLECTION, CoreBlockStore, CoreBlocksAddon, CoreBlocksAddon as default, blockAddonId, blockIdFromAddonId, compileBlock, extractSettingsSchema, loadBlockTypeDefs, materializeBlock, removeBlockPackage };

package/dist/builtins/device-manager/device-manager.addon.js

@@ -3,8 +3,8 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 require("../../chunk-Cek0wNdY.js");
-const require_dist = require("../../dist-DTgd2gOR.js");
-const require_retired_settings_keys = require("../../retired-settings-keys-Ddb5cCNR.js");
+const require_dist = require("../../dist-BgV_QADz.js");
+const require_retired_settings_keys = require("../../retired-settings-keys-D980hwnw.js");
 let zod = require("zod");
 let node_crypto = require("node:crypto");
 let _camstack_types_node = require("@camstack/types/node");

package/dist/builtins/device-manager/device-manager.addon.mjs

@@ -1,5 +1,5 @@
-import { D as MINUTES_PER_DAY, Gn as BaseAddon, Hn as DeviceRole, Lt as legacyAutoLinkIds, P as STREAM_PROFILE_META, S as FieldClaimSchema, St as enumerateSchemaFields, T as LocationIconIdSchema, Tt as expandContainer, Un as DeviceType, Vn as DeviceFeature, Vt as locationIconKey, Wn as errMsg, X as buildStreamParamsConfigSchema, Zn as WELL_KNOWN_TAB_MAP, Zt as normalizeUnit, _t as deviceManagerCapability, ct as createDeviceExtensionProvider, en as parseStreamParamsFormPatch, g as DAY_NAMES, gr as EventCategory, gt as deviceExtensionCapability, hn as siteZoneKey, kt as formatMinutes, mr as sleep$1, o as CAMERA_SWITCH_ORDER, or as isDeviceConfigCap, pt as defineExtensionSlotProvider, s as CAP_NAMES_WITH_STATUS, t as ALL_CAPABILITY_DEFINITIONS, un as runtimeStatePolicyFor, vt as deviceStateCapability, x as FieldClaimModeSchema, xt as enumerateItemArrayFields, y as DeviceStatusSchema, yt as deviceStatusCapability } from "../../dist-BUFcHq7H.mjs";
-import { n as purgeRetiredSettingsRows } from "../../retired-settings-keys-ltKefX3N.mjs";
+import { $t as normalizeUnit, At as formatMinutes, C as FieldClaimSchema, Ct as enumerateSchemaFields, E as LocationIconIdSchema, Et as expandContainer, F as STREAM_PROFILE_META, Gn as DeviceFeature, Ht as locationIconKey, Jn as errMsg, Kn as DeviceRole, O as MINUTES_PER_DAY, Rt as legacyAutoLinkIds, S as FieldClaimModeSchema, St as enumerateItemArrayFields, Yn as BaseAddon, Z as buildStreamParamsConfigSchema, _ as DAY_NAMES, _t as deviceExtensionCapability, b as DeviceStatusSchema, br as EventCategory, bt as deviceStatusCapability, lt as createDeviceExtensionProvider, mn as runtimeStatePolicyFor, mt as defineExtensionSlotProvider, nn as parseStreamParamsFormPatch, o as CAMERA_SWITCH_ORDER, qn as DeviceType, s as CAP_NAMES_WITH_STATUS, t as ALL_CAPABILITY_DEFINITIONS, tr as WELL_KNOWN_TAB_MAP, ur as isDeviceConfigCap, vr as sleep$1, vt as deviceManagerCapability, yn as siteZoneKey, yt as deviceStateCapability } from "../../dist-nUn3vto_.mjs";
+import { n as purgeRetiredSettingsRows } from "../../retired-settings-keys-pKNWq-CL.mjs";
 import { z } from "zod";
 import { randomUUID } from "node:crypto";
 import { canonicalDeviceFingerprint } from "@camstack/types/node";

package/dist/builtins/hub-forwarder/index.js

@@ -3,7 +3,7 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 require("../../chunk-Cek0wNdY.js");
-const require_dist = require("../../dist-DTgd2gOR.js");
+const require_dist = require("../../dist-BgV_QADz.js");
 const require_formatter = require("../../formatter-DqAKDlvN.js");
 //#region src/builtins/hub-forwarder/hub-forwarder-destination.ts
 var DEFAULT_OUTBOUND_BUFFER_SIZE = 500;

package/dist/builtins/hub-forwarder/index.mjs

@@ -1,4 +1,4 @@
-import { Gn as BaseAddon, Ht as logDestinationCapability } from "../../dist-BUFcHq7H.mjs";
+import { Ut as logDestinationCapability, Yn as BaseAddon } from "../../dist-nUn3vto_.mjs";
 import { t as formatLogLine } from "../../formatter-B7qW8bPJ.mjs";
 //#region src/builtins/hub-forwarder/hub-forwarder-destination.ts
 var DEFAULT_OUTBOUND_BUFFER_SIZE = 500;

package/dist/builtins/liveness-monitor/liveness-monitor.addon.js

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 require("../../chunk-Cek0wNdY.js");
-const require_dist = require("../../dist-DTgd2gOR.js");
+const require_dist = require("../../dist-BgV_QADz.js");
 //#region src/builtins/liveness-monitor/liveness-checks.ts
 var NO_DEVICES = "liveness:no-devices";
 var ALL_OFFLINE = "liveness:all-devices-offline";