camox 0.48.0 → 0.52.1

package/dist/features/studio/components/ThreadMessages.js

@@ -9,12 +9,13 @@ import { MessageScroller, MessageScrollerButton, MessageScrollerContent, Message
 //#region src/features/studio/components/ThreadMessages.tsx
 /**
 * A thread's messages, and "Working…" while a run is going or a message is still `sending`: on
-* its way to the thread, which hasn't accepted it yet. A draft's thread is shared, so it shows
+* its way to the thread, which hasn't accepted it yet. While the end of a turn builds the
+* agent's code, or the agent fixes a build error, it says so instead. A draft's thread is shared, so it shows
 * senders' names too (`showSenders`). A fresh Live thread links to the draft the editor's
 * previous one continued in (`continuedIn`).
 */
 function ThreadMessages(t0) {
-	const $ = c(25);
+	const $ = c(28);
 	const { view, sending: t1, showSenders: t2, continuedIn } = t0;
 	const sending = t1 === void 0 ? false : t1;
 	const showSenders = t2 === void 0 ? false : t2;
@@ -53,9 +54,9 @@ function ThreadMessages(t0) {
 		$[6] = t3;
 	} else t3 = $[6];
 	let t4;
-	if ($[7] !== showSenders || $[8] !== view.messages || $[9] !== working) {
+	if ($[7] !== showSenders || $[8] !== view.messages || $[9] !== view.status || $[10] !== working) {
 		let t5;
-		if ($[11] !== showSenders || $[12] !== view.messages.length || $[13] !== working) {
+		if ($[12] !== showSenders || $[13] !== view.messages.length || $[14] !== view.status || $[15] !== working) {
 			t5 = (message, index) => /* @__PURE__ */ jsxs(MessageScrollerItem, {
 				messageId: message.id,
 				scrollAnchor: message.from === "editor",
@@ -63,28 +64,31 @@ function ThreadMessages(t0) {
 				children: [/* @__PURE__ */ jsx(ThreadMessageRow, {
 					message,
 					showSender: showSenders
-				}), working && index === view.messages.length - 1 && /* @__PURE__ */ jsx(Working, {})]
+				}), working && index === view.messages.length - 1 && /* @__PURE__ */ jsx(Working, { status: view.status })]
 			}, message.id);
-			$[11] = showSenders;
-			$[12] = view.messages.length;
-			$[13] = working;
-			$[14] = t5;
-		} else t5 = $[14];
+			$[12] = showSenders;
+			$[13] = view.messages.length;
+			$[14] = view.status;
+			$[15] = working;
+			$[16] = t5;
+		} else t5 = $[16];
 		t4 = view.messages.map(t5);
 		$[7] = showSenders;
 		$[8] = view.messages;
-		$[9] = working;
-		$[10] = t4;
-	} else t4 = $[10];
+		$[9] = view.status;
+		$[10] = working;
+		$[11] = t4;
+	} else t4 = $[11];
 	let t5;
-	if ($[15] !== view.messages.length || $[16] !== working) {
-		t5 = working && view.messages.length === 0 && /* @__PURE__ */ jsx(Working, {});
-		$[15] = view.messages.length;
-		$[16] = working;
-		$[17] = t5;
-	} else t5 = $[17];
+	if ($[17] !== view.messages.length || $[18] !== view.status || $[19] !== working) {
+		t5 = working && view.messages.length === 0 && /* @__PURE__ */ jsx(Working, { status: view.status });
+		$[17] = view.messages.length;
+		$[18] = view.status;
+		$[19] = working;
+		$[20] = t5;
+	} else t5 = $[20];
 	let t6;
-	if ($[18] !== t3 || $[19] !== t4 || $[20] !== t5) {
+	if ($[21] !== t3 || $[22] !== t4 || $[23] !== t5) {
 		t6 = /* @__PURE__ */ jsx(MessageScrollerViewport, { children: /* @__PURE__ */ jsxs(MessageScrollerContent, {
 			className: "flex flex-col gap-4 px-2 py-3",
 			children: [
@@ -93,46 +97,53 @@ function ThreadMessages(t0) {
 				t5
 			]
 		}) });
-		$[18] = t3;
-		$[19] = t4;
-		$[20] = t5;
-		$[21] = t6;
-	} else t6 = $[21];
+		$[21] = t3;
+		$[22] = t4;
+		$[23] = t5;
+		$[24] = t6;
+	} else t6 = $[24];
 	let t7;
-	if ($[22] === Symbol.for("react.memo_cache_sentinel")) {
+	if ($[25] === Symbol.for("react.memo_cache_sentinel")) {
 		t7 = /* @__PURE__ */ jsx(MessageScrollerButton, {});
-		$[22] = t7;
-	} else t7 = $[22];
+		$[25] = t7;
+	} else t7 = $[25];
 	let t8;
-	if ($[23] !== t6) {
+	if ($[26] !== t6) {
 		t8 = /* @__PURE__ */ jsx(MessageScrollerProvider, { children: /* @__PURE__ */ jsxs(MessageScroller, {
 			className: "min-h-0 flex-1",
 			children: [t6, t7]
 		}) });
-		$[23] = t6;
-		$[24] = t8;
-	} else t8 = $[24];
+		$[26] = t6;
+		$[27] = t8;
+	} else t8 = $[27];
 	return t8;
 }
 /**
 * Shown in the last message, not after it: the scroller only brings a message the editor just
 * sent into view when it's appended last, and it arrives while the agent is already working.
 */
-function Working() {
-	const $ = c(1);
-	let t0;
-	if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
-		t0 = /* @__PURE__ */ jsx("p", {
+function Working(t0) {
+	const $ = c(2);
+	const { status } = t0;
+	const t1 = status ? STATUS_LINES[status] : "Working…";
+	let t2;
+	if ($[0] !== t1) {
+		t2 = /* @__PURE__ */ jsx("p", {
 			role: "status",
 			className: "shimmer text-muted-foreground text-sm",
-			children: "Working…"
+			children: t1
 		});
-		$[0] = t0;
-	} else t0 = $[0];
-	return t0;
+		$[0] = t1;
+		$[1] = t2;
+	} else t2 = $[1];
+	return t2;
 }
+const STATUS_LINES = {
+	building: "Building…",
+	fixing: "Fixing a build error…"
+};
 function ThreadMessageRow(t0) {
-	const $ = c(17);
+	const $ = c(20);
 	const { message, showSender } = t0;
 	if (message.from === "stopped" || message.from === "failed") {
 		const t1 = message.from === "stopped" ? `Stopped by ${message.sender.name}` : "Camox couldn’t finish this. Send your message again to retry.";
@@ -156,24 +167,48 @@ function ThreadMessageRow(t0) {
 		} else t1 = $[3];
 		return t1;
 	}
+	if (message.from === "camox") {
+		let t1;
+		if ($[4] === Symbol.for("react.memo_cache_sentinel")) {
+			t1 = /* @__PURE__ */ jsx(MessageHeader, {
+				className: "text-muted-foreground text-xs",
+				children: "Camox"
+			});
+			$[4] = t1;
+		} else t1 = $[4];
+		let t2;
+		if ($[5] !== message.text) {
+			t2 = /* @__PURE__ */ jsx(Message, { children: /* @__PURE__ */ jsxs(MessageContent, { children: [t1, /* @__PURE__ */ jsx(Bubble, {
+				variant: "muted",
+				className: "max-w-full",
+				children: /* @__PURE__ */ jsx(BubbleContent, {
+					className: "whitespace-pre-wrap",
+					children: message.text
+				})
+			})] }) });
+			$[5] = message.text;
+			$[6] = t2;
+		} else t2 = $[6];
+		return t2;
+	}
 	let t1;
-	if ($[4] !== message.sender) {
+	if ($[7] !== message.sender) {
 		t1 = /* @__PURE__ */ jsx(MessageAvatar, { children: /* @__PURE__ */ jsx(SenderAvatar, { sender: message.sender }) });
-		$[4] = message.sender;
-		$[5] = t1;
-	} else t1 = $[5];
+		$[7] = message.sender;
+		$[8] = t1;
+	} else t1 = $[8];
 	let t2;
-	if ($[6] !== message.sender || $[7] !== showSender) {
+	if ($[9] !== message.sender || $[10] !== showSender) {
 		t2 = showSender && /* @__PURE__ */ jsx(MessageHeader, {
 			className: "text-muted-foreground text-xs",
 			children: message.sender.name
 		});
-		$[6] = message.sender;
-		$[7] = showSender;
-		$[8] = t2;
-	} else t2 = $[8];
+		$[9] = message.sender;
+		$[10] = showSender;
+		$[11] = t2;
+	} else t2 = $[11];
 	let t3;
-	if ($[9] !== message.text) {
+	if ($[12] !== message.text) {
 		t3 = /* @__PURE__ */ jsx(Bubble, {
 			align: "end",
 			variant: "muted",
@@ -183,26 +218,26 @@ function ThreadMessageRow(t0) {
 				children: message.text
 			})
 		});
-		$[9] = message.text;
-		$[10] = t3;
-	} else t3 = $[10];
+		$[12] = message.text;
+		$[13] = t3;
+	} else t3 = $[13];
 	let t4;
-	if ($[11] !== t2 || $[12] !== t3) {
+	if ($[14] !== t2 || $[15] !== t3) {
 		t4 = /* @__PURE__ */ jsxs(MessageContent, { children: [t2, t3] });
-		$[11] = t2;
-		$[12] = t3;
-		$[13] = t4;
-	} else t4 = $[13];
+		$[14] = t2;
+		$[15] = t3;
+		$[16] = t4;
+	} else t4 = $[16];
 	let t5;
-	if ($[14] !== t1 || $[15] !== t4) {
+	if ($[17] !== t1 || $[18] !== t4) {
 		t5 = /* @__PURE__ */ jsxs(Message, {
 			align: "end",
 			children: [t1, t4]
 		});
-		$[14] = t1;
-		$[15] = t4;
-		$[16] = t5;
-	} else t5 = $[16];
+		$[17] = t1;
+		$[18] = t4;
+		$[19] = t5;
+	} else t5 = $[19];
 	return t5;
 }
 function ContinuedIn(t0) {

package/dist/features/studio/components/UserButton.js

@@ -1,10 +1,10 @@
 import { useAuthContext, useAuthState } from "../../../lib/auth.js";
 import { useNavigate } from "../../navigation/navigation.js";
-import { PlatformLabel } from "../../../components/PlatformLabel.js";
 import { useLocalePath, useLocalizedPath } from "../../../lib/view-locale.js";
+import { PlatformLabel } from "../../../components/PlatformLabel.js";
+import { previewStore, selectIsCanvasShown } from "../../preview/previewStore.js";
 import { STUDIO_BASE_PATH } from "../routes.js";
 import { studioStore } from "../studioStore.js";
-import { previewStore, selectIsCanvasShown } from "../../preview/previewStore.js";
 import { useApplyTheme } from "../useTheme.js";
 import { c } from "react/compiler-runtime";
 import { useSelector } from "@xstate/store-react";

package/dist/features/studio/routes.js

@@ -3,6 +3,8 @@ const STUDIO_ROUTE_SEGMENT = "camox";
 const STUDIO_BASE_PATH = `/${STUDIO_ROUTE_SEGMENT}`;
 const STUDIO_CONTENT_PATH = `${STUDIO_BASE_PATH}/content`;
 const STUDIO_ASSETS_PATH = `${STUDIO_CONTENT_PATH}/assets`;
+/** The Settings Section, where members change Project Settings. */
+const STUDIO_SETTINGS_PATH = `${STUDIO_BASE_PATH}/settings`;
 const collectionContentPath = (collectionId) => `${STUDIO_CONTENT_PATH}/collections/${encodeURIComponent(collectionId)}`;
 function matchCollectionContentPath(pathname) {
 	const match = /^\/camox\/content\/collections\/([^/]+)(?:(\/new)|\/([^/]+)\/edit)?$/.exec(pathname);
@@ -29,4 +31,4 @@ function matchCollectionContentPath(pathname) {
 const STUDIO_CANVAS_PATH = `${STUDIO_BASE_PATH}/canvas`;
 
 //#endregion
-export { STUDIO_ASSETS_PATH, STUDIO_BASE_PATH, STUDIO_CANVAS_PATH, STUDIO_CONTENT_PATH, STUDIO_ROUTE_SEGMENT, collectionContentPath, matchCollectionContentPath };
+export { STUDIO_ASSETS_PATH, STUDIO_BASE_PATH, STUDIO_CANVAS_PATH, STUDIO_CONTENT_PATH, STUDIO_ROUTE_SEGMENT, STUDIO_SETTINGS_PATH, collectionContentPath, matchCollectionContentPath };

package/dist/features/studio/showInCanvas.js

@@ -0,0 +1,129 @@
+import { useProjectUuid } from "../../lib/auth.js";
+import { localizedPath } from "../../lib/locale-path.js";
+import { useViewLocale } from "../../lib/view-locale-context.js";
+import { useLocation, useNavigate } from "../navigation/navigation.js";
+import { reads, useStudioCache } from "../../lib/studio-reads.js";
+import { previewStore, sameEditingOwner } from "../preview/previewStore.js";
+import { fieldTypesDictionary } from "../../core/lib/fieldTypes.js";
+import { c } from "react/compiler-runtime";
+
+//#region src/features/studio/showInCanvas.ts
+/**
+* How long showing something in the Canvas keeps selecting it, in milliseconds, while the Canvas
+* mounts and its page's editing frame claims, each of which can clear the selection. A product
+* tuning value: long enough for a page to load, short enough not to fight the editor.
+*/
+const SELECTING_FOR = 5e3;
+const isFieldType = (kind) => !!kind && Object.hasOwn(fieldTypesDictionary, kind);
+/** What to select on the target's page: its field, else its item or block, else nothing. */
+function selectionOf({ blockId, itemId, field }) {
+	if (!blockId) return null;
+	const fieldType = field && isFieldType(field.kind) ? field.kind : null;
+	if (itemId) return field && fieldType ? {
+		type: "item-field",
+		blockId,
+		itemId,
+		fieldName: field.name,
+		fieldType
+	} : {
+		type: "item",
+		blockId,
+		itemId
+	};
+	return field && fieldType ? {
+		type: "block-field",
+		blockId,
+		fieldName: field.name,
+		fieldType
+	} : {
+		type: "block",
+		blockId
+	};
+}
+/** Stops selecting what was last shown in the Canvas. */
+let stopSelecting = null;
+/**
+* Selects `selection` once `owner`'s editing frame is active, and again whenever it's cleared,
+* until the editor selects something else or the time runs out.
+*/
+function selectOnceShown(owner, selection) {
+	stopSelecting?.();
+	const select = () => {
+		const { editingContext } = previewStore.getSnapshot().context;
+		if (!sameEditingOwner(editingContext, owner)) return;
+		const current = editingContext?.selection ?? null;
+		if (current === null) {
+			previewStore.send({
+				type: "selectTarget",
+				...owner,
+				selection
+			});
+			return;
+		}
+		if (JSON.stringify(current) !== JSON.stringify(selection)) stop();
+	};
+	const subscription = previewStore.subscribe(select);
+	const timer = setTimeout(() => stop(), SELECTING_FOR);
+	const stop = () => {
+		subscription.unsubscribe();
+		clearTimeout(timer);
+		if (stopSelecting === stop) stopSelecting = null;
+	};
+	stopSelecting = stop;
+	const { editingContext } = previewStore.getSnapshot().context;
+	if (sameEditingOwner(editingContext, owner)) previewStore.send({
+		type: "selectTarget",
+		...owner,
+		selection
+	});
+}
+/**
+* Shows a page in the Canvas, in the target's locale, and selects the block, item or field in it
+* once the page's editing frame is active.
+*/
+function useShowInCanvas() {
+	const $ = c(8);
+	const cache = useStudioCache();
+	const projectUuid = useProjectUuid();
+	const view = useViewLocale();
+	const navigate = useNavigate();
+	let t0;
+	if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+		t0 = { select: _temp };
+		$[0] = t0;
+	} else t0 = $[0];
+	const search = useLocation(t0);
+	let t1;
+	if ($[1] !== cache || $[2] !== navigate || $[3] !== projectUuid || $[4] !== search || $[5] !== view.locale || $[6] !== view.locales) {
+		t1 = async (target) => {
+			const locale = view.locales.find((each) => each.tag === target.locale) ?? view.locale;
+			const page = (await cache.ensure(reads.pageList({ projectUuid }), { locale }).catch(_temp2)).find((each_0) => each_0.id === target.pageId);
+			if (!page) return;
+			const selection = selectionOf(target);
+			if (selection) selectOnceShown({
+				kind: "page",
+				pageId: page.id
+			}, selection);
+			else stopSelecting?.();
+			previewStore.send({ type: "showCanvas" });
+			await navigate({ to: `${localizedPath(page.fullPath, locale)}${search}` });
+		};
+		$[1] = cache;
+		$[2] = navigate;
+		$[3] = projectUuid;
+		$[4] = search;
+		$[5] = view.locale;
+		$[6] = view.locales;
+		$[7] = t1;
+	} else t1 = $[7];
+	return t1;
+}
+function _temp2() {
+	return [];
+}
+function _temp(location) {
+	return location.search;
+}
+
+//#endregion
+export { useShowInCanvas };

package/dist/features/vite/definitionsSync.js

@@ -56,14 +56,13 @@ async function syncDefinitionsToApi(options) {
 		throw error;
 	}
 	if (result.draftCreated) logger.info("[camox] Created your development draft", { timestamp: true });
-	logger.info(`[camox] Synced ${counted(result.blocks.count, "block definition")}`, { timestamp: true });
+	const definitionCount = result.blocks.count + result.collections.count + (result.layouts?.count ?? 0);
+	logger.info(`[camox] Synced ${counted(definitionCount, "Camox definition")}`, { timestamp: true });
 	const { deletedDefinitionTypes } = result.blocks;
 	if (deletedDefinitionTypes.length > 0) logger.info(`[camox] Removed ${counted(deletedDefinitionTypes.length, "block definition")} no longer in code: ${quoted(deletedDefinitionTypes)}. Their blocks are kept and render nothing until the definition comes back.`, { timestamp: true });
-	logger.info(`[camox] Synced ${result.collections.count} collection definitions`, { timestamp: true });
 	for (const id of result.collections.retired) logger.warn(`[camox] Removed collection "${id}"; its records are kept and hidden`, { timestamp: true });
 	const layoutSyncResults = result.layouts;
 	if (layoutSyncResults) {
-		logger.info(`[camox] Synced ${counted(layoutSyncResults.count, "layout")} to Camox API`, { timestamp: true });
 		for (const layout of layoutSyncResults.layouts) {
 			const { layoutId, createdBlockTypes, removedBlockTypes, skippedOrphanTypes } = layout;
 			if (layout.wasExisting && createdBlockTypes.length > 0) logger.info(`[camox] Added ${counted(createdBlockTypes.length, "block")} to existing layout "${layoutId}": ${quoted(createdBlockTypes)}`, { timestamp: true });
@@ -180,7 +179,7 @@ async function syncDefinitions(server, options) {
 		await sync({ initial: true });
 		synced = true;
 	} catch (error) {
-		logger.error(`[camox] Failed to sync block definitions: ${String(error)}`, { timestamp: true });
+		logger.error(`[camox] Failed to sync Camox definitions: ${String(error)}`, { timestamp: true });
 	}
 	let running = Promise.resolve();
 	let timer;
@@ -188,7 +187,7 @@ async function syncDefinitions(server, options) {
 		clearTimeout(timer);
 		timer = setTimeout(() => {
 			running = running.then(() => sync().catch((error) => {
-				logger.error(`[camox] Failed to sync block definitions: ${String(error)}`, { timestamp: true });
+				logger.error(`[camox] Failed to sync Camox definitions: ${String(error)}`, { timestamp: true });
 			}));
 		}, SYNC_DEBOUNCE_DELAY_MS);
 	};
@@ -208,4 +207,4 @@ async function syncDefinitions(server, options) {
 }
 
 //#endregion
-export { VIRTUAL_CAMOX_APP, syncDefinitions, syncDefinitionsToApi };
+export { VIRTUAL_CAMOX_APP, loadDefinitionSet, syncDefinitions, syncDefinitionsToApi };

package/dist/features/vite/hostedChecks.js

@@ -0,0 +1,127 @@
+import { readFileSync } from "node:fs";
+import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+import { Visitor, parseSync } from "vite-plus";
+
+//#region src/features/vite/hostedChecks.ts
+/**
+* Set by Camox's revision and release sandboxes: a hosted project's build checks the code an
+* agent may have written (ADR 0021). `apps/landing` and dev mode never set it.
+*/
+const HOSTED_BUILD_ENV = "CAMOX_INTERNAL_HOSTED";
+const sdkRoot = resolve(dirname(fileURLToPath(import.meta.url)), "../../..");
+/** `camox`'s public entry points, as `camox/<path>`: its exports, less its internal ones. */
+function camoxEntryPoints() {
+	const { exports } = JSON.parse(readFileSync(join(sdkRoot, "package.json"), "utf8"));
+	return new Set(Object.keys(exports).filter((path) => !path.startsWith("./_internal/")).map((path) => `camox${path.slice(1)}`));
+}
+function readHostedProject(root) {
+	const { dependencies = {} } = JSON.parse(readFileSync(join(root, "package.json"), "utf8"));
+	return {
+		root,
+		src: join(root, "src"),
+		dependencies: new Set(Object.keys(dependencies)),
+		camoxEntryPoints: camoxEntryPoints()
+	};
+}
+const withoutQuery = (path) => path.replace(/[?#].*$/, "");
+const isInside = (dir, path) => path.startsWith(dir + sep);
+const displayPath = (project, file) => relative(project.root, file).split(sep).join("/");
+/** The project's own file an importer names, when it is one of `src/`'s: the code it checks. */
+function sourceFile(project, importer) {
+	if (!importer || importer.startsWith("\0")) return;
+	const file = withoutQuery(importer);
+	return isAbsolute(file) && isInside(project.src, file) ? file : void 0;
+}
+function isAllowedImport(project, specifier, importer) {
+	if (specifier.startsWith("\0")) return true;
+	const path = withoutQuery(specifier);
+	let file;
+	if (path.startsWith("./") || path.startsWith("../")) file = resolve(dirname(importer), path);
+	else if (path.startsWith("@/")) file = resolve(project.src, path.slice(2));
+	else if (path.startsWith("/")) file = isInside(project.root, path) ? resolve(path) : resolve(project.root, `.${path}`);
+	if (file !== void 0) return isInside(project.src, file);
+	if (path === "camox" || path.startsWith("camox/")) return project.camoxEntryPoints.has(path);
+	const [scopeOrName, name] = path.split("/");
+	const packageName = scopeOrName.startsWith("@") ? `${scopeOrName}/${name}` : scopeOrName;
+	return project.dependencies.has(packageName);
+}
+/**
+* Why a file of `src/` can't import `specifier`, or nothing when it may: files of `src/`,
+* `camox`'s public entry points and `package.json`'s `dependencies`.
+*/
+function forbiddenImport(project, specifier, importer) {
+	const file = sourceFile(project, importer);
+	if (!file || isAllowedImport(project, specifier, file)) return;
+	return `${displayPath(project, file)} imports "${specifier}", which a hosted project can't import. It can import files in src/, camox's public entry points and the packages package.json lists in dependencies.`;
+}
+/** The modules the registry loads blocks from, as its globs name them. */
+const BLOCK_MODULE = /^src\/(?:camox\/)?blocks\/([^/]+)\.tsx?$/;
+/** A string an expression spells out, without running it. */
+function literalString(node) {
+	if (node?.type === "Literal" && typeof node.value === "string") return node.value;
+	if (node?.type === "TemplateLiteral" && node.expressions.length === 0) return node.quasis[0]?.value.cooked ?? void 0;
+}
+/**
+* Whether `callee` calls `createBlock`: by its name, the names a module imports it as
+* (`import { createBlock as defineBlock }`), or as a namespace's member.
+*/
+function isCreateBlock(callee, names) {
+	if (callee.type === "Identifier") return names.has(callee.name);
+	return callee.type === "MemberExpression" && callee.property.type === "Identifier" && callee.property.name === "createBlock";
+}
+/** The local names a module calls `createBlock` by: its own name, and its imports' aliases. */
+function createBlockNames(program) {
+	const names = /* @__PURE__ */ new Set(["createBlock"]);
+	for (const statement of program.body) {
+		if (statement.type !== "ImportDeclaration") continue;
+		for (const specifier of statement.specifiers) {
+			if (specifier.type !== "ImportSpecifier") continue;
+			const imported = specifier.imported;
+			if ((imported.type === "Identifier" ? imported.name : imported.value) === "createBlock") names.add(specifier.local.name);
+		}
+	}
+	return names;
+}
+/** The `id` a block definition's object literal spells out. */
+function definitionId(definition) {
+	if (definition?.type !== "ObjectExpression") return;
+	for (const property of definition.properties) {
+		if (property.type !== "Property" || property.computed) continue;
+		const key = property.key;
+		if (key.type === "Identifier" && key.name === "id" || key.type === "Literal" && key.value === "id") return property.value;
+	}
+}
+/**
+* Why a block's module breaks the registry, or nothing when it doesn't. The browser finds a block
+* by its file name, so a block's file must be named after its id: the build reads the id from the
+* `createBlock()` call, and needs it written as a string.
+*/
+function misnamedBlock(project, moduleId, code) {
+	const file = sourceFile(project, moduleId);
+	if (!file) return;
+	const path = displayPath(project, file);
+	const fileName = BLOCK_MODULE.exec(path)?.[1];
+	if (!fileName) return;
+	const { program, errors } = parseSync(file, code);
+	if (errors.length > 0) return;
+	let problem;
+	const names = createBlockNames(program);
+	new Visitor({ CallExpression(call) {
+		if (problem || !isCreateBlock(call.callee, names)) return;
+		const id = literalString(definitionId(call.arguments[0]));
+		const at = definitionId(call.arguments[0])?.start ?? call.start;
+		if (id === void 0) problem = {
+			message: `${path} calls createBlock() without its id as a string literal, which the build needs to check that the file is named after it: write \`id: "${fileName}"\`.`,
+			at
+		};
+		else if (id !== fileName) problem = {
+			message: `${path} defines the block "${id}", but its file is named "${fileName}": a block's file is named after its id. Rename the file to ${id}${file.slice(file.lastIndexOf("."))} or the id to "${fileName}".`,
+			at
+		};
+	} }).visit(program);
+	return problem;
+}
+
+//#endregion
+export { HOSTED_BUILD_ENV, forbiddenImport, misnamedBlock, readHostedProject };