@classytic/labs 0.1.0 → 0.3.0

package/dist/kit/activity-authoring.d.mts

@@ -0,0 +1,117 @@
+import { LearningPhase, LearningSequenceStep } from "./learning-sequence.mjs";
+
+//#region src/kit/activity-authoring.d.ts
+type ActivityPattern = 'optimization' | 'diagnosis' | 'allocation' | 'scenario' | 'forecast' | 'investigation' | 'construction';
+type SuccessOperator = 'eq' | 'neq' | 'gte' | 'lte' | 'between' | 'contains';
+interface AuthoredChoice {
+  value: string;
+  label: string;
+  feedback?: string;
+}
+interface AuthoredQuestionBase {
+  id: string;
+  prompt: string;
+  explain?: string;
+  tryAgain?: string;
+}
+interface AuthoredChoiceQuestion extends AuthoredQuestionBase {
+  kind?: 'choice';
+  choices: AuthoredChoice[];
+  answer: string;
+}
+interface AuthoredNumericQuestion extends AuthoredQuestionBase {
+  kind: 'numeric';
+  answer: number;
+  tolerance?: number;
+  unit?: string;
+}
+interface AuthoredTextQuestion extends AuthoredQuestionBase {
+  kind: 'text';
+  answers: string[];
+  caseSensitive?: boolean;
+}
+interface AuthoredOrderingQuestion extends AuthoredQuestionBase {
+  kind: 'ordering';
+  items: AuthoredChoice[];
+  answer: string[];
+}
+interface AuthoredReflectionQuestion extends Omit<AuthoredQuestionBase, 'tryAgain'> {
+  kind: 'reflection';
+  rubric: string[];
+  placeholder?: string;
+}
+type AuthoredQuestion = AuthoredChoiceQuestion | AuthoredNumericQuestion | AuthoredTextQuestion | AuthoredOrderingQuestion | AuthoredReflectionQuestion;
+interface AuthoredSuccessCondition {
+  id: string;
+  source: 'answer' | 'action' | 'metric' | 'reflection';
+  key: string;
+  operator?: SuccessOperator;
+  value?: string | number | boolean;
+  min?: number;
+  max?: number;
+  pendingLabel?: string;
+}
+interface AuthoredDataset {
+  id: string;
+  label: string;
+  description?: string;
+  records: Record<string, string | number | boolean>[];
+}
+interface AuthoredActivityStep {
+  id: string;
+  phase: LearningPhase;
+  title: string;
+  lead?: string;
+  reveal?: string[];
+  controls?: boolean;
+  success?: string;
+  next?: string;
+}
+interface AuthoredTransferCase {
+  id: string;
+  title: string;
+  prompt: string;
+  dataset?: string;
+  overrides?: Record<string, string | number | boolean>;
+}
+/** Serializable teaching contract. Domain engines continue to own their scene and model. */
+interface AuthoredActivity {
+  pattern: ActivityPattern;
+  title?: string;
+  objectives: string[];
+  steps: AuthoredActivityStep[];
+  questions?: AuthoredQuestion[];
+  success?: AuthoredSuccessCondition[];
+  datasets?: AuthoredDataset[];
+  transfer?: AuthoredTransferCase[];
+}
+/**
+ * Serializable execution plan derived from author-facing activity data.
+ *
+ * The source remains readable and portable while runtime-only lookups are
+ * compiled once. Numeric indexes avoid duplicating question and condition
+ * objects when a plan is serialized by an authoring or build tool.
+ */
+interface CompiledAuthoredActivity {
+  readonly kind: 'classytic.activity-plan';
+  readonly version: 1;
+  readonly source: AuthoredActivity;
+  readonly steps: readonly LearningSequenceStep[];
+  readonly successIndex: Readonly<Record<string, number>>;
+  readonly questionIndex: Readonly<Record<string, number>>;
+}
+/** Compile author data into runtime steps; condition evaluation remains domain-owned. */
+declare function activitySteps(activity: Pick<AuthoredActivity, 'steps' | 'success'>): LearningSequenceStep[];
+declare function isCompiledAuthoredActivity(value: AuthoredActivity | CompiledAuthoredActivity): value is CompiledAuthoredActivity;
+/**
+ * Compile validated author data outside React's render path. This function is
+ * intentionally independent of Zod so learner bundles do not pay for the
+ * authoring validator. Use `authoredActivitySchema` at author/build boundaries.
+ */
+declare function compileAuthoredActivity(activity: AuthoredActivity | CompiledAuthoredActivity): CompiledAuthoredActivity;
+/** Apply host objectives without mutating a shared plan or leaving compiled source stale. */
+declare function withAuthoredObjectives(activity: AuthoredActivity | CompiledAuthoredActivity, objectives?: string[]): AuthoredActivity | CompiledAuthoredActivity;
+/** Define and precompile a static activity next to its domain model. */
+declare const defineAuthoredActivity: typeof compileAuthoredActivity;
+//#endregion
+export { ActivityPattern, AuthoredActivity, AuthoredActivityStep, AuthoredChoice, AuthoredChoiceQuestion, AuthoredDataset, AuthoredNumericQuestion, AuthoredOrderingQuestion, AuthoredQuestion, AuthoredReflectionQuestion, AuthoredSuccessCondition, AuthoredTextQuestion, AuthoredTransferCase, CompiledAuthoredActivity, SuccessOperator, activitySteps, compileAuthoredActivity, defineAuthoredActivity, isCompiledAuthoredActivity, withAuthoredObjectives };

package/dist/kit/activity-authoring.mjs

@@ -0,0 +1,56 @@
+//#region src/kit/activity-authoring.ts
+/** Compile author data into runtime steps; condition evaluation remains domain-owned. */
+function activitySteps(activity) {
+	const conditions = new Map((activity.success ?? []).map((condition) => [condition.id, condition]));
+	return activity.steps.map((step) => {
+		const condition = step.success ? conditions.get(step.success) : void 0;
+		return {
+			id: step.id,
+			phase: step.phase,
+			title: step.title,
+			...step.lead ? { lead: step.lead } : {},
+			...step.reveal ? { reveal: step.reveal } : {},
+			...step.controls != null ? { controls: step.controls } : {},
+			...step.next ? { next: step.next } : {},
+			...condition ? { gate: {
+				kind: condition.source === "metric" ? "state" : condition.source,
+				id: condition.id,
+				...condition.pendingLabel ? { pendingLabel: condition.pendingLabel } : {}
+			} } : {}
+		};
+	});
+}
+function isCompiledAuthoredActivity(value) {
+	return "kind" in value && value.kind === "classytic.activity-plan" && value.version === 1;
+}
+/**
+* Compile validated author data outside React's render path. This function is
+* intentionally independent of Zod so learner bundles do not pay for the
+* authoring validator. Use `authoredActivitySchema` at author/build boundaries.
+*/
+function compileAuthoredActivity(activity) {
+	if (isCompiledAuthoredActivity(activity)) return activity;
+	const successIndex = Object.fromEntries((activity.success ?? []).map((condition, index) => [condition.id, index]));
+	const questionIndex = Object.fromEntries((activity.questions ?? []).map((question, index) => [question.id, index]));
+	return Object.freeze({
+		kind: "classytic.activity-plan",
+		version: 1,
+		source: activity,
+		steps: Object.freeze(activitySteps(activity).map((step) => Object.freeze(step))),
+		successIndex: Object.freeze(successIndex),
+		questionIndex: Object.freeze(questionIndex)
+	});
+}
+/** Apply host objectives without mutating a shared plan or leaving compiled source stale. */
+function withAuthoredObjectives(activity, objectives) {
+	if (!objectives) return activity;
+	return {
+		...isCompiledAuthoredActivity(activity) ? activity.source : activity,
+		objectives
+	};
+}
+/** Define and precompile a static activity next to its domain model. */
+const defineAuthoredActivity = compileAuthoredActivity;
+
+//#endregion
+export { activitySteps, compileAuthoredActivity, defineAuthoredActivity, isCompiledAuthoredActivity, withAuthoredObjectives };

package/dist/kit/activity.d.mts

@@ -0,0 +1,147 @@
+import { HTMLAttributes, ReactNode, Ref } from "react";
+
+//#region src/kit/activity.d.ts
+interface ActivityRootProps extends HTMLAttributes<HTMLDivElement> {
+  children: ReactNode;
+  /** Large-screen composition intent. Defaults to a balanced reading layout. */
+  focusLayout?: 'compact' | 'standard' | 'immersive';
+}
+declare function Header({
+  children
+}: {
+  children: ReactNode;
+}): ReactNode;
+declare function Heading({
+  eyebrow,
+  title,
+  description
+}: {
+  eyebrow?: ReactNode;
+  title: ReactNode;
+  description?: ReactNode;
+}): ReactNode;
+declare function FocusButton(): ReactNode;
+declare function Status({
+  children
+}: {
+  children: ReactNode;
+}): ReactNode;
+declare function Workspace({
+  children
+}: {
+  children: ReactNode;
+}): ReactNode;
+declare function Canvas({
+  children,
+  label
+}: {
+  children: ReactNode;
+  label?: string;
+}): ReactNode;
+declare function Dock({
+  children
+}: {
+  children: ReactNode;
+}): ReactNode;
+declare function Inspector({
+  children,
+  label,
+  defaultOpen,
+  responsive
+}: {
+  children: ReactNode;
+  label?: string;
+  defaultOpen?: boolean; /** Automatically opens at wide activity widths until the learner makes a choice. */
+  responsive?: boolean;
+}): ReactNode;
+/**
+ * Canonical content boundary inside an Inspector.
+ *
+ * Inspector owns disclosure and framing; InspectorSection owns its interior rhythm. Keeping
+ * those responsibilities separate lets host shadcn controls retain their own sizing without
+ * every lab inventing margins around them.
+ */
+declare function InspectorSection({
+  children,
+  className
+}: {
+  children: ReactNode;
+  className?: string;
+}): ReactNode;
+declare function Feedback({
+  children
+}: {
+  children: ReactNode;
+}): ReactNode;
+declare function Transport({
+  children
+}: {
+  children: ReactNode;
+}): ReactNode;
+declare function Progress({
+  value,
+  max,
+  label,
+  onChange
+}: {
+  value: number;
+  max: number;
+  label?: ReactNode;
+  onChange?: (value: number) => void;
+}): ReactNode;
+/** Compact progress for finite decks or repeated practice items. */
+declare function ItemProgress({
+  done,
+  total,
+  label,
+  segmentedMax
+}: {
+  done: number;
+  total: number;
+  label?: string;
+  segmentedMax?: number;
+}): ReactNode;
+declare function Transcript({
+  children,
+  label,
+  defaultOpen
+}: {
+  children: ReactNode;
+  label?: string;
+  defaultOpen?: boolean;
+}): ReactNode;
+declare function LiveRegion({
+  children
+}: {
+  children: ReactNode;
+}): ReactNode;
+declare const Activity: {
+  Root: ({
+    children,
+    className,
+    ref: forwardedRef,
+    role,
+    tabIndex,
+    focusLayout,
+    ...props
+  }: ActivityRootProps & {
+    ref?: Ref<HTMLDivElement>;
+  }) => ReactNode;
+  Header: typeof Header;
+  Heading: typeof Heading;
+  FocusButton: typeof FocusButton;
+  Status: typeof Status;
+  Workspace: typeof Workspace;
+  Canvas: typeof Canvas;
+  Dock: typeof Dock;
+  Inspector: typeof Inspector;
+  InspectorSection: typeof InspectorSection;
+  Feedback: typeof Feedback;
+  Transport: typeof Transport;
+  Progress: typeof Progress;
+  ItemProgress: typeof ItemProgress;
+  Transcript: typeof Transcript;
+  LiveRegion: typeof LiveRegion;
+};
+//#endregion
+export { Activity, ActivityRootProps };

package/dist/kit/activity.mjs

@@ -0,0 +1,374 @@
+'use client';
+
+import { ActionButton, IconButton, Slider } from "./controls.mjs";
+import { useLabEmbed } from "./embed.mjs";
+import { createContext, useContext, useEffect, useRef, useState } from "react";
+import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
+import { Button } from "@/components/ui/button";
+import { Pause, Play, RotateCcw, StepForward } from "lucide-react";
+
+//#region src/kit/activity.tsx
+const ActivityContext = createContext(null);
+const useActivity = () => {
+	const value = useContext(ActivityContext);
+	if (!value) throw new Error("Activity compound components must be used inside Activity.Root");
+	return value;
+};
+const Root = function Root({ children, className, ref: forwardedRef, role, tabIndex, focusLayout = "standard", ...props }) {
+	const rootRef = useRef(null);
+	const restoreFocusRef = useRef(null);
+	const [focused, setFocused] = useState(false);
+	const [nativeFullscreen, setNativeFullscreen] = useState(false);
+	useEffect(() => {
+		const onFullscreenChange = () => {
+			const active = document.fullscreenElement === rootRef.current;
+			setNativeFullscreen(active);
+			if (!active && document.fullscreenElement == null) setFocused(false);
+		};
+		document.addEventListener("fullscreenchange", onFullscreenChange);
+		return () => document.removeEventListener("fullscreenchange", onFullscreenChange);
+	}, []);
+	useEffect(() => {
+		if (!focused || nativeFullscreen) return;
+		const previous = document.body.style.overflow;
+		restoreFocusRef.current = document.activeElement instanceof HTMLElement ? document.activeElement : null;
+		const root = rootRef.current;
+		document.body.style.overflow = "hidden";
+		root?.focus({ preventScroll: true });
+		const onKeyDown = (event) => {
+			if (event.key === "Escape") {
+				event.preventDefault();
+				setFocused(false);
+				return;
+			}
+			if (event.key !== "Tab" || !root) return;
+			const focusable = Array.from(root.querySelectorAll("button:not(:disabled), [href], input:not(:disabled), select:not(:disabled), textarea:not(:disabled), summary, [tabindex]:not([tabindex=\"-1\"])")).filter((element) => !element.hidden && element.getClientRects().length > 0);
+			if (focusable.length === 0) {
+				event.preventDefault();
+				root.focus();
+				return;
+			}
+			const first = focusable[0];
+			const last = focusable.at(-1);
+			if (event.shiftKey && (document.activeElement === first || document.activeElement === root)) {
+				event.preventDefault();
+				last.focus();
+			} else if (!event.shiftKey && document.activeElement === root) {
+				event.preventDefault();
+				first.focus();
+			} else if (!event.shiftKey && document.activeElement === last) {
+				event.preventDefault();
+				first.focus();
+			}
+		};
+		window.addEventListener("keydown", onKeyDown);
+		return () => {
+			document.body.style.overflow = previous;
+			window.removeEventListener("keydown", onKeyDown);
+			restoreFocusRef.current?.focus({ preventScroll: true });
+			restoreFocusRef.current = null;
+		};
+	}, [focused, nativeFullscreen]);
+	const toggleFocus = async () => {
+		if (nativeFullscreen && document.fullscreenElement) {
+			await document.exitFullscreen();
+			return;
+		}
+		if (focused) {
+			setFocused(false);
+			return;
+		}
+		if (rootRef.current?.requestFullscreen) try {
+			await rootRef.current.requestFullscreen();
+			setFocused(true);
+			return;
+		} catch {}
+		setFocused(true);
+	};
+	return /* @__PURE__ */ jsx(ActivityContext.Provider, {
+		value: {
+			focused,
+			toggleFocus
+		},
+		children: /* @__PURE__ */ jsx("div", {
+			ref: (node) => {
+				rootRef.current = node;
+				if (typeof forwardedRef === "function") forwardedRef(node);
+				else if (forwardedRef && "current" in forwardedRef) forwardedRef.current = node;
+			},
+			className: ["not-prose lab-activity", className].filter(Boolean).join(" "),
+			"data-focus": focused || void 0,
+			"data-focus-layout": focusLayout,
+			...props,
+			role: focused && !nativeFullscreen ? "dialog" : role,
+			"aria-modal": focused && !nativeFullscreen ? true : void 0,
+			tabIndex: focused && !nativeFullscreen ? -1 : tabIndex,
+			children
+		})
+	});
+};
+function Header({ children }) {
+	return /* @__PURE__ */ jsx("header", {
+		className: "lab-activity-header",
+		children
+	});
+}
+function Heading({ eyebrow, title, description }) {
+	if (useLabEmbed()) return /* @__PURE__ */ jsxs("div", {
+		className: "lab-activity-heading",
+		"data-embedded": "true",
+		children: [/* @__PURE__ */ jsx("h3", {
+			className: "lab-sr-only",
+			children: title
+		}), description && /* @__PURE__ */ jsx("div", {
+			className: "lab-activity-description",
+			children: description
+		})]
+	});
+	return /* @__PURE__ */ jsxs("div", {
+		className: "lab-activity-heading",
+		children: [
+			eyebrow && /* @__PURE__ */ jsx("span", {
+				className: "lab-activity-eyebrow",
+				children: eyebrow
+			}),
+			/* @__PURE__ */ jsx("h3", { children: title }),
+			description && /* @__PURE__ */ jsx("div", {
+				className: "lab-activity-description",
+				children: description
+			})
+		]
+	});
+}
+function FocusButton() {
+	const { focused, toggleFocus } = useActivity();
+	return /* @__PURE__ */ jsxs(Button, {
+		className: "lab-activity-focus",
+		size: "sm",
+		variant: "outline",
+		type: "button",
+		onClick: toggleFocus,
+		"aria-label": focused ? "Exit focused lab" : "Open focused lab",
+		"aria-pressed": focused,
+		children: [/* @__PURE__ */ jsx("svg", {
+			viewBox: "0 0 24 24",
+			"aria-hidden": "true",
+			children: /* @__PURE__ */ jsx("path", { d: focused ? "M9 4v5H4m11-5v5h5M9 20v-5H4m11 5v-5h5" : "M8 3H3v5m13-5h5v5M8 21H3v-5m13 5h5v-5" })
+		}), /* @__PURE__ */ jsx("span", { children: focused ? "Exit focus" : "Focus mode" })]
+	});
+}
+function Status({ children }) {
+	return /* @__PURE__ */ jsx("div", {
+		className: "lab-activity-status",
+		role: "status",
+		"aria-live": "polite",
+		"aria-atomic": "false",
+		children
+	});
+}
+function Workspace({ children }) {
+	return /* @__PURE__ */ jsx("div", {
+		className: "lab-activity-workspace",
+		children
+	});
+}
+function Canvas({ children, label }) {
+	return /* @__PURE__ */ jsx("section", {
+		className: "lab-activity-canvas",
+		"aria-label": label,
+		children
+	});
+}
+function Dock({ children }) {
+	return /* @__PURE__ */ jsx("section", {
+		className: "lab-activity-dock",
+		"aria-label": "Model controls",
+		children
+	});
+}
+function Inspector({ children, label = "Inspector", defaultOpen, responsive = true }) {
+	const ref = useRef(null);
+	const userChoice = useRef(false);
+	useEffect(() => {
+		if (!responsive) return;
+		const details = ref.current;
+		const activity = details?.closest(".lab-activity");
+		if (!details || !activity) return;
+		const sync = () => {
+			if (!userChoice.current) details.open = activity.getBoundingClientRect().width >= 960;
+		};
+		sync();
+		const observer = new ResizeObserver(sync);
+		observer.observe(activity);
+		return () => observer.disconnect();
+	}, [responsive]);
+	return /* @__PURE__ */ jsxs("details", {
+		ref,
+		className: "lab-activity-inspector",
+		open: defaultOpen,
+		children: [/* @__PURE__ */ jsx("summary", {
+			onClick: () => {
+				userChoice.current = true;
+			},
+			onKeyDown: (event) => {
+				if (event.key === "Enter" || event.key === " ") userChoice.current = true;
+			},
+			children: label
+		}), /* @__PURE__ */ jsx("div", {
+			className: "lab-activity-inspector-body",
+			children
+		})]
+	});
+}
+/**
+* Canonical content boundary inside an Inspector.
+*
+* Inspector owns disclosure and framing; InspectorSection owns its interior rhythm. Keeping
+* those responsibilities separate lets host shadcn controls retain their own sizing without
+* every lab inventing margins around them.
+*/
+function InspectorSection({ children, className }) {
+	return /* @__PURE__ */ jsx("div", {
+		className: ["lab-activity-inspector-section", className].filter(Boolean).join(" "),
+		children
+	});
+}
+function Feedback({ children }) {
+	return /* @__PURE__ */ jsx("div", {
+		className: "lab-activity-feedback",
+		children
+	});
+}
+function Transport({ children }) {
+	return /* @__PURE__ */ jsx("footer", {
+		className: "lab-activity-transport",
+		children
+	});
+}
+function Progress({ value, max, label, onChange }) {
+	return /* @__PURE__ */ jsxs("div", {
+		className: "lab-activity-progress",
+		children: [/* @__PURE__ */ jsx("div", { children: label ?? /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsxs("strong", { children: ["Step ", value] }), /* @__PURE__ */ jsxs("span", { children: ["of ", max] })] }) }), onChange ? /* @__PURE__ */ jsx(Slider, {
+			min: 1,
+			max,
+			step: 1,
+			value,
+			onChange,
+			ariaLabel: `Choose step, currently ${value} of ${max}`
+		}) : /* @__PURE__ */ jsx("progress", {
+			value,
+			max,
+			"aria-label": `Step ${value} of ${max}`
+		})]
+	});
+}
+/** Compact progress for finite decks or repeated practice items. */
+function ItemProgress({ done, total, label = "Done", segmentedMax = 8 }) {
+	if (total <= 0) return null;
+	const clamped = Math.max(0, Math.min(total, done));
+	if (clamped >= total) return /* @__PURE__ */ jsxs("span", {
+		className: "lab-progress",
+		"data-complete": "true",
+		role: "status",
+		"aria-label": `${label}, ${total} of ${total}`,
+		children: [
+			/* @__PURE__ */ jsx("span", {
+				className: "lab-progress-check",
+				"aria-hidden": true,
+				children: "✓"
+			}),
+			" ",
+			label
+		]
+	});
+	return /* @__PURE__ */ jsxs("span", {
+		className: "lab-progress",
+		role: "group",
+		"aria-label": `step ${clamped} of ${total}`,
+		children: [total <= segmentedMax ? /* @__PURE__ */ jsx("span", {
+			className: "lab-progress-segs",
+			"aria-hidden": true,
+			children: Array.from({ length: total }, (_, index) => /* @__PURE__ */ jsx("span", {
+				className: "lab-progress-seg",
+				"data-on": index < clamped ? "true" : void 0
+			}, index))
+		}) : /* @__PURE__ */ jsx("span", {
+			className: "lab-progress-bar",
+			"aria-hidden": true,
+			children: /* @__PURE__ */ jsx("span", {
+				className: "lab-progress-bar-fill",
+				style: { width: `${clamped / total * 100}%` }
+			})
+		}), /* @__PURE__ */ jsxs("span", {
+			className: "lab-progress-count",
+			children: [
+				clamped,
+				" / ",
+				total
+			]
+		})]
+	});
+}
+function Transcript({ children, label = "Event transcript", defaultOpen = false }) {
+	return /* @__PURE__ */ jsxs("details", {
+		className: "lab-activity-transcript",
+		open: defaultOpen || void 0,
+		children: [/* @__PURE__ */ jsx("summary", { children: label }), children]
+	});
+}
+function LiveRegion({ children }) {
+	return /* @__PURE__ */ jsx("div", {
+		"aria-live": "polite",
+		className: "lab-sr-only",
+		children
+	});
+}
+/** Shared reset/step/state/run transport for simulations and iterative models. */
+function RunTransport({ running, onReset, onToggle, onStep, state, detail, disabled, resetLabel = "Reset activity", stepLabel = "Take one step", runLabel = "Run" }) {
+	return /* @__PURE__ */ jsxs(Fragment$1, { children: [
+		/* @__PURE__ */ jsx(IconButton, {
+			label: resetLabel,
+			onClick: onReset,
+			children: /* @__PURE__ */ jsx(RotateCcw, { "aria-hidden": "true" })
+		}),
+		onStep ? /* @__PURE__ */ jsx(IconButton, {
+			label: stepLabel,
+			onClick: onStep,
+			disabled,
+			children: /* @__PURE__ */ jsx(StepForward, { "aria-hidden": "true" })
+		}) : null,
+		/* @__PURE__ */ jsxs("div", {
+			className: "lab-transport-state",
+			"aria-live": "polite",
+			children: [/* @__PURE__ */ jsx("strong", { children: state }), detail ? /* @__PURE__ */ jsx("span", { children: detail }) : null]
+		}),
+		/* @__PURE__ */ jsxs(ActionButton, {
+			className: "lab-primary-action",
+			onClick: onToggle,
+			pressed: running,
+			disabled,
+			children: [running ? /* @__PURE__ */ jsx(Pause, { "aria-hidden": "true" }) : /* @__PURE__ */ jsx(Play, { "aria-hidden": "true" }), running ? "Pause" : runLabel]
+		})
+	] });
+}
+const Activity = {
+	Root,
+	Header,
+	Heading,
+	FocusButton,
+	Status,
+	Workspace,
+	Canvas,
+	Dock,
+	Inspector,
+	InspectorSection,
+	Feedback,
+	Transport,
+	Progress,
+	ItemProgress,
+	Transcript,
+	LiveRegion
+};
+
+//#endregion
+export { Activity, RunTransport };