@classytic/labs 0.1.0 → 0.3.0

package/dist/blocks/index.mjs

@@ -1,120 +1,22 @@
 import { coerceArray } from "./authoring.mjs";
-import { LabConfig } from "./lab-config.mjs";
-import { AtwoodBlock, BulletWallsBlock, CarnotBlock, CircularMotionBlock, CollisionTrackBlock, DopplerBlock, EfficiencyBlock, EnergySkateBlock, EntropyBlock, GasProcessBlock, GravitationBlock, GravityDropBlock, HeatTransferBlock, HeatingCurveBlock, ImpulseBlock, KeplerBlock, LeverBlock, LeverPuzzle, LorentzBlock, MagnetismBlock, OpticsBlock, OrbitLabBlock, ProjectileLabBlock, RainRelativeBlock, RampForcesBlock, RippleTankBlock, RiverBoatBlock, SimpleHarmonicBlock, StoppingDistanceBlock, StringReflectionBlock, TemperatureScalesBlock, TerminalVelocityBlock, ThermalExpansionBlock, VectorBoardBlock, VectorTypesBlock, WaterDensityBlock, WaveBlock, physicsBlocks, physicsComponents } from "./physics.mjs";
-import { AreaModelBlock, BalanceAlgebraBlock, DerivationBlock, DerivativeExplorerBlock, GradientDescentBlock, GraphBlock, GrowingPatternBlock, IntegralExplorerBlock, InteractiveProblemBlock, LimitExplorerBlock, LinearSystemBlock, LinearSystemView, MysteryBucketBlock, NumberLineBlock, TriangleTrigBlock, TrigExplorerBlock, VertexParabolaBlock, mathBlocks, mathComponents } from "./math.mjs";
-import { BatteryBlock, BohrAtomBlock, DilutionBlock, ElectrochemBlock, GasBoxBlock, KineticsBlock, LeChatelierBlock, PeriodicTrendsBlock, ReactionLabBlock, ReactionProfileBlock, SolutionBoxBlock, StoichiometryBlock, TitrationBlock, chemBlocks, chemComponents } from "./chem.mjs";
-import { CapacitorLeakBlock, CircuitBlock, CircuitBuilderBlock, CircuitLabBlock, CircuitPuzzle, circuitsBlocks, circuitsComponents } from "./circuits.mjs";
-import { GeometryBoardBlock, IntersectingCirclesBlock, geometryBlocks, geometryComponents } from "./geometry.mjs";
-import { BaseOdometerBlock, BitGrouperBlock, PlaceValueDialBlock, ictBlocks, ictComponents } from "./ict.mjs";
-import { AgreementBlock, ArticleLensBlock, PrepositionBlock, SentenceBuilderBlock, TransformBlock, WordMatchBlock, languageBlocks, languageComponents } from "./language.mjs";
-import { EquationBalanceBlock, JournalPosterBlock, StatementSorterBlock, accountingBlocks, accountingComponents } from "./accounting.mjs";
-import { DemandShiftVsMoveBlock, ElasticityRevenueBlock, MarketEquilibriumBlock, economicsBlocks, economicsComponents } from "./economics.mjs";
-import { CentralDogmaBlock, EnzymeRateBlock, GeneticCrossBlock, PhotosynthesisFactorsBlock, PunnettCrossBlock, RespirationBlock, SequenceBlock, SexLinkedCrossBlock, biologyBlocks, biologyComponents } from "./biology.mjs";
-import { CycleBlock, geographyBlocks, geographyComponents } from "./geography.mjs";
-import { ClassifierThresholdBlock, KMeansBlock, RegressionBlock, mlBlocks, mlComponents } from "./ml.mjs";
-import { ArrangementsBlock, BayesBlock, BinomialBlock, BooleanCircuitBlock, CountingSlotsBlock, CountingTreeBlock, ExpectedValueBlock, HypergeometricBlock, KarnaughBlock, LawOfLargeNumbersBlock, MonteCarloBlock, MontyHallBlock, OutcomeBuilderBlock, PascalBlock, SampleSpaceBlock, SelectionBlock, TruthTableBlock, VennBlock, discreteBlocks, discreteComponents } from "./discrete.mjs";
-import { CenterSpreadBlock, GaltonBlock, HistogramBlock, NormalBlock, SamplingBlock, SeriesBlock, ZTableBlock, statisticsBlocks, statisticsComponents } from "./statistics.mjs";
 import { PredictBlock, PredictWidget, lessonBlocks, lessonComponents } from "./lesson.mjs";
-import { LabGallery } from "./lab-gallery.mjs";
+import { LabConfig } from "./lab-config.mjs";
+import { parseAuthoredAttrs, parseAuthoredValue } from "../lab-def/attrs.mjs";
+import { manifestComponents } from "../domains/render.mjs";
+import { manifestBlocks } from "../domains/blocks.mjs";
+import { labCatalog } from "./catalog.mjs";
+import { lazyLabBlocks } from "./lazy.mjs";
 
 //#region src/blocks/index.tsx
-/** Every lab block — pass to `<CmsBlockEditor blocks={labsBlocks}>` (slash menu). */
-const labsBlocks = [
-	...lessonBlocks,
-	...languageBlocks,
-	...physicsBlocks,
-	...mathBlocks,
-	...chemBlocks,
-	...circuitsBlocks,
-	...geometryBlocks,
-	...ictBlocks,
-	...accountingBlocks,
-	...economicsBlocks,
-	...biologyBlocks,
-	...geographyBlocks,
-	...mlBlocks,
-	...discreteBlocks,
-	...statisticsBlocks
-];
-/** MDX render map — merge into the host's `blockComponents` (tag → component).
+/** Every lab block, pass to `<CmsBlockEditor blocks={labsBlocks}>` (slash menu). */
+const labsBlocks = [...manifestBlocks, ...lessonBlocks];
+/** MDX render map, merge into the host's `blockComponents` (tag → component).
 *  Tags match each block's `tag` so editor + player render the same component.
 *  Tags are unique across domains, so spread order is irrelevant. */
 const labsComponents = {
 	...lessonComponents,
-	...languageComponents,
-	...physicsComponents,
-	...mathComponents,
-	...chemComponents,
-	...circuitsComponents,
-	...geometryComponents,
-	...ictComponents,
-	...accountingComponents,
-	...economicsComponents,
-	...biologyComponents,
-	...geographyComponents,
-	...mlComponents,
-	...discreteComponents,
-	...statisticsComponents
+	...manifestComponents
 };
-/** Every lab tagged with its subject group, for `<LabGallery blocks={labGalleryItems}>`. */
-const labGalleryItems = [
-	...mathBlocks.map((b) => ({
-		...b,
-		group: "Math"
-	})),
-	...physicsBlocks.map((b) => ({
-		...b,
-		group: "Physics"
-	})),
-	...chemBlocks.map((b) => ({
-		...b,
-		group: "Chemistry"
-	})),
-	...biologyBlocks.map((b) => ({
-		...b,
-		group: "Biology"
-	})),
-	...circuitsBlocks.map((b) => ({
-		...b,
-		group: "Circuits"
-	})),
-	...geometryBlocks.map((b) => ({
-		...b,
-		group: "Geometry"
-	})),
-	...discreteBlocks.map((b) => ({
-		...b,
-		group: "Discrete"
-	})),
-	...statisticsBlocks.map((b) => ({
-		...b,
-		group: "Statistics"
-	})),
-	...ictBlocks.map((b) => ({
-		...b,
-		group: "ICT"
-	})),
-	...languageBlocks.map((b) => ({
-		...b,
-		group: "Language"
-	})),
-	...accountingBlocks.map((b) => ({
-		...b,
-		group: "Accounting"
-	})),
-	...economicsBlocks.map((b) => ({
-		...b,
-		group: "Economics"
-	})),
-	...geographyBlocks.map((b) => ({
-		...b,
-		group: "Geography"
-	})),
-	...mlBlocks.map((b) => ({
-		...b,
-		group: "Machine learning"
-	}))
-];
 
 //#endregion
-export { AgreementBlock, AreaModelBlock, ArrangementsBlock, ArticleLensBlock, AtwoodBlock, BalanceAlgebraBlock, BaseOdometerBlock, BatteryBlock, BayesBlock, BinomialBlock, BitGrouperBlock, BohrAtomBlock, BooleanCircuitBlock, BulletWallsBlock, CapacitorLeakBlock, CarnotBlock, CenterSpreadBlock, CentralDogmaBlock, CircuitBlock, CircuitBuilderBlock, CircuitLabBlock, CircuitPuzzle, CircularMotionBlock, ClassifierThresholdBlock, CollisionTrackBlock, CountingSlotsBlock, CountingTreeBlock, CycleBlock, DemandShiftVsMoveBlock, DerivationBlock, DerivativeExplorerBlock, DilutionBlock, DopplerBlock, EfficiencyBlock, ElasticityRevenueBlock, ElectrochemBlock, EnergySkateBlock, EntropyBlock, EnzymeRateBlock, EquationBalanceBlock, ExpectedValueBlock, GaltonBlock, GasBoxBlock, GasProcessBlock, GeneticCrossBlock, GeometryBoardBlock, GradientDescentBlock, GraphBlock, GravitationBlock, GravityDropBlock, GrowingPatternBlock, HeatTransferBlock, HeatingCurveBlock, HistogramBlock, HypergeometricBlock, ImpulseBlock, IntegralExplorerBlock, InteractiveProblemBlock, IntersectingCirclesBlock, JournalPosterBlock, KMeansBlock, KarnaughBlock, KeplerBlock, KineticsBlock, LabConfig, LabGallery, LawOfLargeNumbersBlock, LeChatelierBlock, LeverBlock, LeverPuzzle, LimitExplorerBlock, LinearSystemBlock, LinearSystemView, LorentzBlock, MagnetismBlock, MarketEquilibriumBlock, MonteCarloBlock, MontyHallBlock, MysteryBucketBlock, NormalBlock, NumberLineBlock, OpticsBlock, OrbitLabBlock, OutcomeBuilderBlock, PascalBlock, PeriodicTrendsBlock, PhotosynthesisFactorsBlock, PlaceValueDialBlock, PredictBlock, PredictWidget, PrepositionBlock, ProjectileLabBlock, PunnettCrossBlock, RainRelativeBlock, RampForcesBlock, ReactionLabBlock, ReactionProfileBlock, RegressionBlock, RespirationBlock, RippleTankBlock, RiverBoatBlock, SampleSpaceBlock, SamplingBlock, SelectionBlock, SentenceBuilderBlock, SequenceBlock, SeriesBlock, SexLinkedCrossBlock, SimpleHarmonicBlock, SolutionBoxBlock, StatementSorterBlock, StoichiometryBlock, StoppingDistanceBlock, StringReflectionBlock, TemperatureScalesBlock, TerminalVelocityBlock, ThermalExpansionBlock, TitrationBlock, TransformBlock, TriangleTrigBlock, TrigExplorerBlock, TruthTableBlock, VectorBoardBlock, VectorTypesBlock, VennBlock, VertexParabolaBlock, WaterDensityBlock, WaveBlock, WordMatchBlock, ZTableBlock, accountingBlocks, accountingComponents, biologyBlocks, biologyComponents, chemBlocks, chemComponents, circuitsBlocks, circuitsComponents, coerceArray, discreteBlocks, discreteComponents, economicsBlocks, economicsComponents, geographyBlocks, geographyComponents, geometryBlocks, geometryComponents, ictBlocks, ictComponents, labGalleryItems, labsBlocks, labsComponents, languageBlocks, languageComponents, lessonBlocks, lessonComponents, mathBlocks, mathComponents, mlBlocks, mlComponents, physicsBlocks, physicsComponents, statisticsBlocks, statisticsComponents };
+export { LabConfig, PredictBlock, PredictWidget, coerceArray, labCatalog, labsBlocks, labsComponents, lazyLabBlocks, lessonBlocks, lessonComponents, parseAuthoredAttrs, parseAuthoredValue };

package/dist/blocks/lab-block.mjs

@@ -1,21 +1,20 @@
 'use client';
 
-import { LabConfig } from "./lab-config.mjs";
 import { jsx, jsxs } from "react/jsx-runtime";
 import { z } from "zod";
 import { defineBlock } from "@classytic/cms-ui/contract";
 
 //#region src/blocks/lab-block.tsx
 /**
-* labBlock — wrap a plain lab component into a CMS block "on call", with ZERO
+* labBlock, wrap a plain lab component into a CMS block "on call", with ZERO
 * per-lab boilerplate. The host passes the lab component + its zod prop-schema; this
 * returns a `defineBlock` spec whose Component:
 *   • in render mode  → spreads the block attributes straight into the lab, and
 *   • in editing mode → shows the generic, zod-driven `LabConfig` panel above it
-*     (one field per prop, derived from the schema — no hand-written ConfigPanel).
+*     (one field per prop, derived from the schema, no hand-written ConfigPanel).
 * The MDX tag is auto-derived (PascalCase of the key) by `defineBlock`.
 *
-* This is the ONE shared factory for every domain (`./physics`, `./chem`, …) — a
+* This is the ONE shared factory for every domain (`./physics`, `./chem`, …), a
 * domain file just declares `labBlock({ key, label, description, schema, Component })`
 * per lab instead of re-implementing the defineBlock + attribute-spread + editor
 * wiring each time. `commonLabProps` are the title/prompt/objectives/hints/controlId
@@ -29,46 +28,6 @@ const commonLabProps = {
 	hints: z.array(z.string()).optional(),
 	controlId: z.string().optional()
 };
-/** PascalCase MDX tag from a kebab key — mirrors `defineBlock`'s default, for building a components map. */
-const pascalTag = (key) => key.split("-").map((s) => s.charAt(0).toUpperCase() + s.slice(1)).join("");
-function labBlock({ key, label, description, schema, Component, tag, omit }) {
-	const block = defineBlock({
-		key,
-		void: true,
-		...tag ? { tag } : {},
-		label,
-		description,
-		category: "interactive",
-		schema,
-		Component: ({ attributes, mode, updateAttributes }) => {
-			const widget = Component(attributes);
-			if (mode !== "editing" || !updateAttributes) return widget;
-			return /* @__PURE__ */ jsxs("div", { children: [/* @__PURE__ */ jsx(LabConfig, {
-				schema,
-				value: attributes,
-				onChange: updateAttributes,
-				omit
-			}), widget] });
-		}
-	});
-	return Object.assign(block, {
-		tag: tag ?? pascalTag(key),
-		lab: Component
-	});
-}
-/**
-* Derive the tag→component MDX render map from a domain's blocks — ONE source of truth.
-* Only `labBlock`-created blocks carry `.lab`; bespoke `defineBlock` blocks (custom editor
-* UI) are merged into the map by hand alongside this.
-*/
-function buildComponents(blocks) {
-	const map = {};
-	for (const b of blocks) {
-		const lb = b;
-		if (typeof lb.tag === "string" && typeof lb.lab === "function") map[lb.tag] = lb.lab;
-	}
-	return map;
-}
 
 //#endregion
-export { buildComponents, commonLabProps, labBlock };
+export { commonLabProps };

package/dist/blocks/lab-config.d.mts

@@ -5,7 +5,7 @@ import { z } from "zod";
 interface LabConfigProps {
   schema: z.ZodType;
   value: Record<string, unknown>;
-  /** Patch callback — same shape as a block's `updateAttributes`. */
+  /** Patch callback, same shape as a block's `updateAttributes`. */
   onChange: (patch: Record<string, unknown>) => void;
   /** Props to skip (e.g. ones a bespoke panel already handles). */
   omit?: string[];

package/dist/blocks/lab-config.mjs

@@ -1,20 +1,21 @@
 'use client';
 
 import { ChipToggle, ConfigPanel, ConfigRow, JsonArea, NumField, RowsEditor, TagsField, TextField } from "./authoring.mjs";
-import { Fragment, jsx } from "react/jsx-runtime";
+import { useId } from "react";
+import { Fragment as Fragment$1, jsx } from "react/jsx-runtime";
 import { z } from "zod";
 
 //#region src/blocks/lab-config.tsx
 /**
-* LabConfig — the schema→form primitive. Give it a lab's Zod prop schema (already
+* LabConfig, the schema→form primitive. Give it a lab's Zod prop schema (already
 * the source of truth) + the current attributes + an `updateAttributes`-shaped
-* patch callback, and it introspects the schema and renders a friendly form — NO
+* patch callback, and it introspects the schema and renders a friendly form, NO
 * raw JSON for the common cases:
 *   string→TextField · number→NumField · boolean→toggle · enum→chips
 *   array<object>→RowsEditor (columns auto-derived from the element shape)
 *   array<string>→tag input · nested object→a nested sub-form (recursion)
 * Only genuinely un-introspectable shapes (unions, records, arrays of arrays)
-* fall back to a raw-JSON box — an explicit last resort, not the default.
+* fall back to a raw-JSON box, an explicit last resort, not the default.
 *
 * So a block can drop its whole hand-built panel and do
 *   <LabConfig schema={SCHEMA} value={attributes} onChange={updateAttributes} />
@@ -50,7 +51,7 @@ const GROW_KEYS = new Set([
 	"title",
 	"description"
 ]);
-/** Map a ZodObject's fields to RowsEditor columns — null if any field is too complex to flatten. */
+/** Map a ZodObject's fields to RowsEditor columns, null if any field is too complex to flatten. */
 function columnsFor(obj) {
 	const cols = [];
 	for (const [k, f] of Object.entries(obj.shape)) {
@@ -81,7 +82,52 @@ function columnsFor(obj) {
 	}
 	return cols.length ? cols : null;
 }
+/** The `.describe()` text of a field, looking through optional/default wrappers. */
+function hintOf(field, base) {
+	return field.description ?? base.description;
+}
+/** Best-effort min/max (+ int step) off a ZodNumber, across zod versions. */
+function numConstraints(base) {
+	const out = {};
+	try {
+		const b = base;
+		if (typeof b.minValue === "number") out.min = b.minValue;
+		if (typeof b.maxValue === "number") out.max = b.maxValue;
+		const checks = b.def?.checks ?? b._def?.checks ?? [];
+		for (const c of checks) {
+			const kind = c?.kind ?? c?.check ?? c?.format;
+			if (kind === "int" || kind === "safeint") out.step = 1;
+		}
+	} catch {}
+	return out;
+}
 /** A blank record matching a ZodObject (for RowsEditor's "+ row"). */
+/**
+* The `.default(...)` a field carries, if any.
+*
+* Used to seed the raw-JSON fallback. A block inserts with NO attributes, so a nested-array prop
+* would otherwise open as `[]` and the author has to type the whole structure from memory. The
+* schema already holds a worked example: showing it is the difference between an editable
+* starting point and a blank box.
+*/
+function defaultOf(field) {
+	let s = field;
+	for (let i = 0; i < 8; i++) {
+		if (s instanceof z.ZodDefault) {
+			const get = s.def.defaultValue;
+			try {
+				return typeof get === "function" ? get() : get;
+			} catch {
+				return;
+			}
+		}
+		if (s instanceof z.ZodOptional || s instanceof z.ZodNullable) {
+			s = s.unwrap();
+			continue;
+		}
+		break;
+	}
+}
 function blankFor(obj) {
 	const r = {};
 	for (const [k, f] of Object.entries(obj.shape)) {
@@ -91,60 +137,85 @@ function blankFor(obj) {
 	return r;
 }
 function LabConfig({ schema, value, onChange, omit = [], flat = false }) {
+	const uid = useId();
 	if (!(schema instanceof z.ZodObject)) return /* @__PURE__ */ jsx(JsonArea, {
 		value,
 		onChange: (v) => onChange(v)
 	});
 	const shape = schema.shape;
 	const set = (k, v) => onChange({ [k]: v });
+	const parsed = schema.safeParse(value ?? {});
+	const errors = {};
+	if (!parsed.success) for (const issue of parsed.error.issues) {
+		const k = String(issue.path[0] ?? "");
+		if (k && !(k in errors)) errors[k] = issue.message;
+	}
 	const rows = Object.entries(shape).filter(([k]) => !omit.includes(k)).map(([key, field]) => {
 		const base = baseOf(field);
 		const cur = value?.[key];
-		if (base instanceof z.ZodString) return /* @__PURE__ */ jsx(ConfigRow, {
+		const err = errors[key];
+		const hint = hintOf(field, base);
+		const errId = err ? `${uid}-${key}-err` : void 0;
+		const rowProps = {
 			label: key,
+			hint,
+			error: err,
+			errorId: errId
+		};
+		if (base instanceof z.ZodString) return /* @__PURE__ */ jsx(ConfigRow, {
+			...rowProps,
 			children: /* @__PURE__ */ jsx(TextField, {
 				value: cur ?? "",
 				onChange: (v) => set(key, v),
-				className: "flex-1"
-			})
-		}, key);
-		if (base instanceof z.ZodNumber) return /* @__PURE__ */ jsx(ConfigRow, {
-			label: key,
-			children: /* @__PURE__ */ jsx(NumField, {
-				value: cur ?? 0,
-				onChange: (v) => set(key, v)
+				className: "flex-1",
+				invalid: !!err,
+				describedBy: errId
 			})
 		}, key);
+		if (base instanceof z.ZodNumber) {
+			const c = numConstraints(base);
+			return /* @__PURE__ */ jsx(ConfigRow, {
+				...rowProps,
+				children: /* @__PURE__ */ jsx(NumField, {
+					value: cur ?? 0,
+					onChange: (v) => set(key, v),
+					invalid: !!err,
+					describedBy: errId,
+					min: c.min,
+					max: c.max,
+					step: c.step
+				})
+			}, key);
+		}
 		if (base instanceof z.ZodBoolean) return /* @__PURE__ */ jsx(ConfigRow, {
-			label: key,
+			...rowProps,
 			children: /* @__PURE__ */ jsx(ChipToggle, {
 				active: !!cur,
 				onClick: () => set(key, !cur),
 				children: key
 			})
 		}, key);
-		if (base instanceof z.ZodEnum) return /* @__PURE__ */ jsx(ConfigRow, {
-			label: key,
-			children: /* @__PURE__ */ jsx("span", {
-				style: {
-					display: "inline-flex",
-					gap: 6,
-					flexWrap: "wrap"
-				},
-				children: (base.options ?? []).map((o) => /* @__PURE__ */ jsx(ChipToggle, {
-					active: cur === o,
-					onClick: () => set(key, o),
-					children: o
-				}, o))
-			})
-		}, key);
+		if (base instanceof z.ZodEnum) {
+			const opts = base.options ?? [];
+			return /* @__PURE__ */ jsx(ConfigRow, {
+				...rowProps,
+				children: /* @__PURE__ */ jsx("span", {
+					className: "lab-config-options",
+					children: opts.map((o) => /* @__PURE__ */ jsx(ChipToggle, {
+						active: cur === o,
+						onClick: () => set(key, o),
+						children: o
+					}, o))
+				})
+			}, key);
+		}
 		if (base instanceof z.ZodArray) {
 			const el = elementOf(base);
 			const elBase = el ? baseOf(el) : null;
 			if (elBase instanceof z.ZodObject) {
 				const cols = columnsFor(elBase);
 				if (cols) return /* @__PURE__ */ jsx(ConfigRow, {
-					label: key,
+					...rowProps,
 					children: /* @__PURE__ */ jsx(RowsEditor, {
 						rows: Array.isArray(cur) ? cur : [],
 						columns: cols,
@@ -155,7 +226,7 @@ function LabConfig({ schema, value, onChange, omit = [], flat = false }) {
 				}, key);
 			}
 			if (elBase instanceof z.ZodString) return /* @__PURE__ */ jsx(ConfigRow, {
-				label: key,
+				...rowProps,
 				children: /* @__PURE__ */ jsx(TagsField, {
 					value: Array.isArray(cur) ? cur : [],
 					onChange: (v) => set(key, v),
@@ -164,14 +235,17 @@ function LabConfig({ schema, value, onChange, omit = [], flat = false }) {
 			}, key);
 			return /* @__PURE__ */ jsx(ConfigRow, {
 				label: `${key} (advanced)`,
+				hint,
+				error: err,
+				errorId: errId,
 				children: /* @__PURE__ */ jsx(JsonArea, {
-					value: cur ?? [],
+					value: cur ?? defaultOf(field) ?? [],
 					onChange: (v) => set(key, v)
 				})
 			}, key);
 		}
 		if (base instanceof z.ZodObject) return /* @__PURE__ */ jsx(ConfigRow, {
-			label: key,
+			...rowProps,
 			children: /* @__PURE__ */ jsx("span", {
 				className: "w-full rounded-md border border-border/60 bg-background/40 p-1.5",
 				children: /* @__PURE__ */ jsx(LabConfig, {
@@ -187,13 +261,16 @@ function LabConfig({ schema, value, onChange, omit = [], flat = false }) {
 		}, key);
 		return /* @__PURE__ */ jsx(ConfigRow, {
 			label: `${key} (advanced)`,
+			hint,
+			error: err,
+			errorId: errId,
 			children: /* @__PURE__ */ jsx(JsonArea, {
 				value: cur ?? null,
 				onChange: (v) => set(key, v)
 			})
 		}, key);
 	});
-	return flat ? /* @__PURE__ */ jsx(Fragment, { children: rows }) : /* @__PURE__ */ jsx(ConfigPanel, { children: rows });
+	return flat ? /* @__PURE__ */ jsx(Fragment$1, { children: rows }) : /* @__PURE__ */ jsx(ConfigPanel, { children: rows });
 }
 
 //#endregion

package/dist/blocks/lazy-resolve.d.mts

@@ -0,0 +1,20 @@
+import { LabDomain } from "./catalog.mjs";
+import { ReactNode } from "react";
+
+//#region src/blocks/lazy-resolve.d.ts
+interface LazyLabProps {
+  domain?: LabDomain;
+  blockKey: string;
+  fallback?: ReactNode;
+  attributes: Record<string, unknown>;
+  mode?: string;
+  updateAttributes?: (patch: Record<string, unknown>) => void;
+  children?: ReactNode;
+}
+/** Resolve exclusively through the per-lab manifest registry. */
+declare function LazyLab({
+  blockKey,
+  attributes
+}: LazyLabProps): ReactNode;
+//#endregion
+export { LazyLab, LazyLabProps };

package/dist/blocks/lazy-resolve.mjs

@@ -0,0 +1,24 @@
+'use client';
+
+import { manifestComponentsByKey } from "../domains/render.mjs";
+import { createElement } from "react";
+import { jsxs } from "react/jsx-runtime";
+
+//#region src/blocks/lazy-resolve.tsx
+/** Resolve exclusively through the per-lab manifest registry. */
+function LazyLab({ blockKey, attributes }) {
+	const Component = manifestComponentsByKey[blockKey];
+	if (Component) return createElement(Component, attributes);
+	return /* @__PURE__ */ jsxs("div", {
+		role: "alert",
+		className: "lab-load-error",
+		children: [
+			"Unknown lab “",
+			blockKey,
+			"”. Regenerate the manifest registry."
+		]
+	});
+}
+
+//#endregion
+export { LazyLab };

package/dist/blocks/lazy.d.mts

@@ -0,0 +1,10 @@
+import { LabCatalogEntry, LabDomain, labCatalog } from "./catalog.mjs";
+import { LazyLab, LazyLabProps } from "./lazy-resolve.mjs";
+import { CmsBlock } from "@classytic/cms-ui/contract";
+
+//#region src/blocks/lazy.d.ts
+/** Every lab block for `<CmsBlockEditor blocks={…}>`: migrated labs (real schema + per-lab
+ *  loader) then the still-generated labs. */
+declare const lazyLabBlocks: readonly CmsBlock[];
+//#endregion
+export { type LabCatalogEntry, type LabDomain, LazyLab, type LazyLabProps, labCatalog, lazyLabBlocks };

package/dist/blocks/lazy.mjs

@@ -0,0 +1,13 @@
+'use client';
+
+import { manifestBlocks } from "../domains/blocks.mjs";
+import { labCatalog } from "./catalog.mjs";
+import { LazyLab } from "./lazy-resolve.mjs";
+
+//#region src/blocks/lazy.tsx
+/** Every lab block for `<CmsBlockEditor blocks={…}>`: migrated labs (real schema + per-lab
+*  loader) then the still-generated labs. */
+const lazyLabBlocks = manifestBlocks;
+
+//#endregion
+export { LazyLab, labCatalog, lazyLabBlocks };

package/dist/blocks/lesson.mjs

@@ -8,14 +8,14 @@ import { defineBlock } from "@classytic/cms-ui/contract";
 
 //#region src/blocks/lesson.tsx
 /**
-* @classytic/labs/blocks — lesson / pedagogy blocks (domain-neutral).
+* @classytic/labs/blocks, lesson / pedagogy blocks (domain-neutral).
 *
-* `PredictBlock` is the missing primitive that lets a CREATOR — not a developer —
+* `PredictBlock` is the missing primitive that lets a CREATOR, not a developer ,
 * author a predict-first lesson: a multiple-choice question the learner commits to
 * before the reveal. A correct pick shows the "why" and reports completion through
 * the learner/step seam, so dropping one between or after any lab turns a sequence
 * of widgets into a gated, guided lesson. The creator authors the prompt, the
-* choices (mark the correct one), and the explanation — entirely in the editor.
+* choices (mark the correct one), and the explanation, entirely in the editor.
 *
 * This is the authorable version of the predict-first card that the "Why ice floats"
 * reference lesson used in code: same ChallengeCard + useCheckpoint underneath, now
@@ -63,7 +63,7 @@ const PredictBlock = defineBlock({
 	tag: "Predict",
 	void: true,
 	label: "Predict / quiz question",
-	description: "A predict-first multiple-choice question. The learner commits to an answer; a correct pick reveals the explanation and completes the step (so it can gate a guided lesson). Author your own prompt, choices and explanation — drop it before or after any lab.",
+	description: "A predict-first multiple-choice question. The learner commits to an answer; a correct pick reveals the explanation and completes the step (so it can gate a guided lesson). Author your own prompt, choices and explanation, drop it before or after any lab.",
 	category: "interactive",
 	schema: z.object({
 		prompt: z.string().default("What do you predict?"),

package/dist/build/CircuitEditor.d.mts

@@ -0,0 +1,14 @@
+import { CircuitDoc } from "./contract.mjs";
+import { ReactNode } from "react";
+
+//#region src/build/CircuitEditor.d.ts
+interface CircuitEditorProps {
+  value: CircuitDoc;
+  onChange: (doc: CircuitDoc) => void;
+}
+declare function CircuitEditor({
+  value,
+  onChange
+}: CircuitEditorProps): ReactNode;
+//#endregion
+export { CircuitEditor, CircuitEditorProps };