@classytic/labs 0.1.0 → 0.3.0

package/dist/schemas/activity-authoring.mjs

@@ -0,0 +1,316 @@
+import { z } from "zod";
+
+//#region src/schemas/activity-authoring.ts
+const scalar = z.union([
+	z.string(),
+	z.number(),
+	z.boolean()
+]);
+const authoredText = z.string().trim().min(1);
+const activityPatternSchema = z.enum([
+	"optimization",
+	"diagnosis",
+	"allocation",
+	"scenario",
+	"forecast",
+	"investigation",
+	"construction"
+]);
+const authoredChoiceSchema = z.object({
+	value: authoredText,
+	label: authoredText,
+	feedback: authoredText.optional()
+});
+const choiceQuestionSchema = z.object({
+	kind: z.literal("choice").optional(),
+	id: authoredText,
+	prompt: authoredText,
+	choices: z.array(authoredChoiceSchema).min(2),
+	answer: authoredText,
+	explain: authoredText.optional(),
+	tryAgain: authoredText.optional()
+}).superRefine((question, context) => {
+	if (!question.choices.some((choice) => choice.value === question.answer)) context.addIssue({
+		code: "custom",
+		path: ["answer"],
+		message: "answer must match a choice value"
+	});
+});
+const numericQuestionSchema = z.object({
+	kind: z.literal("numeric"),
+	id: authoredText,
+	prompt: authoredText,
+	answer: z.number(),
+	tolerance: z.number().nonnegative().default(0),
+	unit: authoredText.optional(),
+	explain: authoredText.optional(),
+	tryAgain: authoredText.optional()
+});
+const textQuestionSchema = z.object({
+	kind: z.literal("text"),
+	id: authoredText,
+	prompt: authoredText,
+	answers: z.array(authoredText).min(1),
+	caseSensitive: z.boolean().default(false),
+	explain: authoredText.optional(),
+	tryAgain: authoredText.optional()
+});
+const orderingQuestionSchema = z.object({
+	kind: z.literal("ordering"),
+	id: authoredText,
+	prompt: authoredText,
+	items: z.array(authoredChoiceSchema).min(2),
+	answer: z.array(authoredText).min(2),
+	explain: authoredText.optional(),
+	tryAgain: authoredText.optional()
+}).superRefine((question, context) => {
+	const values = new Set(question.items.map((item) => item.value));
+	if (question.answer.length !== values.size || question.answer.some((value) => !values.has(value)) || new Set(question.answer).size !== question.answer.length) context.addIssue({
+		code: "custom",
+		path: ["answer"],
+		message: "answer must order every item exactly once"
+	});
+});
+const reflectionQuestionSchema = z.object({
+	kind: z.literal("reflection"),
+	id: authoredText,
+	prompt: authoredText,
+	rubric: z.array(authoredText).min(1),
+	placeholder: authoredText.optional(),
+	explain: authoredText.optional()
+});
+/** Backward-compatible choice questions plus richer community-authorable response shapes. */
+const authoredQuestionSchema = z.union([
+	choiceQuestionSchema,
+	numericQuestionSchema,
+	textQuestionSchema,
+	orderingQuestionSchema,
+	reflectionQuestionSchema
+]);
+const authoredSuccessSchema = z.object({
+	id: authoredText,
+	source: z.enum([
+		"answer",
+		"action",
+		"metric",
+		"reflection"
+	]),
+	key: authoredText,
+	operator: z.enum([
+		"eq",
+		"neq",
+		"gte",
+		"lte",
+		"between",
+		"contains"
+	]).optional(),
+	value: scalar.optional(),
+	min: z.number().optional(),
+	max: z.number().optional(),
+	pendingLabel: authoredText.optional()
+});
+const authoredDatasetSchema = z.object({
+	id: authoredText,
+	label: authoredText,
+	description: authoredText.optional(),
+	records: z.array(z.record(z.string(), scalar))
+});
+const authoredActivityStepSchema = z.object({
+	id: authoredText,
+	phase: z.enum([
+		"predict",
+		"act",
+		"observe",
+		"explain",
+		"transfer"
+	]),
+	title: authoredText,
+	lead: authoredText.optional(),
+	reveal: z.array(authoredText).optional(),
+	controls: z.boolean().optional(),
+	success: authoredText.optional(),
+	next: authoredText.optional()
+});
+const authoredTransferCaseSchema = z.object({
+	id: authoredText,
+	title: authoredText,
+	prompt: authoredText,
+	dataset: authoredText.optional(),
+	overrides: z.record(z.string(), scalar).optional()
+});
+const authoredActivitySchema = z.object({
+	pattern: activityPatternSchema,
+	title: authoredText.optional(),
+	objectives: z.array(authoredText).min(1),
+	steps: z.array(authoredActivityStepSchema).min(1),
+	questions: z.array(authoredQuestionSchema).optional(),
+	success: z.array(authoredSuccessSchema).optional(),
+	datasets: z.array(authoredDatasetSchema).optional(),
+	transfer: z.array(authoredTransferCaseSchema).optional()
+}).superRefine((activity, context) => {
+	const requireUniqueIds = (items, path) => {
+		const seen = /* @__PURE__ */ new Set();
+		(items ?? []).forEach((item, index) => {
+			if (seen.has(item.id)) context.addIssue({
+				code: "custom",
+				path: [
+					path,
+					index,
+					"id"
+				],
+				message: `${path} ids must be unique`
+			});
+			seen.add(item.id);
+		});
+	};
+	requireUniqueIds(activity.steps, "steps");
+	requireUniqueIds(activity.questions, "questions");
+	requireUniqueIds(activity.success, "success");
+	requireUniqueIds(activity.datasets, "datasets");
+	requireUniqueIds(activity.transfer, "transfer");
+	const requireUniqueText = (items, path) => {
+		const seen = /* @__PURE__ */ new Set();
+		items.forEach((item, index) => {
+			const key = item.toLocaleLowerCase();
+			if (seen.has(key)) context.addIssue({
+				code: "custom",
+				path: [path, index],
+				message: `${path} must not repeat the same text`
+			});
+			seen.add(key);
+		});
+	};
+	requireUniqueText(activity.objectives, "objectives");
+	const prompts = /* @__PURE__ */ new Set();
+	(activity.questions ?? []).forEach((question, index) => {
+		const prompt = question.prompt.toLocaleLowerCase();
+		if (prompts.has(prompt)) context.addIssue({
+			code: "custom",
+			path: [
+				"questions",
+				index,
+				"prompt"
+			],
+			message: "question prompts must not repeat"
+		});
+		prompts.add(prompt);
+	});
+	const ids = new Set(activity.steps.map((step) => step.id));
+	const success = new Set((activity.success ?? []).map((condition) => condition.id));
+	const datasets = new Set((activity.datasets ?? []).map((dataset) => dataset.id));
+	const questions = new Map((activity.questions ?? []).map((question) => [question.id, question]));
+	activity.steps.forEach((step, index) => {
+		if (step.next && !ids.has(step.next)) context.addIssue({
+			code: "custom",
+			path: [
+				"steps",
+				index,
+				"next"
+			],
+			message: "next must reference a step id"
+		});
+		if (step.success && !success.has(step.success)) context.addIssue({
+			code: "custom",
+			path: [
+				"steps",
+				index,
+				"success"
+			],
+			message: "success must reference a condition id"
+		});
+	});
+	const referencedSuccess = new Set(activity.steps.flatMap((step) => step.success ? [step.success] : []));
+	(activity.success ?? []).forEach((condition, index) => {
+		if (!referencedSuccess.has(condition.id)) context.addIssue({
+			code: "custom",
+			path: [
+				"success",
+				index,
+				"id"
+			],
+			message: "success condition must be used by a step"
+		});
+	});
+	(activity.success ?? []).forEach((condition, index) => {
+		if (condition.source !== "answer" && condition.source !== "reflection") return;
+		const question = questions.get(condition.key);
+		if (!question) {
+			context.addIssue({
+				code: "custom",
+				path: [
+					"success",
+					index,
+					"key"
+				],
+				message: `${condition.source} must reference a question id`
+			});
+			return;
+		}
+		const reflection = question.kind === "reflection";
+		if (condition.source === "reflection" && !reflection) context.addIssue({
+			code: "custom",
+			path: [
+				"success",
+				index,
+				"key"
+			],
+			message: "reflection must reference a reflection question"
+		});
+		if (condition.source === "answer" && reflection) context.addIssue({
+			code: "custom",
+			path: [
+				"success",
+				index,
+				"key"
+			],
+			message: "answer must reference a scored question"
+		});
+	});
+	const referencedQuestions = new Set((activity.success ?? []).flatMap((condition) => condition.source === "answer" || condition.source === "reflection" ? [condition.key] : []));
+	(activity.questions ?? []).forEach((question, index) => {
+		if (!referencedQuestions.has(question.id)) context.addIssue({
+			code: "custom",
+			path: [
+				"questions",
+				index,
+				"id"
+			],
+			message: "question must be connected to an answer or reflection success condition"
+		});
+	});
+	if (activity.steps.length > 0) {
+		const byId = new Map(activity.steps.map((step, index) => [step.id, index]));
+		const reachable = /* @__PURE__ */ new Set();
+		let position = 0;
+		while (position != null && !reachable.has(position)) {
+			reachable.add(position);
+			const step = activity.steps[position];
+			position = step.next ? byId.get(step.next) : position + 1 < activity.steps.length ? position + 1 : void 0;
+		}
+		activity.steps.forEach((_step, index) => {
+			if (!reachable.has(index)) context.addIssue({
+				code: "custom",
+				path: [
+					"steps",
+					index,
+					"id"
+				],
+				message: "step is unreachable from the first step"
+			});
+		});
+	}
+	(activity.transfer ?? []).forEach((item, index) => {
+		if (item.dataset && !datasets.has(item.dataset)) context.addIssue({
+			code: "custom",
+			path: [
+				"transfer",
+				index,
+				"dataset"
+			],
+			message: "dataset must reference a dataset id"
+		});
+	});
+});
+
+//#endregion
+export { activityPatternSchema, authoredActivitySchema, authoredActivityStepSchema, authoredChoiceSchema, authoredDatasetSchema, authoredQuestionSchema, authoredSuccessSchema, authoredTransferCaseSchema };

package/dist/schemas/index.d.mts

@@ -1,3 +1,4 @@
+import { activityPatternSchema, authoredActivitySchema, authoredActivityStepSchema, authoredChoiceSchema, authoredDatasetSchema, authoredQuestionSchema, authoredSuccessSchema, authoredTransferCaseSchema } from "./activity-authoring.mjs";
 import { z } from "zod";
 
 //#region src/schemas/index.d.ts
@@ -14,27 +15,29 @@ declare const posSchema: z.ZodEnum<{
 }>;
 declare const relationSchema: z.ZodEnum<{
   in: "in";
-  at: "at";
-  between: "between";
   on: "on";
   over: "over";
   above: "above";
   under: "under";
   below: "below";
   beside: "beside";
+  between: "between";
   behind: "behind";
   infront: "infront";
+  at: "at";
 }>;
 declare const articleAnswerSchema: z.ZodEnum<{
   a: "a";
   an: "an";
   the: "the";
-  "\u2014": "—";
+  ", ": ", ";
 }>;
 declare const vec2Schema: z.ZodObject<{
   x: z.ZodNumber;
   y: z.ZodNumber;
 }, z.core.$strip>;
+/** Practical BCP-47 guard: accepts language + optional script/region/variants. */
+declare const languageTagSchema: z.ZodString;
 /** A durable visual-asset reference (emoji / registered SVG id / image URL). */
 declare const iconRefSchema: z.ZodObject<{
   kind: z.ZodEnum<{
@@ -128,6 +131,9 @@ declare const transformTileSchema: z.ZodObject<{
   }>>;
   gloss: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
+/** Per-wrong-option feedback: maps an option the learner might wrongly pick to a
+ *  targeted correction ("why that's the classic trap"). Keys are option strings. */
+declare const feedbackSchema: z.ZodRecord<z.ZodString, z.ZodString>;
 declare const articleItemSchema: z.ZodObject<{
   before: z.ZodString;
   noun: z.ZodString;
@@ -136,9 +142,10 @@ declare const articleItemSchema: z.ZodObject<{
     a: "a";
     an: "an";
     the: "the";
-    "\u2014": "—";
+    ", ": ", ";
   }>;
   why: z.ZodOptional<z.ZodString>;
+  feedback: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
 }, z.core.$strip>;
 declare const agreementItemSchema: z.ZodObject<{
   subject: z.ZodString;
@@ -146,6 +153,7 @@ declare const agreementItemSchema: z.ZodObject<{
   correct: z.ZodString;
   tail: z.ZodOptional<z.ZodString>;
   note: z.ZodOptional<z.ZodString>;
+  feedback: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
 }, z.core.$strip>;
 declare const prepItemSchema: z.ZodObject<{
   before: z.ZodString;
@@ -154,16 +162,16 @@ declare const prepItemSchema: z.ZodObject<{
   options: z.ZodArray<z.ZodString>;
   scene: z.ZodEnum<{
     in: "in";
-    at: "at";
-    between: "between";
     on: "on";
     over: "over";
     above: "above";
     under: "under";
     below: "below";
     beside: "beside";
+    between: "between";
     behind: "behind";
     infront: "infront";
+    at: "at";
   }>;
   figure: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
     kind: z.ZodEnum<{
@@ -186,6 +194,31 @@ declare const prepItemSchema: z.ZodObject<{
     alt: z.ZodString;
   }, z.core.$strip>]>>;
   note: z.ZodOptional<z.ZodString>;
+  feedback: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>;
+declare const clozeItemSchema: z.ZodObject<{
+  text: z.ZodString;
+  answers: z.ZodArray<z.ZodString>;
+  distractors: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  why: z.ZodOptional<z.ZodString>;
+  gloss: z.ZodOptional<z.ZodString>;
+  audioUrl: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const readingQuestionSchema: z.ZodObject<{
+  q: z.ZodString;
+  options: z.ZodArray<z.ZodString>;
+  answer: z.ZodString;
+  explain: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const glossEntrySchema: z.ZodObject<{
+  word: z.ZodString;
+  meaning: z.ZodString;
+}, z.core.$strip>;
+declare const errorItemSchema: z.ZodObject<{
+  text: z.ZodString;
+  wrong: z.ZodString;
+  fix: z.ZodString;
+  why: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 declare const boardVectorSchema: z.ZodObject<{
   id: z.ZodOptional<z.ZodString>;
@@ -208,6 +241,7 @@ declare const flatVecSchema: z.ZodObject<{
   dy: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
   color: z.ZodOptional<z.ZodString>;
   drag: z.ZodOptional<z.ZodBoolean>;
+  lockMagnitude: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 declare const typePanelSchema: z.ZodObject<{
   name: z.ZodString;
@@ -232,4 +266,4 @@ declare const controlConfigSchema: z.ZodObject<{
   lock: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strip>;
 //#endregion
-export { agreementItemSchema, articleAnswerSchema, articleItemSchema, boardVectorSchema, controlConfigSchema, deckItemSchema, deckSchema, flatVecSchema, iconRefSchema, iconValueSchema, posSchema, prepItemSchema, relationSchema, sentenceTileSchema, transformTileSchema, typePanelSchema, vec2Schema };
+export { activityPatternSchema, agreementItemSchema, articleAnswerSchema, articleItemSchema, authoredActivitySchema, authoredActivityStepSchema, authoredChoiceSchema, authoredDatasetSchema, authoredQuestionSchema, authoredSuccessSchema, authoredTransferCaseSchema, boardVectorSchema, clozeItemSchema, controlConfigSchema, deckItemSchema, deckSchema, errorItemSchema, feedbackSchema, flatVecSchema, glossEntrySchema, iconRefSchema, iconValueSchema, languageTagSchema, posSchema, prepItemSchema, readingQuestionSchema, relationSchema, sentenceTileSchema, transformTileSchema, typePanelSchema, vec2Schema };

package/dist/schemas/index.mjs

@@ -1,14 +1,15 @@
+import { activityPatternSchema, authoredActivitySchema, authoredActivityStepSchema, authoredChoiceSchema, authoredDatasetSchema, authoredQuestionSchema, authoredSuccessSchema, authoredTransferCaseSchema } from "./activity-authoring.mjs";
 import { z } from "zod";
 
 //#region src/schemas/index.ts
 /**
-* @classytic/labs/schemas — the validation contract for every authorable lab.
+* @classytic/labs/schemas, the validation contract for every authorable lab.
 *
 * Real zod schemas for the lab DATA shapes (decks, tiles, items, vectors) that the
 * language + physics blocks reuse to validate authored arrays (no `z.any()`). zod is
 * isolated to this subpath + `/blocks`.
 *
-* Per-lab PROP schemas are NOT here — each lives on its own `defineBlock({ schema })`
+* Per-lab PROP schemas are NOT here, each lives on its own `defineBlock({ schema })`
 * (the single source of truth), so there's no parallel registry to drift. A consuming
 * app builds LLM tools straight from the block schemas if it wants.
 *
@@ -44,12 +45,15 @@ const articleAnswerSchema = z.enum([
 	"a",
 	"an",
 	"the",
-	"—"
+	", "
 ]);
 const vec2Schema = z.object({
 	x: z.number(),
 	y: z.number()
 });
+const nonBlankSchema = z.string().trim().min(1);
+/** Practical BCP-47 guard: accepts language + optional script/region/variants. */
+const languageTagSchema = z.string().trim().regex(/^[A-Za-z]{2,8}(?:-[A-Za-z0-9]{1,8})*$/, "Use a BCP-47 language tag such as en-US, ar, or bn-BD");
 /** A durable visual-asset reference (emoji / registered SVG id / image URL). */
 const iconRefSchema = z.object({
 	kind: z.enum([
@@ -64,8 +68,8 @@ const iconRefSchema = z.object({
 /** Back-compat union: a plain string (emoji, or a scene backdrop key) OR an IconRef. */
 const iconValueSchema = z.union([z.string(), iconRefSchema]);
 const deckItemSchema = z.object({
-	term: z.string().describe("the target-language word/phrase"),
-	translation: z.string().describe("the learner's-language meaning"),
+	term: nonBlankSchema.describe("the target-language word/phrase"),
+	translation: nonBlankSchema.describe("the learner's-language meaning"),
 	transliteration: z.string().optional(),
 	audioUrl: z.string().optional().describe("uploaded or external audio URL; none → browser TTS"),
 	icon: iconValueSchema.optional().describe("emoji string, or an IconRef for a registered SVG / image"),
@@ -74,39 +78,121 @@ const deckItemSchema = z.object({
 });
 const deckSchema = z.object({
 	title: z.string().optional(),
-	termLang: z.string().describe("BCP-47, e.g. en-US / ar / bn-BD"),
-	transLang: z.string().describe("BCP-47 of the translation side"),
-	items: z.array(deckItemSchema)
+	termLang: languageTagSchema.describe("BCP-47, e.g. en-US / ar / bn-BD"),
+	transLang: languageTagSchema.describe("BCP-47 of the translation side"),
+	items: z.array(deckItemSchema).min(1)
 });
 const sentenceTileSchema = z.object({
-	text: z.string(),
+	text: nonBlankSchema,
 	pos: posSchema.optional(),
 	gloss: z.string().optional()
 });
 const transformTileSchema = sentenceTileSchema;
+/** Per-wrong-option feedback: maps an option the learner might wrongly pick to a
+*  targeted correction ("why that's the classic trap"). Keys are option strings. */
+const feedbackSchema = z.record(z.string(), z.string());
 const articleItemSchema = z.object({
-	before: z.string(),
-	noun: z.string(),
+	before: nonBlankSchema,
+	noun: nonBlankSchema,
 	after: z.string().optional(),
 	answer: articleAnswerSchema,
-	why: z.string().optional()
+	why: z.string().optional(),
+	feedback: feedbackSchema.optional()
 });
 const agreementItemSchema = z.object({
-	subject: z.string(),
-	options: z.array(z.string()),
-	correct: z.string(),
+	subject: nonBlankSchema,
+	options: z.array(nonBlankSchema).min(2).max(6),
+	correct: nonBlankSchema,
 	tail: z.string().optional(),
-	note: z.string().optional()
+	note: z.string().optional(),
+	feedback: feedbackSchema.optional()
+}).superRefine((item, context) => {
+	if (!item.options.includes(item.correct)) context.addIssue({
+		code: "custom",
+		path: ["correct"],
+		message: "The correct verb form must be one of the options"
+	});
+	if (new Set(item.options).size !== item.options.length) context.addIssue({
+		code: "custom",
+		path: ["options"],
+		message: "Verb options must be unique"
+	});
 });
 const prepItemSchema = z.object({
-	before: z.string(),
-	noun: z.string(),
-	answer: z.string(),
-	options: z.array(z.string()),
+	before: nonBlankSchema,
+	noun: nonBlankSchema,
+	answer: nonBlankSchema,
+	options: z.array(nonBlankSchema).min(2).max(6),
 	scene: relationSchema,
 	figure: iconValueSchema.optional().describe("emoji/IconRef for the placed thing"),
 	landmark: iconValueSchema.optional().describe("emoji/IconRef, or a backdrop key: 'sky'|'water'|'ground'|'room'"),
-	note: z.string().optional()
+	note: z.string().optional(),
+	feedback: feedbackSchema.optional()
+}).superRefine((item, context) => {
+	if (!item.options.includes(item.answer)) context.addIssue({
+		code: "custom",
+		path: ["answer"],
+		message: "The answer must be one of the preposition options"
+	});
+	if (new Set(item.options).size !== item.options.length) context.addIssue({
+		code: "custom",
+		path: ["options"],
+		message: "Preposition options must be unique"
+	});
+});
+const clozeItemSchema = z.object({
+	text: nonBlankSchema.describe("sentence with each blank written as ___ (3+ underscores)"),
+	answers: z.array(nonBlankSchema).min(1).max(8),
+	distractors: z.array(nonBlankSchema).max(16).optional(),
+	why: z.string().optional(),
+	gloss: z.string().optional(),
+	audioUrl: z.string().optional()
+}).superRefine((item, context) => {
+	const blanks = item.text.match(/_{3,}/g)?.length ?? 0;
+	if (blanks !== item.answers.length) context.addIssue({
+		code: "custom",
+		path: ["answers"],
+		message: `Provide exactly one answer for each blank (${blanks} found)`
+	});
+});
+const readingQuestionSchema = z.object({
+	q: nonBlankSchema,
+	options: z.array(nonBlankSchema).min(2).max(6),
+	answer: nonBlankSchema,
+	explain: z.string().optional()
+}).superRefine((question, context) => {
+	if (!question.options.includes(question.answer)) context.addIssue({
+		code: "custom",
+		path: ["answer"],
+		message: "The reading answer must be one of the options"
+	});
+	if (new Set(question.options).size !== question.options.length) context.addIssue({
+		code: "custom",
+		path: ["options"],
+		message: "Reading options must be unique"
+	});
+});
+const glossEntrySchema = z.object({
+	word: nonBlankSchema,
+	meaning: nonBlankSchema
+});
+const errorItemSchema = z.object({
+	text: nonBlankSchema,
+	wrong: nonBlankSchema,
+	fix: nonBlankSchema,
+	why: z.string().optional()
+}).superRefine((item, context) => {
+	const bare = (value) => value.replace(/[.,!?;:"']+$/g, "").toLocaleLowerCase();
+	if (item.text.split(/\s+/).filter((token) => bare(token) === bare(item.wrong)).length !== 1) context.addIssue({
+		code: "custom",
+		path: ["wrong"],
+		message: "The wrong word must appear exactly once in the sentence"
+	});
+	if (bare(item.wrong) === bare(item.fix)) context.addIssue({
+		code: "custom",
+		path: ["fix"],
+		message: "The correction must differ from the wrong word"
+	});
 });
 const boardVectorSchema = z.object({
 	id: z.string().optional(),
@@ -122,7 +208,8 @@ const flatVecSchema = z.object({
 	dx: z.union([z.number(), z.string()]).optional(),
 	dy: z.union([z.number(), z.string()]).optional(),
 	color: z.string().optional(),
-	drag: z.boolean().optional()
+	drag: z.boolean().optional(),
+	lockMagnitude: z.boolean().optional().describe("dragging rotates this vector and holds its length (constant speed)")
 });
 const typePanelSchema = z.object({
 	name: z.string(),
@@ -142,4 +229,4 @@ const controlConfigSchema = z.object({
 });
 
 //#endregion
-export { agreementItemSchema, articleAnswerSchema, articleItemSchema, boardVectorSchema, controlConfigSchema, deckItemSchema, deckSchema, flatVecSchema, iconRefSchema, iconValueSchema, posSchema, prepItemSchema, relationSchema, sentenceTileSchema, transformTileSchema, typePanelSchema, vec2Schema };
+export { activityPatternSchema, agreementItemSchema, articleAnswerSchema, articleItemSchema, authoredActivitySchema, authoredActivityStepSchema, authoredChoiceSchema, authoredDatasetSchema, authoredQuestionSchema, authoredSuccessSchema, authoredTransferCaseSchema, boardVectorSchema, clozeItemSchema, controlConfigSchema, deckItemSchema, deckSchema, errorItemSchema, feedbackSchema, flatVecSchema, glossEntrySchema, iconRefSchema, iconValueSchema, languageTagSchema, posSchema, prepItemSchema, readingQuestionSchema, relationSchema, sentenceTileSchema, transformTileSchema, typePanelSchema, vec2Schema };

package/dist/shared/fields.mjs

@@ -0,0 +1,39 @@
+import { commonLabProps } from "../blocks/lab-block.mjs";
+import { z } from "zod";
+
+//#region src/shared/fields.ts
+/**
+* Shared authoring-schema fragments reused across migrated labs. Keeps each lab's
+* schema.ts a thin, honest declaration instead of re-inlining the same shapes.
+*/
+/**
+* Creator control policy — the Activity `controlConfig` fragment: hide or lock named
+* knobs so an author can ship a FOCUSED lesson (one setup) from a multi-mode lab.
+*/
+const controlConfig = z.object({
+	hide: z.array(z.string()).optional(),
+	lock: z.array(z.string()).optional()
+}).optional();
+/** A 2-D point in world coords. */
+const vec2 = z.object({
+	x: z.number(),
+	y: z.number()
+});
+/**
+* An attached graded question (the LabAsk mechanism): MCQ (choices + correct) or a typed
+* answer (number / algebraic), with an explanation shown once answered correctly.
+*/
+const ask = z.object({
+	prompt: z.string().describe("the question"),
+	choices: z.array(z.object({
+		value: z.string(),
+		label: z.string()
+	})).optional().describe("multiple-choice options"),
+	correct: z.string().optional().describe("the value of the correct choice"),
+	answer: z.any().optional().describe("typed-answer spec (number or algebraic), instead of choices"),
+	placeholder: z.string().optional(),
+	explain: z.string().optional().describe("shown once answered correctly")
+}).optional();
+
+//#endregion
+export { ask, controlConfig, vec2 };