@camstack/system 1.2.347 → 1.2.349

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

@@ -1,13 +1,16 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_chunk = require("../../chunk-Cek0wNdY.js");
-const require_dist = require("../../dist-DTgd2gOR.js");
-const require_composition_sources = require("../../composition-sources-CeZ3tyH8.js");
+const require_dist = require("../../dist-DvAczrLl.js");
+const require_composition_sources = require("../../composition-sources-w_NIID5d.js");
 let node_crypto = require("node:crypto");
 let _camstack_types_node = require("@camstack/types/node");
 let node_fs_promises = require("node:fs/promises");
 node_fs_promises = require_chunk.__toESM(node_fs_promises);
 let node_path = require("node:path");
 node_path = require_chunk.__toESM(node_path);
+let node_os = require("node:os");
+node_os = require_chunk.__toESM(node_os);
+let node_url = require("node:url");
 //#region src/builtins/core-blocks/block-package.ts
 /**
 * Turning a stored block into something the addon runner can fork.
@@ -133,11 +136,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 = node_path.join(input.root, input.blockId);
 	const distDir = node_path.join(addonDir, "dist");
+	const srcDir = node_path.join(addonDir, "src");
+	await node_fs_promises.rm(srcDir, {
+		recursive: true,
+		force: true
+	});
 	await node_fs_promises.mkdir(distDir, { recursive: true });
+	if (input.files !== void 0) for (const [rel, content] of Object.entries(input.files)) {
+		const abs = node_path.resolve(srcDir, rel);
+		if (!abs.startsWith(srcDir + node_path.sep) && abs !== srcDir) throw new Error(`refusing path outside the block package: ${rel}`);
+		await node_fs_promises.mkdir(node_path.dirname(abs), { recursive: true });
+		await node_fs_promises.writeFile(abs, content, "utf-8");
+	}
 	await Promise.all([
 		node_fs_promises.writeFile(node_path.join(addonDir, "package.json"), renderBlockManifest(input.blockId, input.blockName), "utf-8"),
 		node_fs_promises.writeFile(node_path.join(distDir, "block.js"), input.js, "utf-8"),
@@ -388,7 +407,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 } = require_dist.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;
@@ -398,7 +422,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,
@@ -464,6 +489,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 = require_dist.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.
@@ -537,6 +629,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) {
@@ -560,11 +670,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"
@@ -586,6 +703,79 @@ async function compileBlock(transpiler, code) {
 		};
 	}
 }
+async function compileFiles(transpiler, files, entryPath) {
+	const entry = require_dist.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 node_fs_promises.mkdtemp(node_path.join(node_os.tmpdir(), "core-block-compile-"));
+	try {
+		for (const [rel, content] of Object.entries(files)) {
+			const abs = node_path.resolve(work, rel);
+			if (!abs.startsWith(work + node_path.sep) && abs !== work) return {
+				ok: false,
+				error: `refusing path outside the block package: ${rel}`
+			};
+			await node_fs_promises.mkdir(node_path.dirname(abs), { recursive: true });
+			await node_fs_promises.writeFile(abs, content, "utf-8");
+		}
+		const outfile = node_path.join(work, ".bundle", "block.js");
+		await node_fs_promises.mkdir(node_path.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 node_fs_promises.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 node_fs_promises.rm(work, {
+			recursive: true,
+			force: true
+		}).catch(() => void 0);
+	}
+}
 //#endregion
 //#region src/builtins/core-blocks/core-block-store.ts
 /**
@@ -781,8 +971,10 @@ var CoreBlockStore = class {
 	async create(input, createdBy) {
 		this.requireLoaded();
 		const now = this.now();
+		const normalized = require_dist.normalizeCoreBlockWrite(input);
 		const block = require_dist.CoreBlockSchema.parse({
 			...input,
+			...normalized,
 			id: this.newId(),
 			createdBy,
 			createdAt: now,
@@ -798,11 +990,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) && require_dist.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) && require_dist.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 && require_dist.coreBlockSourceKind(existing) !== "code") throw new Error(`core block "${existing.name}" is a composition — rename it with updateComposition, which checks expectedUpdatedAt`);
 		const updated = require_dist.CoreBlockSchema.parse({
 			...existing,
 			...patch,
+			...sourcePatch !== null ? {
+				code: nextCode,
+				files: nextFiles,
+				entry: nextEntry
+			} : {},
 			id: existing.id,
 			createdBy: existing.createdBy,
 			createdAt: existing.createdAt,
@@ -907,6 +1111,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 require_dist.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 = require_dist.resolveCoreBlockEntry(patch.entry ?? existing.entry);
+			return require_dist.normalizeCoreBlockWrite({
+				files: {
+					...existing.files,
+					[entry]: patch.code ?? existing.files[entry] ?? existing.code
+				},
+				entry
+			});
+		}
+		return require_dist.normalizeCoreBlockWrite({
+			code: patch.code ?? existing.code,
+			entry: patch.entry
+		});
+	}
 };
 //#endregion
 //#region src/builtins/core-blocks/blocks-integration.ts
@@ -1412,6 +1642,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 node_fs_promises.mkdtemp(node_path.join(node_os.tmpdir(), "core-block-schema-"));
+	const file = node_path.join(dir, "block.mjs");
+	try {
+		await node_fs_promises.writeFile(file, js, "utf-8");
+		const mod = await import((0, node_url.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 node_fs_promises.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
@@ -1452,6 +1723,7 @@ var CoreBlocksAddon = class extends require_dist.BaseAddon {
 		super({});
 	}
 	store = null;
+	prefs = null;
 	transpiler = null;
 	typeDefs = null;
 	supervisor = null;
@@ -1461,10 +1733,12 @@ var CoreBlocksAddon = class extends require_dist.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({
@@ -1491,6 +1765,7 @@ var CoreBlocksAddon = class extends require_dist.BaseAddon {
 		this.supervisor?.stop();
 		this.supervisor = null;
 		this.store = null;
+		this.prefs = null;
 		this.transpiler = null;
 		this.typeDefs = null;
 	}
@@ -1527,12 +1802,16 @@ var CoreBlocksAddon = class extends require_dist.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) => {
@@ -1594,27 +1873,51 @@ var CoreBlocksAddon = class extends require_dist.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 = require_dist.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,
@@ -1624,8 +1927,21 @@ var CoreBlocksAddon = class extends require_dist.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
@@ -1635,6 +1951,7 @@ var CoreBlocksAddon = class extends require_dist.BaseAddon {
 			},
 			delete: async ({ blockId }) => {
 				await this.requireStore().delete(blockId);
+				await this.requirePrefs().delete(blockId);
 				this.convergeSoon();
 				return { success: true };
 			},
@@ -1664,14 +1981,30 @@ var CoreBlocksAddon = class extends require_dist.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 require_dist.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) => ({
@@ -1758,9 +2091,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",
@@ -1774,13 +2114,16 @@ async function loadTranspiler(logger) {
 }
 //#endregion
 exports.BLOCK_ADDON_PREFIX = BLOCK_ADDON_PREFIX;
+exports.BlockSettingsStore = BlockSettingsStore;
 exports.BlockSupervisor = BlockSupervisor;
 exports.CORE_BLOCKS_COLLECTION = CORE_BLOCKS_COLLECTION;
+exports.CORE_BLOCK_SETTINGS_COLLECTION = CORE_BLOCK_SETTINGS_COLLECTION;
 exports.CoreBlockStore = CoreBlockStore;
 exports.CoreBlocksAddon = CoreBlocksAddon;
 exports.blockAddonId = blockAddonId;
 exports.blockIdFromAddonId = blockIdFromAddonId;
 exports.compileBlock = compileBlock;
+exports.extractSettingsSchema = extractSettingsSchema;
 exports.loadBlockTypeDefs = loadBlockTypeDefs;
 exports.materializeBlock = materializeBlock;
 exports.removeBlockPackage = removeBlockPackage;