@plasius/learning 0.4.0 → 0.5.0

package/dist/courses/skywing-sprint.cjs

@@ -0,0 +1,367 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/courses/skywing-sprint.ts
+var skywing_sprint_exports = {};
+__export(skywing_sprint_exports, {
+  course: () => course,
+  practice: () => practice
+});
+module.exports = __toCommonJS(skywing_sprint_exports);
+
+// src/mission-authoring.ts
+var JUNIOR_CODER_MISSION_STAGE_ORDER_V1 = [
+  "learn",
+  "predict",
+  "build",
+  "run",
+  "assess",
+  "inspect",
+  "fix",
+  "explain",
+  "reward"
+];
+
+// src/course-contracts.ts
+var LEARNING_COURSE_STAGE_ORDER = JUNIOR_CODER_MISSION_STAGE_ORDER_V1;
+var LEARNING_COURSE_LIMITS = Object.freeze({
+  missions: 6,
+  stagesPerMission: 9,
+  projectFiles: 8,
+  sourceCharactersPerFile: 64e3,
+  sourceCharactersPerProject: 96e3
+});
+var ID = /^[a-z0-9][a-z0-9.-]{0,159}$/u;
+var FILE_PATH = /^[a-z0-9][a-z0-9_-]{0,63}\.(?:js|py|cpp|html|css|json)$/u;
+var VERSION = /^\d+\.\d+\.\d+$/u;
+var LANGUAGES = ["javascript", "python", "cpp", "html", "css", "blocks", "json"];
+var CATEGORIES = ["game", "robot", "vibe", "web-app"];
+var PLACEHOLDER = /\b(?:TODO|TBD|coming soon|placeholder|lorem ipsum)\b/iu;
+var record = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var text = (value, minimum = 1, maximum = 8e3) => typeof value === "string" && value.trim().length >= minimum && value.length <= maximum;
+var id = (value) => typeof value === "string" && ID.test(value);
+var integer = (value, minimum, maximum) => typeof value === "number" && Number.isSafeInteger(value) && value >= minimum && value <= maximum;
+var exactKeys = (value, keys) => Object.keys(value).length === keys.length && keys.every((key) => Object.hasOwn(value, key));
+var LearningCourseInputError = class extends Error {
+  constructor() {
+    super("Invalid learning course input.");
+    this.name = "LearningCourseInputError";
+  }
+};
+function fileDefinitions(value) {
+  return Array.isArray(value) && value.length >= 1 && value.length <= LEARNING_COURSE_LIMITS.projectFiles && value.every((file) => record(file) && exactKeys(file, ["path", "language", "maximumCharacters"]) && typeof file.path === "string" && FILE_PATH.test(file.path) && typeof file.language === "string" && LANGUAGES.includes(file.language) && integer(file.maximumCharacters, 1, LEARNING_COURSE_LIMITS.sourceCharactersPerFile)) && new Set(value.map((file) => file.path)).size === value.length;
+}
+function parseLearningProject(course2, value) {
+  if (!fileDefinitions(course2.projectFiles) || !record(value) || !exactKeys(value, ["files"]) || !Array.isArray(value.files) || value.files.length !== course2.projectFiles.length) throw new LearningCourseInputError();
+  const files = [];
+  const seen = /* @__PURE__ */ new Set();
+  let characters = 0;
+  for (const file of value.files) {
+    if (!record(file) || !exactKeys(file, ["path", "source"]) || typeof file.path !== "string" || typeof file.source !== "string" || seen.has(file.path)) throw new LearningCourseInputError();
+    const definition = course2.projectFiles.find((candidate) => candidate.path === file.path);
+    if (!definition || file.source.length > definition.maximumCharacters || file.source.includes("\0")) throw new LearningCourseInputError();
+    characters += file.source.length;
+    if (characters > LEARNING_COURSE_LIMITS.sourceCharactersPerProject) throw new LearningCourseInputError();
+    seen.add(file.path);
+    files.push({ path: file.path, source: file.source });
+  }
+  return { files: course2.projectFiles.map((definition) => files.find((file) => file.path === definition.path)) };
+}
+function validateLearningCourse(value) {
+  const issues = [];
+  const add = (code, path) => {
+    issues.push({ code, path });
+  };
+  if (!record(value)) return [{ code: "invalid-manifest", path: "$" }];
+  if (!exactKeys(value, [
+    "schemaVersion",
+    "moduleId",
+    "moduleVersion",
+    "slug",
+    "title",
+    "summary",
+    "runtimeId",
+    "category",
+    "estimatedMinutes",
+    "completionAssessmentId",
+    "projectFiles",
+    "starterProject",
+    "reference",
+    "missions",
+    "completionBadge"
+  ]) || value.schemaVersion !== "1" || !id(value.moduleId) || !id(value.slug) || !id(value.runtimeId) || !text(value.moduleVersion) || !VERSION.test(value.moduleVersion) || typeof value.category !== "string" || !CATEGORIES.includes(value.category) || !text(value.title, 3, 160) || !text(value.summary, 40, 2e3) || !integer(value.estimatedMinutes, 60, 3600) || !id(value.completionAssessmentId) || !record(value.completionBadge) || !exactKeys(value.completionBadge, ["id", "title"]) || !id(value.completionBadge.id) || !text(value.completionBadge.title, 3, 160)) add("invalid-manifest", "$");
+  if (!fileDefinitions(value.projectFiles)) add("invalid-project", "projectFiles");
+  else {
+    try {
+      parseLearningProject({ projectFiles: value.projectFiles }, value.starterProject);
+    } catch {
+      add("invalid-project", "starterProject");
+    }
+  }
+  if (!Array.isArray(value.reference) || value.reference.length < 1 || value.reference.length > 80 || value.reference.some((entry) => !record(entry) || !exactKeys(entry, ["name", "signature", "description", "example"]) || !text(entry.name) || !text(entry.signature) || !text(entry.description, 20) || !text(entry.example))) add("incomplete-content", "reference");
+  if (!Array.isArray(value.missions)) {
+    add("mission-count", "missions");
+    return issues;
+  }
+  if (value.missions.length !== LEARNING_COURSE_LIMITS.missions) add("mission-count", "missions");
+  if (value.missions.length > LEARNING_COURSE_LIMITS.missions) return issues;
+  const seen = /* @__PURE__ */ new Set();
+  const checkId = (candidate, path) => {
+    if (!id(candidate)) add("invalid-manifest", path);
+    else if (seen.has(candidate)) add("duplicate-id", path);
+    else seen.add(candidate);
+  };
+  let minutes = 0;
+  value.missions.forEach((mission, missionIndex) => {
+    const path = `missions[${missionIndex}]`;
+    if (!record(mission)) {
+      add("invalid-manifest", path);
+      return;
+    }
+    checkId(mission.id, `${path}.id`);
+    checkId(mission.assessmentId, `${path}.assessmentId`);
+    if (!exactKeys(mission, ["id", "title", "concepts", "estimatedMinutes", "goals", "assessmentId", "stages", "extension"]) || !text(mission.title, 3, 160) || !integer(mission.estimatedMinutes, 10, 600) || !Array.isArray(mission.concepts) || mission.concepts.length < 1 || mission.concepts.length > 12 || mission.concepts.some((concept) => !text(concept, 2, 120)) || !Array.isArray(mission.goals) || mission.goals.length < 1 || mission.goals.length > 12 || mission.goals.some((goal) => !text(goal, 20, 2e3)) || !text(mission.extension, 30, 2e3)) add("incomplete-content", path);
+    if (typeof mission.estimatedMinutes === "number") minutes += mission.estimatedMinutes;
+    if (!Array.isArray(mission.stages) || mission.stages.length !== LEARNING_COURSE_LIMITS.stagesPerMission) {
+      add("stage-order", `${path}.stages`);
+      return;
+    }
+    mission.stages.forEach((stage, stageIndex) => {
+      const stagePath = `${path}.stages[${stageIndex}]`;
+      if (!record(stage)) {
+        add("invalid-manifest", stagePath);
+        return;
+      }
+      checkId(stage.id, `${stagePath}.id`);
+      if (stage.kind !== LEARNING_COURSE_STAGE_ORDER[stageIndex]) add("stage-order", stagePath);
+      if (!exactKeys(stage, ["id", "kind", "title", "instruction", "help"]) || !text(stage.title, 3, 160) || !text(stage.instruction, 40) || !text(stage.help, 30) || typeof stage.instruction === "string" && PLACEHOLDER.test(stage.instruction)) add("incomplete-content", stagePath);
+    });
+  });
+  if (minutes !== value.estimatedMinutes) add("invalid-manifest", "estimatedMinutes");
+  return issues;
+}
+function parseLearningCourse(value) {
+  if (validateLearningCourse(value).length) throw new LearningCourseInputError();
+  return structuredClone(value);
+}
+
+// src/courses/course-authoring.ts
+function authorCourse(header, missions) {
+  const course2 = parseLearningCourse({
+    ...header,
+    schemaVersion: "1",
+    moduleVersion: "2.0.0",
+    moduleId: `junior-coder.${header.slug}`,
+    runtimeId: `${header.slug}.v2`,
+    estimatedMinutes: missions.length * 60,
+    completionAssessmentId: `${header.slug}.final`,
+    completionBadge: { id: `${header.slug}.completed`, title: `${header.title} creator` },
+    missions: missions.map((mission, index) => ({
+      id: `${header.slug}.m${index + 1}`,
+      title: mission.title,
+      concepts: mission.concepts,
+      goals: mission.goals,
+      estimatedMinutes: 60,
+      assessmentId: `${header.slug}.m${index + 1}.assessment`,
+      extension: mission.extension,
+      stages: LEARNING_COURSE_STAGE_ORDER.map((kind) => ({
+        id: `${header.slug}.m${index + 1}.${kind}`,
+        kind,
+        title: `${kind.charAt(0).toUpperCase()}${kind.slice(1)}: ${mission.title}`,
+        instruction: mission.activities[kind][0],
+        help: mission.activities[kind][1]
+      }))
+    }))
+  });
+  const practice2 = structuredClone(missions.flatMap((mission, index) => ["learn", "predict", "explain"].map((kind) => ({ ...mission.questions[kind], stageId: `${header.slug}.m${index + 1}.${kind}` }))));
+  for (const question of practice2) {
+    if (question.question.trim().length < 20 || question.feedback.trim().length < 40 || question.choices.length !== 3 || question.choices.some((choice) => choice.trim().length < 2) || new Set(question.choices).size !== 3 || !Number.isInteger(question.correctChoice) || question.correctChoice < 0 || question.correctChoice > 2) throw new Error("Invalid course practice question.");
+  }
+  return { course: course2, practice: practice2 };
+}
+
+// src/courses/skywing-sprint.ts
+var { course, practice } = authorCourse({
+  slug: "skywing-sprint",
+  title: "Skywing Sprint",
+  category: "game",
+  summary: "Create a side-scrolling flight game from a stationary bird. Give it weight and a flap, move gates across the sky, make collisions fair, and award each gate once. Finish with a repeatable twilight race that can be paused, restarted and played with a keyboard or touch controls.",
+  projectFiles: [{ path: "game.js", language: "javascript", maximumCharacters: 32e3 }],
+  starterProject: { files: [{ path: "game.js", source: `function initialState() {
+  return {
+    bird: { x: 80, y: 180, vy: 0, radius: 10 },
+    gates: [], score: 0, elapsed: 0, status: "ready"
+  };
+}
+
+function update(state, input) {
+  // Return the next state after this action. The host draws that state.
+  return state;
+}
+` }] },
+  reference: [
+    { name: "initialState", signature: "initialState() -> state", description: "Return a fresh race state. The world is 480 by 360 logical pixels; y increases downwards. Restart must create fresh arrays as well as resetting the bird.", example: 'return { bird: { x: 80, y: 180, vy: 0, radius: 10 }, gates: [], score: 0, elapsed: 0, status: "ready" };' },
+    { name: "update", signature: "update(state, input) -> state", description: "Handle one start, flap, tick or restart action and return the complete next state. Only a playing race advances on tick. Rendering and button events are supplied by the host.", example: 'if (input.action === "restart") return initialState();' },
+    { name: "input.dt", signature: "input.dt: seconds", description: "A tick supplies 0.02 simulated seconds. Express velocity in pixels per second and multiply by dt when changing position. No wall clock or display frame rate is needed.", example: "const nextY = state.bird.y + state.bird.vy * input.dt;" },
+    { name: "flap", signature: 'input.action === "flap"', description: "A press creates one flap action. Set upward velocity to -180; do not repeatedly add an impulse while a button remains held. Gravity is 420 pixels per second squared.", example: 'if (input.action === "flap" && state.status === "playing") state.bird.vy = -180;' },
+    { name: "input.gate", signature: "input.gate: gate | null", description: "A tick may carry one seeded gate with id, x, gapY, gapHeight and width. Add it once, then move gates left at 90 pixels per second. The same seed supplies the same course.", example: "if (input.gate && !state.gates.some(g => g.id === input.gate.id)) state.gates.push({ ...input.gate, passed: false });" },
+    { name: "bird.radius", signature: "bird.radius = 10", description: "The bird has a collision radius. It fits a gate only when its top and bottom are inside the gap while its horizontal extent overlaps the gate. The floor is y=360 and ceiling y=0.", example: "const top = state.bird.y - state.bird.radius; const bottom = state.bird.y + state.bird.radius;" },
+    { name: "gate.passed", signature: "gate.passed: boolean", description: "Award a point once after the entire gate moves behind the bird's left edge. Set passed immediately so later ticks cannot award the same gate again. Remove gates only after they leave the world.", example: "const behind = gate.x + gate.width < state.bird.x - state.bird.radius;" },
+    { name: "status", signature: '"ready" | "playing" | "over"', description: "Start changes ready to playing. A collision changes playing to over. Over freezes physics and score until restart returns a fresh ready state; pause is controlled by the host.", example: 'if (state.status !== "playing" || input.action !== "tick") return state;' }
+  ]
+}, [
+  {
+    title: "A bird with weight",
+    concepts: ["State", "Velocity", "Simulation time"],
+    goals: ["Update vertical velocity and position using the supplied simulated time.", "Keep ready and finished races still until a valid start or restart action."],
+    extension: "Compare gravity values 300 and 420 in separate named saves. Use the same starting height and tick count to explain the difference in the fall.",
+    activities: {
+      learn: ["Position tells us where the bird is; velocity tells us how quickly it moves. Down is positive y in this world. On each playing tick, first add 420 \xD7 dt to vy, then add the new vy \xD7 dt to y. These are pixels per second and seconds, not pixels per screen redraw.", "At rest, vy is zero. Gravity changes vy even before the first visible movement. Keep both numbers in the state."],
+      predict: ["Start at y=180 with vy=0 and use dt=0.02. Calculate the new velocity, then the new position for one tick. Use the updated velocity in the second calculation and keep the fractional part.", "420 \xD7 0.02 is 8.4. Multiplying that by 0.02 gives the first displacement; adding 8.4 directly to y mixes units."],
+      build: ["In game.js, handle start by setting status to playing. Handle tick only while playing: update vy, update y and add dt to elapsed. Return the whole state so that the preview can draw the new bird and read its numbers.", "Keep the starter fields and initialState function. A missing return or returning only bird loses the rest of the race state."],
+      run: ["Start the preview, step through several ticks and watch the velocity and height readouts. Restart the simulation and repeat the same number of steps. The numbers should match even if you paused for a while between steps.", "The preview supplies simulated time. Waiting with the preview paused must not make the bird jump when you resume."],
+      assess: ["Check the saved flight model. Tests compare a fresh state, the first ticks of a falling bird and ticks received while ready. They check the calculation order as well as whether the bird appears to fall.", "A visually moving bird can still use the wrong units. Compare the expected and actual vy and y values in the first failing tick."],
+      inspect: ["Find the earliest mismatch in the flight trace. If velocity is right but displacement is far too large, inspect the second dt multiplication. If nothing changes, inspect the start transition and the tick condition.", "Change one calculation at a time. A later wrong height is often the sum of an earlier small error."],
+      fix: ["Repair the integration and state conditions, then rerun the same tick sequence and assess the current saved source. Keep the bird still in ready state and retain fractional coordinates during simulation.", "Round only a displayed label, never the stored physics values. Repeated rounding changes the trajectory."],
+      explain: ["Choose why a game should multiply speed by simulated seconds rather than adding that speed on every redraw. Relate your answer to the paused and stepped runs you compared.", "Two devices can draw different numbers of frames while simulating the same amount of game time."],
+      reward: ["Save this project as Falling bird. You now have a small physics model with a reproducible trace. The next mission adds a single upward impulse so that the player can influence the flight.", "Keep a named save before changing the controls; it gives you a simple physics baseline to revisit."]
+    },
+    questions: {
+      learn: { question: "Which quantity describes how fast the bird moves vertically?", choices: ["Its score", "Its velocity vy", "Its gate count"], correctChoice: 1, feedback: "The y coordinate is position; vy is the rate at which that position changes over simulated seconds." },
+      predict: { question: "After the first 0.02-second tick, what are vy and y?", choices: ["8.4 and 180.168", "420 and 600", "8.4 and 188.4"], correctChoice: 0, feedback: "Velocity becomes 8.4 pixels per second. The displacement is 8.4 \xD7 0.02 = 0.168 pixels." },
+      explain: { question: "Why use dt instead of adding a fixed displacement per redraw?", choices: ["It makes gravity unnecessary", "It guarantees every device draws at the same rate", "It ties movement to game time rather than drawing frequency"], correctChoice: 2, feedback: "The simulation measures elapsed seconds, so an extra screen redraw does not create an extra movement step." }
+    }
+  },
+  {
+    title: "One flap, one impulse",
+    concepts: ["Events", "Assignment", "State transitions"],
+    goals: ["Make one flap press set a bounded upward velocity during a race.", "Handle repeated presses and held controls without accumulating unlimited lift."],
+    extension: "Save two flap strengths and compare their highest point from the same starting state. Explain the trade-off between recovery and fine control.",
+    activities: {
+      learn: ["A flap is an event, not a permanent force. Set vy to -180 when a flap action arrives while playing. Negative velocity moves upwards. Setting a value differs from subtracting 180: two immediate presses should still leave vy at -180.", "The host converts a keyboard or touch press to a flap action. A held key should not become an uncontrolled stream of repeat events."],
+      predict: ["The bird is falling with vy=70. Predict vy after one flap and after a second flap with no tick between them. Then predict what the first gravity tick does to that upward velocity.", "Assignment replaces the old value. Gravity adds a positive amount, so upward speed gradually becomes less negative."],
+      build: ["Add the flap branch to update. Require playing status and assign vy=-180. Keep start separate from flap, and add restart handling that calls initialState rather than resetting only the bird's y coordinate.", "Return after handling an event if that makes your branches clearer. A flap event is not a tick and must not also advance elapsed time."],
+      run: ["Start a race and try single presses, quick double presses, holding a key and using the touch flap button. Step after a flap to observe rising, slowing, stopping at the top and falling again. Check that restart returns to ready.", "Use the velocity readout to distinguish a fresh impulse from a frame update. Two presses do not mean twice the upward speed."],
+      assess: ["Check flap handling during playing, ready and over states. The checks also send two consecutive flap actions and a restart after movement. Only the intended action should change the corresponding state.", "Tests call update directly as well as exercising controls. Your project still needs safe event handling even when the interface normally filters held keys."],
+      inspect: ["If the double-flap check fails, compare assignment with subtraction. If a finished bird keeps moving after a press, inspect the status guard. If restart inherits old velocity, compare every fresh-state field.", "A working button is only one part of the behaviour. The state transition must be correct for actions received at awkward times."],
+      fix: ["Repair the smallest failing control branch and replay the fall model from the previous mission. Verify that flap changes velocity without changing position immediately, and that restart returns a fresh state with elapsed zero.", "An upward teleport can look like a flap but bypasses the physics model. Let the next tick apply the new velocity to position."],
+      explain: ["Choose why assigning a fixed impulse makes rapid presses more predictable than subtracting from the current velocity. Use the double-press trace as evidence, then describe where the playing-state check belongs.", "The same control action should have a clear, bounded meaning even if it arrives twice quickly."],
+      reward: ["Save this version as Controlled flight. You can now start, flap and reset a reproducible bird simulation. Next you will create a world that moves past the bird and gives those controls a purpose.", "Try a short flight without repeatedly pressing the button. You will soon need deliberate timing to pass gates."]
+    },
+    questions: {
+      learn: { question: "What should a flap action do while the race is playing?", choices: ["Set vy to -180", "Teleport y to zero", "Subtract 180 on every display frame"], correctChoice: 0, feedback: "A flap sets one bounded upward velocity. Position changes later through the ordinary physics tick." },
+      predict: { question: "Two flap actions without a tick between them leave vy at what value?", choices: ["-360", "-180", "70"], correctChoice: 1, feedback: "Both actions assign the same value, so the second press does not add another -180 to the first." },
+      explain: { question: "Why ignore flap events after the race is over?", choices: ["To erase the previous score", "To make the controls depend on frame rate", "To keep the finished race stable until restart"], correctChoice: 2, feedback: "An over state preserves the final result. Restart is the explicit action that creates another race." }
+    }
+  },
+  {
+    title: "Gates on the horizon",
+    concepts: ["Arrays", "Identity", "Object lifecycle"],
+    goals: ["Add and move supplied gates without duplicating their stable identifiers.", "Remove offscreen gates while retaining the objects still needed for collisions and scoring."],
+    extension: "Compare a wide and a narrow gap on the same seeded course. Keep the movement speed unchanged so the comparison isolates gap size.",
+    activities: {
+      learn: ["A gate is a record in the gates array, with a stable id, x position, width and vertical gap. Some ticks supply input.gate. Add a fresh copy once, set passed=false and move every gate left by 90 \xD7 dt on each playing tick.", "The bird can stay at x=80 while the scenery moves. Relative motion makes the race feel like forward flight."],
+      predict: ["A gate starts at x=480 and the next tick has dt=0.02. Predict its new x. Then consider two input messages carrying the same id: decide whether they describe two gates or the same gate arriving twice.", "The displacement is speed multiplied by seconds. Identity comes from id, not from the gate's current position."],
+      build: ["Extend the playing tick to accept a supplied gate only if its id is absent. Copy its fields into your array and initialise passed. Move each gate, then filter out gates whose right edge is left of zero. Preserve all other race state.", "Use gate.x + gate.width for the right edge. Removing a gate when its left edge reaches zero deletes it while part remains onscreen."],
+      run: ["Run a seeded course long enough for several gates to enter and leave. Pause and inspect each id and x position. Restart with the same seed to compare the sequence, and watch the array length settle rather than grow forever.", "A simulation may keep several visible gates at once. Filtering should remove only those entirely outside the left edge."],
+      assess: ["Assess insertion, duplicate-id handling, movement and cleanup. Cases include no incoming gate, an already known id and a gate with only its left edge offscreen. The checks compare gate data, not just the picture.", "An empty input.gate means no new gate this tick; it does not mean clear the existing array."],
+      inspect: ["If gates flicker or disappear, inspect the filter boundary and whether you overwrite the array on empty inputs. If a gate appears twice, compare its stable id before insertion. If x changes too quickly, revisit the units.", "Logically inspect the before and after arrays in the trace. A changed index is not a changed identity."],
+      fix: ["Repair the gate lifecycle and rerun a course with duplicate and empty inputs. Keep each object's id and gap measurements intact while changing x. Recheck the flap and falling tests to catch accidental changes to the bird.", "Copying a supplied object keeps the project state separate from its input record. Avoid deleting properties from input.gate."],
+      explain: ["Choose why stable identifiers are useful when objects move and arrays are filtered. Explain why the screen position cannot reliably identify the same gate on the next tick.", "Position changes during play and array indices change after cleanup; a gate's id stays the same."],
+      reward: ["Save Moving gates. Your project now manages objects across their whole lifetime instead of drawing a single fixed obstacle. The next mission decides when the bird actually touches one of them.", "Keep this version for checking collision bugs: it already establishes the expected obstacle movement."]
+    },
+    questions: {
+      learn: { question: "Which value should identify the same gate across movement and cleanup?", choices: ["Its current array index", "Its current x coordinate", "Its stable id"], correctChoice: 2, feedback: "The id remains attached to that gate while x and its array index can change during the race." },
+      predict: { question: "At 90 pixels per second, where is a gate after one 0.02-second tick from x=480?", choices: ["478.2", "390", "481.8"], correctChoice: 0, feedback: "The gate moves left by 90 \xD7 0.02 = 1.8 pixels, so its new x coordinate is 478.2." },
+      explain: { question: "When is it safe to remove a gate for leaving the left edge?", choices: ["As soon as x is less than zero", "When x plus width is less than zero", "Whenever a new gate arrives"], correctChoice: 1, feedback: "The complete gate is outside the world only after its right edge passes the left boundary." }
+    }
+  },
+  {
+    title: "A fair landing",
+    concepts: ["Bounds", "Collision", "Terminal states"],
+    goals: ["Detect floor, ceiling and gate contacts using the bird's full radius.", "Freeze a lost race and reset every field before the next attempt."],
+    extension: "Design three near-miss cases on paper: just inside, exactly touching and just outside a gap. Explain which should be safe under the documented contact rule.",
+    activities: {
+      learn: ["The bird is larger than a point. Its top is y-radius and bottom is y+radius. Contact with the floor, ceiling or a solid gate ends the race. For a gate, first test horizontal overlap, then whether the whole bird fits strictly inside the vertical gap.", "Use the same contact rule consistently: touching a solid edge is a collision. A gate elsewhere on the screen cannot collide with the bird yet."],
+      predict: ["A gap runs from y=120 to y=220 and overlaps the bird horizontally. Predict whether a bird at y=125 with radius 10 fits, even though its centre is inside the gap. Then compare a bird centred at y=170.", "Subtract and add the radius before judging the gap. The first bird's top is y=115."],
+      build: ["After moving the bird and gates, check world boundaries and each overlapping gate. Set status to over on contact. Make later tick and flap actions preserve an over state. Restart must return initialState with no gates, no score and no old velocity.", "A clear gate gap is empty space. Test its top and bottom edges, not collision with the gate's whole rectangular outline."],
+      run: ["Try a centred pass, a scrape against a gap edge and a floor collision. Pause at the last safe tick and the first contact tick. Restart after each loss and verify that old gates do not remain in the new race.", "The text trace shows bounds and status, so you can inspect a close collision without relying on fast animation."],
+      assess: ["Check contacts at all four relevant edges, safe passage through the gap and a gate that is vertically dangerous but not horizontally near the bird. Also check that over states cannot gain movement from later actions.", "Correct collision needs both axes. A height outside one distant gate's gap must not end the race."],
+      inspect: ["If safe passes fail, separate horizontal overlap from vertical fit. If the bird clips an edge, inspect radius and equality comparisons. If a lost race continues, follow the status guard before the tick calculations.", "Write the bird's left, right, top and bottom next to the gate bounds. Use the first contact case instead of guessing from a later frame."],
+      fix: ["Repair the earliest incorrect boundary comparison, then repeat inside, touching and outside cases. Recheck restart from both ready and over states and ensure no score or gate data leaks between attempts.", "Changing all comparisons at once can swap one edge bug for another. Keep an explicit example for each edge."],
+      explain: ["Choose why centre-only collision checks can look unfair to the player. Refer to the bird's radius and explain how a terminal over state makes the last valid race result stable.", "The drawn bird and its logical bounds should agree. A visible wing passing through a solid wall breaks that agreement."],
+      reward: ["Save Fair collisions. Your race can now end consistently and begin again with a clean state. Next you will count successful gate passages without rewarding the same obstacle on every tick.", "Keep your near-miss examples; they become regression cases for later changes to difficulty."]
+    },
+    questions: {
+      learn: { question: "What must be checked before a gate can collide with the bird?", choices: ["Horizontal overlap as well as vertical bounds", "Only the gate's colour", "Only whether the centre is below the gap"], correctChoice: 0, feedback: "Collision requires the gate to overlap the bird horizontally and the bird to touch a solid vertical region." },
+      predict: { question: "Does a radius-10 bird centred at y=125 fit a gap from 120 to 220?", choices: ["Yes, because its centre is inside", "No, because its top reaches y=115", "Only if the score is zero"], correctChoice: 1, feedback: "The bird extends beyond its centre. Its top is five pixels above the gap, so it overlaps the upper obstacle." },
+      explain: { question: "What should a restart after a collision create?", choices: ["The old gates with only y reset", "The old score and a new bird", "A fresh ready state for every race field"], correctChoice: 2, feedback: "Restart creates a new attempt. Old velocity, score, gates and elapsed time must not carry into it." }
+    }
+  },
+  {
+    title: "A score you can trust",
+    concepts: ["One-time events", "Reproducibility", "Invariants"],
+    goals: ["Award each fully passed gate once and never award points after a collision.", "Reproduce a score with the same seed and sequence of player inputs."],
+    extension: "Record two flap schedules for the same seed and compare their results. Change only the schedule so that the obstacle layout remains a fair comparison.",
+    activities: {
+      learn: ["A passed gate is an event hidden inside repeated ticks. When its right edge is behind the bird's left edge and passed is false, add one point and set passed=true. Run collision checks first so a losing tick cannot also reward an unsafe passage.", "The passed marker remembers that this gate has already contributed. A condition can stay true for many later ticks."],
+      predict: ["A gate becomes fully behind the bird and remains visible for eight more ticks. Predict the score increase with and without a passed marker. Then decide whether changing only the display frame rate should alter that score.", "Ask how many gates were completed, not how many ticks observed the same completed gate."],
+      build: ["Add one-time passage scoring after collision resolution while status remains playing. Preserve each gate's passed field during movement. Keep supplied seeded gates as the source of obstacles instead of calling a clock or inventing a new course every frame.", "Use the complete gate edge, not its centre, to decide it has passed. A point should mean the whole obstacle was cleared."],
+      run: ["Pass one gate, pause and step several more ticks while it is still visible. The score should remain one. Restart with the same seed and repeat the same input schedule; compare both score and gate positions at the same elapsed time.", "Human button timing can vary. Stepped actions make an exact comparison easier than two hand-played attempts."],
+      assess: ["Check first passage, repeated ticks behind the bird, two different gate ids and a passage on a collision tick. Checks also repeat an identical seeded input sequence and compare the final state.", "A high score alone proves little. The tests care that each point has a distinct, safe passage behind it."],
+      inspect: ["If score grows continuously, find where passed is set or accidentally cleared. If replay changes, inspect calls to ambient time or uncontrolled randomness. If a losing tick awards a point, inspect the order of collision and scoring.", "Keep the gate id in your reasoning. Two snapshots of one id still describe only one obstacle."],
+      fix: ["Repair scoring and replay differences, then recheck insertion, cleanup and restart. A restarted race must clear score and passed markers by creating a new gate array rather than reusing the last attempt's objects.", "Use the same small scenario before and after the fix. A different course can hide whether your change caused the improvement."],
+      explain: ["Choose why a stable seed and input sequence are useful when investigating a bug. Explain separately why the passed flag is still needed even when the course is deterministic.", "Reproducibility helps you repeat a fault; identity and state prevent counting that same event repeatedly."],
+      reward: ["Save Honest score. Your race now turns actual safe passages into a repeatable result. The capstone combines movement, controls, gate lifecycle, collisions and scoring into a polished complete attempt.", "Name a second save before experimenting with speed or gap size so the tested score model remains available."]
+    },
+    questions: {
+      learn: { question: "Which action prevents one passed gate from awarding a point every tick?", choices: ["Drawing the score in a different colour", "Making the gate wider", "Setting that gate's passed marker"], correctChoice: 2, feedback: "The marker records that this specific gate has already been counted, even while the passage condition stays true." },
+      predict: { question: "One gate stays behind the bird for nine ticks; how many points should it award?", choices: ["One", "Nine", "As many as the display draws"], correctChoice: 0, feedback: "The score counts distinct completed gates. Repeated observations of the same gate do not create new passages." },
+      explain: { question: "Why keep the same seed and action sequence when reproducing a scoring bug?", choices: ["It makes all possible bugs disappear", "It keeps the experiment's conditions repeatable", "It removes the need to check collisions"], correctChoice: 1, feedback: "A repeated scenario lets you compare behaviour before and after a change without a different course confusing the result." }
+    }
+  },
+  {
+    title: "The twilight sprint",
+    concepts: ["Integration", "Regression testing", "Accessible play"],
+    goals: ["Complete a playable race with bounded physics, fair gates and repeatable scoring.", "Support start, flap, pause and restart without losing the latest saved project or earned progress."],
+    extension: "Design a gentler practice mode in a separate save. Explain the changed gravity, gate spacing or flap strength, then rerun collision and scoring cases before showing it to someone else.",
+    activities: {
+      learn: ["A finished race is more than a successful flap. Its controls, state transitions and rules must agree from ready through over and back to ready. Use a checklist covering flight, input, gates, collision, score and restart, then add keyboard, touch and reduced motion checks.", "The host owns pause and accessibility controls. Your state update must respect the supplied actions and simulated time rather than assuming animation is always running."],
+      predict: ["Predict the state after this sequence: start, flap, several ticks, pause, resume, collision, flap, restart. Identify which actions should leave elapsed time unchanged and which action should remove every gate.", "Pausing stops ticks; it does not reset the game. A flap after over is ignored, and restart makes a fresh ready state."],
+      build: ["Combine your passing mission versions into the final game.js. Keep small named helpers for physics, gate movement and collision if they improve clarity. Preserve the documented input/state contract and ensure restart creates a fresh object instead of editing an old saved reference.", "Restore your latest good named save if an experiment tangles several behaviours. Rebuild one verified change at a time."],
+      run: ["Play a full attempt using only the keyboard, then try the onscreen touch controls. Pause, step and restart at different moments. Inspect the text state in reduced motion mode and compare a replay with the same seed, keeping the project saved throughout.", "Do not rely on colour or animation alone to understand over, score or collision. The host's status text should tell the same story as the scene."],
+      assess: ["Run the final course checks against the current saved source. They combine physics, valid and mistimed inputs, duplicate gates, near-edge collisions, one-time scoring and clean restarts across several seeded courses.", "Passing one favourite course is not the whole capstone. Read which scenario failed and retain the source version attached to that result."],
+      inspect: ["Find the first difference in a failing capstone trace and connect it to the mission that taught that behaviour. Distinguish a physics error from an input error or an object-lifecycle error before choosing a repair.", "A late wrong score may come from an earlier collision or duplicate insertion. Start with the earliest incorrect state, not the final number."],
+      fix: ["Repair the final project and rerun both the failing case and previously passing mission cases. Confirm that changing the latest source invalidates old assessment evidence, then check the newly saved version before continuing.", "Avoid fixing a seeded case by hard-coding its gate positions. The project should respond to the supplied course data."],
+      explain: ["Choose what the final tests establish about your race, then describe one change you would explore next and which existing cases that change could affect. Be honest about the tested scenarios and the limits of the simplified collision model.", "A well-tested educational game can still have future improvements. Explain the evidence you have rather than promising that no bug is possible."],
+      reward: ["Save Twilight sprint, finish the final assessment and replay any mission. You have built a complete flight game, made its score explainable and preserved your work in account saves. Keep a stable named version before trying the practice-mode extension.", "Earned completion remains while you experiment. A later unsuccessful edit is a new learning opportunity, not a reason to lose your badge."]
+    },
+    questions: {
+      learn: { question: "What should an integrated race checklist include besides a working flap?", choices: ["Only a decorative background", "State transitions, rules, replay and usable controls", "Only the highest score ever seen"], correctChoice: 1, feedback: "The whole journey matters: starting, playing, losing, pausing and restarting must preserve consistent game rules." },
+      predict: { question: "After a collision followed by flap and restart, what state should remain?", choices: ["The old race flying again", "An over state with its old gates", "A fresh ready state with zero score and no gates"], correctChoice: 2, feedback: "Flap cannot revive an over race. Restart explicitly replaces it with initialState, including fresh arrays and counters." },
+      explain: { question: "What does passing the final scenarios establish?", choices: ["Evidence that the tested game rules behave as specified", "A proof that no possible bug remains", "Permission to skip tests after future edits"], correctChoice: 0, feedback: "Tests provide evidence for their scenarios. Changes and new edge cases still need investigation and fresh checks." }
+    }
+  }
+]);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  course,
+  practice
+});
+//# sourceMappingURL=skywing-sprint.cjs.map