@classytic/labs 0.6.0 → 0.7.0

package/dist/domains/accounting/equation-balance/runtime.mjs

@@ -1,11 +1,12 @@
 'use client';
 
+import { formatNumber } from "../../../model/money.mjs";
 import { CheckButton, Chip } from "../../../kit/controls.mjs";
 import { Field, Readout } from "../../../kit/frame.mjs";
 import { useLab } from "../../../runtime/use-lab.mjs";
 import { AuthoredActivityRuntime } from "../../../kit/authored-activity-runtime.mjs";
 import { EvidencePanel } from "../../../commerce/activity.mjs";
-import { equationBalanceModel, money } from "./model.mjs";
+import { equationBalanceModel } from "./model.mjs";
 import { equationBalanceActivity } from "./activity.mjs";
 import { EquationBalanceScene } from "./scene.mjs";
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
@@ -27,12 +28,18 @@ function EquationBalance(props) {
 				scenario.transactions.length,
 				" transactions"
 			] }),
-			/* @__PURE__ */ jsxs("span", { children: ["Assets ", money(reading.assets)] }),
+			/* @__PURE__ */ jsxs("span", { children: ["Assets ", formatNumber(reading.assets, {
+				decimals: 0,
+				grouping: scenario.grouping
+			})] }),
 			/* @__PURE__ */ jsxs("span", { children: [
 				"Liabilities + ",
 				scenario.capitalLabel,
 				" ",
-				money(reading.rhs)
+				formatNumber(reading.rhs, {
+					decimals: 0,
+					grouping: scenario.grouping
+				})
 			] })
 		] }),
 		evidence: ({ scenario, reading }) => scenario.mode === "guided" ? undefined : /* @__PURE__ */ jsxs(EvidencePanel, {
@@ -40,17 +47,30 @@ function EquationBalance(props) {
 			children: [/* @__PURE__ */ jsx(Readout, {
 				tone: reading.balanced ? "result" : "info",
 				accent: reading.balanced ? "var(--lab-good)" : "var(--lab-danger)",
-				value: /* @__PURE__ */ jsx(Fragment, { children: reading.balanced ? "Balanced ✓" : `Off by ${money(Math.abs(reading.imbalance))}` }),
+				value: /* @__PURE__ */ jsx(Fragment, { children: reading.balanced ? "Balanced ✓" : `Off by ${formatNumber(Math.abs(reading.imbalance), {
+					decimals: 0,
+					grouping: scenario.grouping
+				})}` }),
 				sub: /* @__PURE__ */ jsxs(Fragment, { children: [
 					"Assets ",
-					money(reading.assets),
-					" = Liabilities ",
-					money(reading.liabilities + reading.extraLE),
+					formatNumber(reading.assets, {
+						decimals: 0,
+						grouping: scenario.grouping
+					}),
+					" = Liabilities",
+					" ",
+					formatNumber(reading.liabilities + reading.extraLE, {
+						decimals: 0,
+						grouping: scenario.grouping
+					}),
 					" ",
 					"+ ",
 					scenario.capitalLabel,
 					" ",
-					money(reading.equity)
+					formatNumber(reading.equity, {
+						decimals: 0,
+						grouping: scenario.grouping
+					})
 				] })
 			}), /* @__PURE__ */ jsx("p", {
 				className: "finance-aside-copy",
@@ -123,8 +143,20 @@ function EquationBalance(props) {
 				})
 			})] });
 		},
-		observation: ({ sequence, scenario, reading }) => scenario.mode === "guided" && sequence.current.id !== "transfer" ? undefined : reading.balanced ? `Every applied transaction keeps Assets equal to Liabilities plus ${scenario.capitalLabel}.` : `The one-sided posting leaves a ${money(Math.abs(reading.imbalance))} mismatch, so the scale exposes the broken entry.`,
-		transcript: ({ scenario, reading }) => `Assets are ${money(reading.assets)}. Liabilities plus ${scenario.capitalLabel.toLowerCase()} are ${money(reading.rhs)}. The books are ${reading.balanced ? "balanced" : `out of balance by ${money(Math.abs(reading.imbalance))}`}. ${reading.applied} of ${scenario.transactions.length} transactions are posted.${reading.next ? ` Next transaction: ${reading.next.label}.` : ""}`,
+		observation: ({ sequence, scenario, reading }) => scenario.mode === "guided" && sequence.current.id !== "transfer" ? undefined : reading.balanced ? `Every applied transaction keeps Assets equal to Liabilities plus ${scenario.capitalLabel}.` : `The one-sided posting leaves a ${formatNumber(Math.abs(reading.imbalance), {
+			decimals: 0,
+			grouping: scenario.grouping
+		})} mismatch, so the scale exposes the broken entry.`,
+		transcript: ({ scenario, reading }) => `Assets are ${formatNumber(reading.assets, {
+			decimals: 0,
+			grouping: scenario.grouping
+		})}. Liabilities plus ${scenario.capitalLabel.toLowerCase()} are ${formatNumber(reading.rhs, {
+			decimals: 0,
+			grouping: scenario.grouping
+		})}. The books are ${reading.balanced ? "balanced" : `out of balance by ${formatNumber(Math.abs(reading.imbalance), {
+			decimals: 0,
+			grouping: scenario.grouping
+		})}`}. ${reading.applied} of ${scenario.transactions.length} transactions are posted.${reading.next ? ` Next transaction: ${reading.next.label}.` : ""}`,
 		children: ({ sequence, scenario }) => scenario.mode === "guided" || sequence.shows("model") ? /* @__PURE__ */ jsx(EquationBalanceScene, {}) : /* @__PURE__ */ jsxs("div", {
 			className: "commerce-model-lock",
 			children: [/* @__PURE__ */ jsx("strong", { children: "Commit to the constraint first" }), /* @__PURE__ */ jsx("span", { children: "The balance opens after your prediction." })]

package/dist/domains/accounting/equation-balance/scene.mjs

@@ -1,11 +1,15 @@
 'use client';
 
+import { formatNumber } from "../../../model/money.mjs";
 import { useLabView } from "../../../runtime/use-lab-view.mjs";
 import { ScaleFrame } from "../../../kit/scale.mjs";
-import { equationBalanceModel, money } from "./model.mjs";
+import { equationBalanceModel } from "./model.mjs";
 import { CATEGORY_COLOR } from "../../../commerce/accounting/core.mjs";
-import { Circle, Label, Stage, StageAssetDefs } from "@classytic/stage";
+import { useId } from "react";
 import { jsx, jsxs } from "react/jsx-runtime";
+import { Stage } from "@classytic/stage/view";
+import { Circle, Label } from "@classytic/stage/primitives";
+import { StageAssetDefs } from "@classytic/stage/assets";
 
 //#region src/domains/accounting/equation-balance/scene.tsx
 const VIEW = {
@@ -23,6 +27,7 @@ const PAN_HANG = 1.35;
 const PAN_R = 1.75;
 const BASE_Y = -3.6;
 function EquationBalanceScene({ height = 320 }) {
+	const scope = useId();
 	const { scenario, reading } = useLabView(equationBalanceModel);
 	const beamA = {
 		x: PIVOT.x - HB,
@@ -59,7 +64,10 @@ function EquationBalanceScene({ height = 320 }) {
 			}), /* @__PURE__ */ jsx(Label, {
 				x: center.x,
 				y: center.y - 1.25 - i * .72,
-				text: `${ac.name} ${money(reading.balanceOf(ac.id))}`,
+				text: `${ac.name} ${formatNumber(reading.balanceOf(ac.id), {
+					decimals: 0,
+					grouping: scenario.grouping
+				})}`,
 				color: CATEGORY_COLOR[ac.category],
 				size: 13,
 				weight: 600
@@ -72,9 +80,15 @@ function EquationBalanceScene({ height = 320 }) {
 			view: VIEW,
 			height,
 			preserveAspect: true,
-			ariaLabel: `Balance: assets ${money(reading.assets)}, liabilities plus ${scenario.capitalLabel.toLowerCase()} ${money(reading.rhs)}, ${reading.balanced ? "level" : "tipped"}`,
+			ariaLabel: `Balance: assets ${formatNumber(reading.assets, {
+				decimals: 0,
+				grouping: scenario.grouping
+			})}, liabilities plus ${scenario.capitalLabel.toLowerCase()} ${formatNumber(reading.rhs, {
+				decimals: 0,
+				grouping: scenario.grouping
+			})}, ${reading.balanced ? "level" : "tipped"}`,
 			children: [
-				/* @__PURE__ */ jsx(StageAssetDefs, {}),
+				/* @__PURE__ */ jsx(StageAssetDefs, { scope }),
 				/* @__PURE__ */ jsx(Label, {
 					x: -4.2,
 					y: 3,
@@ -92,6 +106,7 @@ function EquationBalanceScene({ height = 320 }) {
 					dy: -12
 				}),
 				/* @__PURE__ */ jsx(ScaleFrame, {
+					scope,
 					pivot: PIVOT,
 					beamA,
 					beamB,
@@ -106,7 +121,16 @@ function EquationBalanceScene({ height = 320 }) {
 				/* @__PURE__ */ jsx(Label, {
 					x: 0,
 					y: BASE_Y - 1.05,
-					text: `Assets ${money(reading.assets)} = Liabilities ${money(reading.liabilities + reading.extraLE)} + ${scenario.capitalLabel} ${money(reading.equity)}`,
+					text: `Assets ${formatNumber(reading.assets, {
+						decimals: 0,
+						grouping: scenario.grouping
+					})} = Liabilities ${formatNumber(reading.liabilities + reading.extraLE, {
+						decimals: 0,
+						grouping: scenario.grouping
+					})} + ${scenario.capitalLabel} ${formatNumber(reading.equity, {
+						decimals: 0,
+						grouping: scenario.grouping
+					})}`,
 					color: "var(--stage-fg)",
 					size: 13,
 					weight: 700
@@ -123,7 +147,10 @@ function EquationBalanceScene({ height = 320 }) {
 						style: { "--equation-effect-color": CATEGORY_COLOR[account?.category ?? "Asset"] }
 					}),
 					/* @__PURE__ */ jsx("b", { children: account?.name ?? effect.account }),
-					/* @__PURE__ */ jsxs("output", { children: [effect.delta >= 0 ? "+" : "−", money(Math.abs(effect.delta))] })
+					/* @__PURE__ */ jsxs("output", { children: [effect.delta >= 0 ? "+" : "−", formatNumber(Math.abs(effect.delta), {
+						decimals: 0,
+						grouping: scenario.grouping
+					})] })
 				] }, `${reading.previous.id}-${effect.account}`);
 			})]
 		}) : null]

package/dist/domains/accounting/equation-map/activity.mjs

@@ -0,0 +1,36 @@
+import { formatMoney } from "../../../model/money.mjs";
+import { labActivity } from "../../../kit/goal-activity.mjs";
+import { defineActivity } from "../../../runtime/activity.mjs";
+import { equationMapModel } from "./model.mjs";
+
+//#region src/domains/accounting/equation-map/activity.ts
+/** Tap the lit terms (the goal), turn on the sides to see the rule; with a hidden amount, find it. */
+const equationMapActivity = defineActivity(equationMapModel, (s) => {
+	const hidden = s.hide ? s.terms.find((t) => t.id === s.hide) : undefined;
+	const lit = s.terms.filter((t) => t.lit).map((t) => t.label);
+	return labActivity({
+		title: "One equation, every idea",
+		objectives: ["Place an accounting idea on the equation", "Read the side a term grows on from where it sits in the equation"],
+		lead: lit.length > 0 ? `This lesson is about ${lit.join(", ")}. Tap each to read it, then show the debit and credit sides.` : "Tap each term to read it, then show the debit and credit sides.",
+		goal: hidden ? "found" : "explored",
+		controls: [
+			"term",
+			"sides",
+			...hidden ? ["reveal"] : []
+		],
+		observations: hidden && hidden.value !== undefined ? [{
+			id: "hidden-amount",
+			kind: "numeric",
+			prompt: `What is ${hidden.label}?`,
+			label: hidden.label,
+			unit: s.currency,
+			answer: hidden.value,
+			tolerance: .005,
+			hints: ["Both sides of the equation are always equal. Fill in everything you know first."],
+			explain: `The two sides must agree, so ${hidden.label} is ${formatMoney(hidden.value, { currency: s.currency })}.`
+		}] : []
+	});
+});
+
+//#endregion
+export { equationMapActivity };

package/dist/domains/accounting/equation-map/manifest.mjs

@@ -0,0 +1,89 @@
+import { defineLab } from "../../../lab-def/define-lab.mjs";
+import { equationMapModel } from "./model.mjs";
+
+//#region src/domains/accounting/equation-map/manifest.ts
+var manifest_default = defineLab({
+	id: "equation-map",
+	tag: "EquationMap",
+	domain: "accounting",
+	group: "Accounting",
+	title: "One equation, every idea",
+	description: "The accounting equation, basic or extended (A = L + (C − D + R − E)), with the lesson’s part lit. Tap a term to read it; show the sides to see debit and credit fall out of each term’s place; optional live amounts with one to find.",
+	model: equationMapModel,
+	examples: [
+		{
+			name: "default",
+			props: {}
+		},
+		{
+			name: "basic",
+			props: {
+				form: "basic",
+				focus: ["assets"]
+			}
+		},
+		{
+			name: "income-statement-bracket",
+			props: {
+				focus: ["revenue", "expenses"],
+				groups: [{
+					terms: ["revenue", "expenses"],
+					label: "Income statement"
+				}],
+				sides: true
+			}
+		},
+		{
+			name: "find-the-missing-amount",
+			props: {
+				currency: "Tk ",
+				values: {
+					liabilities: 9e3,
+					capital: 5e4,
+					drawings: 2e3,
+					revenue: 12400,
+					expenses: 7700
+				},
+				hide: "assets"
+			}
+		}
+	],
+	taxonomy: {
+		grades: [
+			"9",
+			"10",
+			"11"
+		],
+		outcomes: [
+			"accounting",
+			"accounting-equation",
+			"debit",
+			"credit",
+			"double-entry"
+		],
+		durationMinutes: 4,
+		interaction: "guided",
+		authorability: "simple",
+		related: [
+			"claim-split",
+			"equation-balance",
+			"dual-aspect-transfer"
+		],
+		qualityTier: "support"
+	},
+	experience: {
+		objectives: ["Place an accounting idea on the equation", "Read the side a term grows on from where it sits in the equation"],
+		openingPhase: "act",
+		phases: ["act", "explain"],
+		responses: ["choice", "numeric"],
+		accessibility: {
+			keyboard: true,
+			textAlternative: true,
+			reducedMotion: true
+		}
+	},
+	loadRuntime: () => import("./runtime.mjs")
+});
+
+//#endregion
+export { manifest_default as default };

package/dist/domains/accounting/equation-map/model.mjs

@@ -0,0 +1,260 @@
+import { defineLabModel } from "../../../model/define.mjs";
+import { formatMoney } from "../../../model/money.mjs";
+import { refuse } from "../../../model/index.mjs";
+import { z } from "zod";
+import { EQUATION_TERMS, increaseSide, resolveExtendedEquation, termPosition } from "@classytic/stage/finance/accounting";
+
+//#region src/domains/accounting/equation-map/model.ts
+/**
+* The equation map: every accounting idea placed on one equation.
+*
+* A = L + E in its basic form, or the extended form the NCTB book prints, A = L + (C − D + R − E). A lesson lights
+* the part it is about (`focus`) and can bracket a run of terms (`groups`: R − E is the income statement). The
+* learner taps a term to read what it is and which side it grows on, and turns on the debit and credit sides to see
+* the rule fall out of the picture: a left term grows on the debit side, a right term on the credit side, a term
+* subtracted on the right on the debit side. With `values`, both sides add up live; `hide` keeps one for the learner
+* to find. Term names and notes come from the lesson, so the map reads in the lesson's language.
+*
+* The equation and the sides come from stage (`resolveExtendedEquation`, `increaseSide`).
+*/
+const termSchema = z.enum([
+	"assets",
+	"liabilities",
+	"equity",
+	"capital",
+	"drawings",
+	"revenue",
+	"expenses"
+]);
+const BASIC = [
+	"assets",
+	"liabilities",
+	"equity"
+];
+const EXTENDED = EQUATION_TERMS;
+const DEFAULT_LABEL = {
+	assets: "Assets",
+	liabilities: "Liabilities",
+	equity: "Owner's equity",
+	capital: "Capital",
+	drawings: "Drawings",
+	revenue: "Revenue",
+	expenses: "Expenses"
+};
+const textField = z.string().trim().min(1).max(240).optional();
+const perTerm = z.object({
+	assets: textField,
+	liabilities: textField,
+	equity: textField,
+	capital: textField,
+	drawings: textField,
+	revenue: textField,
+	expenses: textField
+}).default({});
+const amount = z.number().nonnegative().finite().optional();
+const equationMapParamsSchema = z.object({
+	form: z.enum(["basic", "extended"]).default("extended").describe("basic A = L + E, or extended A = L + (C − D + R − E) as the NCTB book prints it"),
+	labels: perTerm.describe("each term's name as the lesson writes it (defaults are English)"),
+	notes: perTerm.describe("what a term means, shown when the learner taps it"),
+	focus: z.array(termSchema).max(7).default([]).describe("the terms this lesson is about, lit on the map"),
+	groups: z.array(z.object({
+		terms: z.array(termSchema).min(1).max(6),
+		label: z.string().trim().min(1).max(40)
+	})).max(3).default([]).describe("brackets over a run of adjacent terms, such as revenue and expenses = income statement"),
+	values: z.object({
+		assets: amount,
+		liabilities: amount,
+		equity: amount,
+		capital: amount,
+		drawings: amount,
+		revenue: amount,
+		expenses: amount
+	}).optional().describe("amounts for every term of the form; both sides then add up live"),
+	hide: termSchema.optional().describe("a term whose amount the learner finds (needs values for the rest)"),
+	sides: z.boolean().default(false).describe("open with the debit and credit sides shown"),
+	currency: z.string().min(1).max(6).default("$").describe("printed before amounts; Tk groups in lakhs")
+});
+function positionOf(term) {
+	return term === "equity" ? "right" : termPosition(term);
+}
+function growsOf(term) {
+	return term === "equity" ? "credit" : increaseSide(term);
+}
+/** Why a term grows on its side, read off its place in the equation. */
+function sideReason(term) {
+	if (term.position === "left") return "Left of the equals sign, so it grows on the debit (left) side.";
+	if (term.position === "right") return "Right of the equals sign, so it grows on the credit (right) side.";
+	return "Subtracted on the right: as it grows, the right side shrinks, so it grows on the debit side.";
+}
+const equationMapModel = defineLabModel({
+	id: "equation-map",
+	params: equationMapParamsSchema,
+	resolve(p) {
+		const order = p.form === "basic" ? BASIC : EXTENDED;
+		const outside = [
+			...p.focus,
+			...p.groups.flatMap((g) => g.terms),
+			...p.hide ? [p.hide] : []
+		].filter((t) => !order.includes(t));
+		if (outside.length > 0) {
+			return refuse("term-not-in-form", `${[...new Set(outside)].join(", ")} is not a term of the ${p.form} equation.`);
+		}
+		const groups = [];
+		for (const group of p.groups) {
+			const idx = group.terms.map((t) => order.indexOf(t)).sort((a, b) => a - b);
+			const from = idx[0];
+			const to = idx[idx.length - 1];
+			if (to - from + 1 !== new Set(idx).size) {
+				return refuse("group-not-adjacent", `The bracket "${group.label}" must cover terms that sit side by side.`);
+			}
+			groups.push({
+				label: group.label,
+				from,
+				to
+			});
+		}
+		let totals;
+		let values;
+		if (p.hide && !p.values) return refuse("hide-needs-values", "A hidden term needs the amounts of the others.");
+		if (p.values) {
+			const given = Object.fromEntries(order.filter((t) => t !== p.hide && p.values[t] !== undefined).map((t) => [t, p.values[t]]));
+			const absent = order.filter((t) => t !== p.hide && given[t] === undefined);
+			if (absent.length > 0) return refuse("values-incomplete", `Give an amount for ${absent.join(", ")}.`);
+			try {
+				if (p.form === "basic") {
+					const a = given.assets;
+					const l = given.liabilities;
+					const e = given.equity;
+					const solved = {
+						assets: a ?? l + e,
+						liabilities: l ?? a - e,
+						equity: e ?? a - l
+					};
+					if (solved.liabilities < 0 || solved.equity < 0) throw new RangeError("negative");
+					values = solved;
+					const right = solved.liabilities + solved.equity;
+					totals = {
+						left: solved.assets,
+						right,
+						balanced: Math.abs(solved.assets - right) < .005
+					};
+				} else {
+					const eq = resolveExtendedEquation(given, p.hide);
+					values = eq.values;
+					totals = {
+						left: eq.left,
+						right: eq.right,
+						balanced: eq.balanced
+					};
+				}
+			} catch {
+				return refuse("values-impossible", "These amounts would make a term negative.");
+			}
+			if (!totals.balanced) {
+				return refuse("values-unbalanced", `The sides do not agree: ${totals.left} on the left, ${totals.right} on the right.`);
+			}
+		}
+		const lit = new Set(order.every((t) => p.focus.includes(t)) ? [] : p.focus);
+		const terms = order.map((id) => ({
+			id,
+			label: p.labels[id] ?? DEFAULT_LABEL[id],
+			note: p.notes[id],
+			position: positionOf(id),
+			grows: growsOf(id),
+			lit: lit.has(id),
+			value: values?.[id],
+			hidden: id === p.hide
+		}));
+		return {
+			form: p.form,
+			terms,
+			groups,
+			hide: p.hide,
+			sides: p.sides,
+			currency: p.currency,
+			totals
+		};
+	},
+	initial: (s) => {
+		const first = s.hide ?? s.terms.find((t) => t.lit)?.id ?? s.terms[0].id;
+		return {
+			selected: first,
+			visited: [first],
+			sides: s.sides,
+			revealed: false
+		};
+	},
+	controls: (c) => ({
+		term: c.choice({
+			label: "Term",
+			options: (s) => s.terms.map((t) => ({
+				value: t.id,
+				label: t.label
+			})),
+			get: (st) => st.selected,
+			set: (st, value, s) => {
+				const id = s.terms.find((t) => t.id === value)?.id;
+				if (!id) return st;
+				return {
+					...st,
+					selected: id,
+					visited: st.visited.includes(id) ? st.visited : [...st.visited, id]
+				};
+			}
+		}),
+		sides: c.toggle({
+			label: "Debit and credit sides",
+			get: (st) => st.sides,
+			set: (st, value) => ({
+				...st,
+				sides: value
+			}),
+			states: () => ["Shown", "Hidden"]
+		}),
+		reveal: c.toggle({
+			label: "Reveal the hidden amount",
+			when: (s) => s.hide !== undefined,
+			get: (st) => st.revealed,
+			set: (st, value) => ({
+				...st,
+				revealed: value
+			}),
+			states: () => ["Revealed", "Hidden"]
+		})
+	}),
+	read(s, st) {
+		const selected = s.terms.find((t) => t.id === st.selected) ?? s.terms[0];
+		const focusIds = s.terms.filter((t) => t.lit).map((t) => t.id);
+		const toVisit = focusIds.length > 0 ? focusIds : s.terms.map((t) => t.id);
+		return {
+			selected,
+			sides: st.sides,
+			revealed: st.revealed,
+			visited: st.visited,
+			exploredAll: toVisit.every((id) => st.visited.includes(id)),
+			reason: sideReason(selected)
+		};
+	},
+	goals: {
+		explored: (r) => r.exploredAll,
+		sidesSeen: (r) => r.sides,
+		found: (r) => r.revealed
+	},
+	witness: (s) => ({
+		selected: s.terms[s.terms.length - 1].id,
+		visited: s.terms.map((t) => t.id),
+		sides: true,
+		revealed: true
+	}),
+	describe: (s, st, r) => {
+		const money = (v) => formatMoney(v, { currency: s.currency });
+		const shown = (t) => t.value === undefined ? t.label : t.hidden && !st.revealed ? `${t.label} ?` : `${t.label} ${money(t.value)}`;
+		const left = s.terms.filter((t) => t.position === "left").map(shown);
+		const right = s.terms.filter((t) => t.position !== "left").map((t, i) => `${i === 0 ? "" : t.position === "subtracted" ? "minus " : "plus "}${shown(t)}`);
+		const side = st.sides ? ` ${r.selected.label} grows on the ${r.selected.grows} side.` : "";
+		return `${left.join(" ")} equals ${right.join(" ")}. Selected: ${r.selected.label}.${side}`;
+	}
+});
+
+//#endregion
+export { equationMapModel, equationMapParamsSchema, sideReason };

package/dist/domains/accounting/equation-map/runtime.mjs

@@ -0,0 +1,23 @@
+'use client';
+
+import { useLab } from "../../../runtime/use-lab.mjs";
+import { AuthoredActivityRuntime } from "../../../kit/authored-activity-runtime.mjs";
+import { equationMapModel } from "./model.mjs";
+import { equationMapActivity } from "./activity.mjs";
+import { EquationMapScene } from "./scene.mjs";
+import { jsx } from "react/jsx-runtime";
+
+//#region src/domains/accounting/equation-map/runtime.tsx
+function EquationMap(props) {
+	const lab = useLab(equationMapModel, props);
+	return /* @__PURE__ */ jsx(AuthoredActivityRuntime, {
+		lab,
+		activity: equationMapActivity,
+		layout: "stack",
+		sceneLabel: "The accounting equation with this lesson's part lit",
+		children: /* @__PURE__ */ jsx(EquationMapScene, {})
+	});
+}
+
+//#endregion
+export { EquationMap as default };