@plasius/learning 0.2.18 → 0.2.20

package/README.md

@@ -54,6 +54,30 @@ const result = calculateAssessment(rubric, [
 console.log(result.score, result.completed);
 ```
 
+## Validate a Guardian-approved static project
+
+The publishing contracts cover only immutable evidence and safe render models.
+HTTP, persistence, identity checks, scanning implementations and hosting remain
+consumer responsibilities. A public renderer must consume the allow-listed
+`renderModel`; it must never execute learner source.
+
+```ts
+import {
+  assertValidStaticProjectGuardianApproval,
+  assertValidStaticProjectPublication,
+  assertValidStaticProjectSnapshot,
+} from "@plasius/learning";
+
+assertValidStaticProjectSnapshot(snapshot);
+assertValidStaticProjectGuardianApproval(approval);
+assertValidStaticProjectPublication(publication);
+```
+
+The version-one contract supports the three launch web projects, requires a
+score of at least 80 plus mandatory safety evidence, records all eight scanner
+checks, binds adult approval to the exact snapshot digest, and requires an
+unlisted HTTPS URL with a random slug and explicit expiry.
+
 ## Validate mission authoring
 
 Mission authoring is additive to the immutable catalog. A bundle contains
@@ -74,6 +98,7 @@ import {
   RAINBOW_RESCUE_ROVER_MISSION_ONE_AUTHORING_V1,
   RESCUE_CREW_COMMANDER_MISSION_ONE_AUTHORING_V1,
   ROAD_HOPPER_RALLY_MISSION_ONE_AUTHORING_V1,
+  ROBOT_MISSION_CONTROL_MISSION_ONE_AUTHORING_V1,
   ROBOT_MAZE_DASH_MISSION_ONE_AUTHORING_V1,
   SERVO_CREATURE_MISSION_ONE_AUTHORING_V1,
   SKYWING_SPRINT_MISSION_ONE_AUTHORING_V1,
@@ -138,6 +163,9 @@ const adventureMissionPlanner = JUNIOR_CODER_ROBOT_RESCUE_PATH_V1_1.modules.find
 const creatureCareDashboard = JUNIOR_CODER_ROBOT_RESCUE_PATH_V1_1.modules.find(
   (module) => module.slug === "creature-care-dashboard",
 );
+const robotMissionControl = JUNIOR_CODER_ROBOT_RESCUE_PATH_V1_1.modules.find(
+  (module) => module.slug === "robot-mission-control",
+);
 
 if (
   !roadHopper ||
@@ -157,7 +185,8 @@ if (
   !vibeBugDetective ||
   !vibeIdeaStudio ||
   !adventureMissionPlanner ||
-  !creatureCareDashboard
+  !creatureCareDashboard ||
+  !robotMissionControl
 ) {
   throw new Error("Junior Coder module is missing");
 }
@@ -234,6 +263,10 @@ assertValidMissionAuthoringBundle(
   CREATURE_CARE_DASHBOARD_MISSION_ONE_AUTHORING_V1,
   creatureCareDashboard,
 );
+assertValidMissionAuthoringBundle(
+  ROBOT_MISSION_CONTROL_MISSION_ONE_AUTHORING_V1,
+  robotMissionControl,
+);
 ```
 
 ## Contract rules
@@ -294,6 +327,10 @@ assertValidMissionAuthoringBundle(
   displays, responsive layouts and equivalent reduced-motion feedback. The
   learner controls the exact accessibility diff; no network, real schedule,
   background task or personal information enters the preview.
+- Robot Mission Control documents commands, a fail-safe state machine, explicit
+  confirmation, bounded telemetry and responsive chart/text views. The learner
+  controls the exact confirmation diff; Web Serial, physical hardware and
+  automatic approval remain outside the simulator.
 
 See [the foundation design](docs/design/junior-coder-catalog-foundation.md),
 [the uniform pricing design](docs/design/junior-coder-uniform-pricing.md),
@@ -310,6 +347,7 @@ See also [TDR 0011](docs/tdrs/tdr-0011-vibe-bug-detective-evidence-led-repair.md
 See also [TDR 0012](docs/tdrs/tdr-0012-vibe-idea-studio-bounded-goal-prototyping.md).
 See also [TDR 0013](docs/tdrs/tdr-0013-adventure-mission-planner-private-persistence.md).
 See also [TDR 0014](docs/tdrs/tdr-0014-creature-care-dashboard-bounded-timers-and-motion.md).
+See also [TDR 0015](docs/tdrs/tdr-0015-robot-mission-control-fail-safe-simulation.md).
 
 ## Development
 

package/dist/index.cjs

@@ -38,18 +38,31 @@ __export(index_exports, {
   RESCUE_CREW_COMMANDER_MISSION_ONE_AUTHORING_V1: () => RESCUE_CREW_COMMANDER_MISSION_ONE_AUTHORING_V1,
   ROAD_HOPPER_RALLY_MISSION_ONE_AUTHORING_V1: () => ROAD_HOPPER_RALLY_MISSION_ONE_AUTHORING_V1,
   ROBOT_MAZE_DASH_MISSION_ONE_AUTHORING_V1: () => ROBOT_MAZE_DASH_MISSION_ONE_AUTHORING_V1,
+  ROBOT_MISSION_CONTROL_MISSION_ONE_AUTHORING_V1: () => ROBOT_MISSION_CONTROL_MISSION_ONE_AUTHORING_V1,
   SERVO_CREATURE_MISSION_ONE_AUTHORING_V1: () => SERVO_CREATURE_MISSION_ONE_AUTHORING_V1,
   SKYWING_SPRINT_MISSION_ONE_AUTHORING_V1: () => SKYWING_SPRINT_MISSION_ONE_AUTHORING_V1,
   STAR_DEFENDER_SQUADRON_MISSION_ONE_AUTHORING_V1: () => STAR_DEFENDER_SQUADRON_MISSION_ONE_AUTHORING_V1,
+  STATIC_PROJECT_APPROVAL_STATEMENT_VERSION_V1: () => STATIC_PROJECT_APPROVAL_STATEMENT_VERSION_V1,
+  STATIC_PROJECT_DEFAULT_LIFETIME_DAYS_V1: () => STATIC_PROJECT_DEFAULT_LIFETIME_DAYS_V1,
+  STATIC_PROJECT_MAX_SOURCE_CHARACTERS_V1: () => STATIC_PROJECT_MAX_SOURCE_CHARACTERS_V1,
+  STATIC_PROJECT_PUBLISHING_CONTRACT_VERSION_V1: () => STATIC_PROJECT_PUBLISHING_CONTRACT_VERSION_V1,
+  STATIC_PROJECT_SAFETY_CHECK_IDS_V1: () => STATIC_PROJECT_SAFETY_CHECK_IDS_V1,
+  STATIC_PROJECT_SCANNER_VERSION_V1: () => STATIC_PROJECT_SCANNER_VERSION_V1,
   VIBE_BUG_DETECTIVE_MISSION_ONE_AUTHORING_V1: () => VIBE_BUG_DETECTIVE_MISSION_ONE_AUTHORING_V1,
   VIBE_GAME_REMIX_LAB_MISSION_ONE_AUTHORING_V1: () => VIBE_GAME_REMIX_LAB_MISSION_ONE_AUTHORING_V1,
   VIBE_IDEA_STUDIO_MISSION_ONE_AUTHORING_V1: () => VIBE_IDEA_STUDIO_MISSION_ONE_AUTHORING_V1,
   assertValidLearningPath: () => assertValidLearningPath,
   assertValidMissionAuthoringBundle: () => assertValidMissionAuthoringBundle,
+  assertValidStaticProjectGuardianApproval: () => assertValidStaticProjectGuardianApproval,
+  assertValidStaticProjectPublication: () => assertValidStaticProjectPublication,
+  assertValidStaticProjectSnapshot: () => assertValidStaticProjectSnapshot,
   calculateAssessment: () => calculateAssessment,
   validateAssessmentRubric: () => validateAssessmentRubric,
   validateLearningPath: () => validateLearningPath,
-  validateMissionAuthoringBundle: () => validateMissionAuthoringBundle
+  validateMissionAuthoringBundle: () => validateMissionAuthoringBundle,
+  validateStaticProjectGuardianApproval: () => validateStaticProjectGuardianApproval,
+  validateStaticProjectPublication: () => validateStaticProjectPublication,
+  validateStaticProjectSnapshot: () => validateStaticProjectSnapshot
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -626,6 +639,135 @@ var JUNIOR_CODER_ROBOT_RESCUE_PATH_CURRENT = JUNIOR_CODER_ROBOT_RESCUE_PATH_V1_1
 // src/contracts.ts
 var MISSION_AUTHORING_CONTRACT_VERSION_V1 = "1.0.0";
 
+// src/publishing.ts
+var STATIC_PROJECT_PUBLISHING_CONTRACT_VERSION_V1 = "1.0.0";
+var STATIC_PROJECT_SCANNER_VERSION_V1 = "junior-coder-static-scan-v1";
+var STATIC_PROJECT_APPROVAL_STATEMENT_VERSION_V1 = "guardian-static-publication-v1";
+var STATIC_PROJECT_DEFAULT_LIFETIME_DAYS_V1 = 90;
+var STATIC_PROJECT_MAX_SOURCE_CHARACTERS_V1 = 8e3;
+var STATIC_PROJECT_SAFETY_CHECK_IDS_V1 = [
+  "allow-listed-source",
+  "no-personal-details",
+  "no-external-network",
+  "no-executable-markup",
+  "no-transmitting-forms",
+  "no-uploads-or-embeds",
+  "no-trackers-or-advertising",
+  "no-account-identifiers"
+];
+var DIGEST_PATTERN = /^sha256:[a-f0-9]{64}$/u;
+var IDENTIFIER_PATTERN = /^(?:account|approval|publication|snapshot)_[A-Za-z0-9_-]{20,128}$/u;
+var VERSION_PATTERN = /^[0-9]+\.[0-9]+\.[0-9]+(?:[-+][A-Za-z0-9.-]+)?$/u;
+var RANDOM_SLUG_PATTERN = /^[A-Za-z0-9_-]{40,128}$/u;
+function validDate(value) {
+  return typeof value === "string" && Number.isFinite(Date.parse(value));
+}
+function allSafetyChecksPresent(scan) {
+  if (!Array.isArray(scan.checks) || scan.checks.length !== STATIC_PROJECT_SAFETY_CHECK_IDS_V1.length) {
+    return false;
+  }
+  const supplied = new Set(scan.checks.map((check) => check.id));
+  return STATIC_PROJECT_SAFETY_CHECK_IDS_V1.every((id) => supplied.has(id)) && scan.checks.every((check) => check.passed === true);
+}
+function safeAdventureRender(value) {
+  const headings = ["Moonbase Missions", "Forest Rescue Plans", "Ocean Quest Board"];
+  const titles = ["Find the moon crystal", "Guide the lost firefly", "Map the coral garden"];
+  const days = ["Saturday", "Sunday", "School holiday"];
+  const messages = ["Choose a day", "Add a mission title", "Mission ready!"];
+  return headings.includes(value.heading) && Array.isArray(value.missions) && value.missions.length >= 1 && value.missions.length <= 3 && value.missions.every((mission2) => titles.includes(mission2.title) && days.includes(mission2.day)) && messages.includes(value.validationMessage) && value.savedAcrossRestart === true && value.accessibleSummaryEnabled === true;
+}
+function safeCreatureRender(value) {
+  return ["Moon Moth", "Cloud Cat", "Pebble Dragon"].includes(value.creature) && ["Resting", "Ready to play", "Snack time"].includes(value.status) && [5, 10, 15].includes(value.timerSeconds) && ["single", "cosy-grid", "wide-grid"].includes(value.layout) && value.reducedMotion === true;
+}
+function safeRobotRender(value) {
+  return ["scan", "hold-position", "return-to-base"].includes(value.command) && value.safetyConfirmed === true && [1, 2, 4].includes(value.telemetryRate) && ["line", "bars", "text-only"].includes(value.chartMode) && value.serialSimulation === true && ["SCANNING", "HOLDING", "RETURNING"].includes(value.state);
+}
+function validateStaticProjectSnapshot(value) {
+  const issues = [];
+  if (value.schemaVersion !== "1") issues.push("invalid-schema-version");
+  if (value.contractVersion !== STATIC_PROJECT_PUBLISHING_CONTRACT_VERSION_V1) {
+    issues.push("invalid-contract-version");
+  }
+  if (!IDENTIFIER_PATTERN.test(value.snapshotId) || !IDENTIFIER_PATTERN.test(value.subjectAccountId)) {
+    issues.push("invalid-identifier");
+  }
+  if (!value.moduleId.startsWith("junior-coder.") || value.moduleId !== `junior-coder.${value.moduleSlug}`) {
+    issues.push("invalid-module");
+  }
+  if (!VERSION_PATTERN.test(value.moduleVersion)) issues.push("invalid-version");
+  if (!DIGEST_PATTERN.test(value.sourceDigest)) issues.push("invalid-source-digest");
+  if (!DIGEST_PATTERN.test(value.snapshotDigest)) issues.push("invalid-snapshot-digest");
+  if (!Number.isInteger(value.sourceCharacterCount) || value.sourceCharacterCount < 1 || value.sourceCharacterCount > STATIC_PROJECT_MAX_SOURCE_CHARACTERS_V1) {
+    issues.push("invalid-source-size");
+  }
+  if (!Number.isInteger(value.assessmentScore) || value.assessmentScore < 80 || value.assessmentScore > 100) {
+    issues.push("assessment-score-incomplete");
+  }
+  if (value.mandatorySafetyPassed !== true) issues.push("mandatory-safety-missing");
+  if (value.scan?.passed !== true || value.scan?.scannerVersion !== STATIC_PROJECT_SCANNER_VERSION_V1) {
+    issues.push("scan-not-passed");
+  }
+  if (!value.scan || !allSafetyChecksPresent(value.scan)) issues.push("scan-checks-incomplete");
+  if (value.moduleSlug !== value.renderModel?.kind) issues.push("module-render-model-mismatch");
+  const renderSafe = value.renderModel?.kind === "adventure-mission-planner" ? safeAdventureRender(value.renderModel) : value.renderModel?.kind === "creature-care-dashboard" ? safeCreatureRender(value.renderModel) : value.renderModel?.kind === "robot-mission-control" ? safeRobotRender(value.renderModel) : false;
+  if (!renderSafe) issues.push("unsafe-render-model");
+  if (value.state !== "pending-review" || !validDate(value.createdAt)) issues.push("invalid-created-at");
+  return [...new Set(issues)];
+}
+function assertValidStaticProjectSnapshot(value) {
+  const issues = validateStaticProjectSnapshot(value);
+  if (issues.length > 0) throw new Error(`Invalid static project snapshot: ${issues.join(", ")}`);
+}
+function validateStaticProjectGuardianApproval(value) {
+  const issues = [];
+  if (value.schemaVersion !== "1") issues.push("invalid-schema-version");
+  if (!IDENTIFIER_PATTERN.test(value.approvalId) || !IDENTIFIER_PATTERN.test(value.snapshotId) || !IDENTIFIER_PATTERN.test(value.guardianActorAccountId)) {
+    issues.push("invalid-identifier");
+  }
+  if (!DIGEST_PATTERN.test(value.snapshotDigest)) issues.push("invalid-snapshot-digest");
+  if (value.statementVersion !== STATIC_PROJECT_APPROVAL_STATEMENT_VERSION_V1) {
+    issues.push("invalid-approval-statement");
+  }
+  if (!validDate(value.approvedAt)) issues.push("invalid-approved-at");
+  return [...new Set(issues)];
+}
+function assertValidStaticProjectGuardianApproval(value) {
+  const issues = validateStaticProjectGuardianApproval(value);
+  if (issues.length > 0) throw new Error(`Invalid static project approval: ${issues.join(", ")}`);
+}
+function validateStaticProjectPublication(value) {
+  const issues = [];
+  if (value.schemaVersion !== "1") issues.push("invalid-schema-version");
+  if (!IDENTIFIER_PATTERN.test(value.publicationId) || !IDENTIFIER_PATTERN.test(value.snapshotId) || !IDENTIFIER_PATTERN.test(value.approvalId)) {
+    issues.push("invalid-identifier");
+  }
+  if (!DIGEST_PATTERN.test(value.snapshotDigest)) issues.push("invalid-snapshot-digest");
+  if (!RANDOM_SLUG_PATTERN.test(value.randomSlug)) issues.push("invalid-random-slug");
+  let parsedUrl;
+  try {
+    parsedUrl = new URL(value.publicUrl);
+  } catch {
+    parsedUrl = void 0;
+  }
+  if (!parsedUrl || parsedUrl.protocol !== "https:" || parsedUrl.username || parsedUrl.password) {
+    issues.push("invalid-public-url");
+  }
+  if (!parsedUrl?.pathname.endsWith(`/${value.randomSlug}`)) issues.push("public-url-slug-mismatch");
+  if (value.state !== "published") issues.push("published-state-required");
+  if (!validDate(value.publishedAt)) issues.push("invalid-published-at");
+  if (!validDate(value.expiresAt) || validDate(value.publishedAt) && Date.parse(value.expiresAt) <= Date.parse(value.publishedAt)) {
+    issues.push("invalid-publication-expiry");
+  }
+  if (value.renewedAt !== void 0 && !validDate(value.renewedAt) || value.unpublishedAt !== void 0 && !validDate(value.unpublishedAt)) {
+    issues.push("invalid-lifecycle-timestamp");
+  }
+  return [...new Set(issues)];
+}
+function assertValidStaticProjectPublication(value) {
+  const issues = validateStaticProjectPublication(value);
+  if (issues.length > 0) throw new Error(`Invalid static project publication: ${issues.join(", ")}`);
+}
+
 // src/rubric-validation.ts
 var DIMENSION_TOTALS = {
   structure: 20,
@@ -5770,6 +5912,287 @@ var CREATURE_CARE_DASHBOARD_MISSION_ONE_AUTHORING_V1 = {
     ]
   }
 };
+var ROBOT_MISSION_CONTROL_MISSION_ONE_AUTHORING_V1 = {
+  version: MISSION_AUTHORING_CONTRACT_VERSION_V1,
+  moduleId: "junior-coder.robot-mission-control",
+  moduleVersion: "1.1.0",
+  missionId: "robot-mission-control-mission-1",
+  learner: {
+    estimatedMinutes: 20,
+    stages: [
+      {
+        kind: "learn",
+        instruction: "Read how commands, a fail-safe state machine, confirmations, telemetry charts and the five documented functions build a simulated mission-control panel.",
+        artifactIds: ["robot-mission-control-m1-guide"]
+      },
+      {
+        kind: "predict",
+        instruction: "Predict whether a planned command may leave STOP when the safety confirmation is disabled.",
+        artifactIds: ["robot-mission-control-m1-command-cards"]
+      },
+      {
+        kind: "build",
+        instruction: "Change only the supplied command, confirmation, telemetry rate, chart mode and serial-simulation settings.",
+        artifactIds: ["robot-mission-control-m1-code"]
+      },
+      {
+        kind: "run",
+        instruction: "Use the action-icon Run button to update the private simulated controls, chart and text telemetry.",
+        artifactIds: ["robot-mission-control-m1-code"]
+      },
+      {
+        kind: "assess",
+        instruction: "Run deterministic command, state-machine, safety-confirmation, telemetry and responsive-layout checks.",
+        artifactIds: []
+      },
+      {
+        kind: "inspect",
+        instruction: "Compare the observed STOP state with the planned command and highlighted safety-confirmation setting.",
+        artifactIds: ["robot-mission-control-m1-code"]
+      },
+      {
+        kind: "fix",
+        instruction: "Review and accept or reject the exact safety-confirmation change yourself, then rerun every check.",
+        artifactIds: ["robot-mission-control-m1-code"]
+      },
+      {
+        kind: "explain",
+        instruction: "Explain how confirmation changes the state machine and why the chart and text telemetry must agree.",
+        artifactIds: []
+      },
+      {
+        kind: "reward",
+        instruction: "Collect the evidence-bound mission-control badge after the score reaches 80 and every mandatory STOP test passes.",
+        artifactIds: []
+      }
+    ],
+    readinessChecks: [
+      {
+        id: "robot-mission-control-m1-stop-check",
+        prompt: "Find the planned command, current STOP state, confirmation and text telemetry before running the simulator.",
+        scored: false
+      }
+    ],
+    artifacts: [
+      {
+        id: "robot-mission-control-m1-code",
+        kind: "starter-code",
+        audience: "learner",
+        solutionBearing: false
+      },
+      {
+        id: "robot-mission-control-m1-guide",
+        kind: "starter-assets",
+        audience: "learner",
+        solutionBearing: false
+      },
+      {
+        id: "robot-mission-control-m1-command-cards",
+        kind: "sample-data",
+        audience: "learner",
+        solutionBearing: false
+      }
+    ],
+    goals: [
+      {
+        id: "robot-mission-control-m1-starts",
+        statement: "The responsive control component, chart and text telemetry build with a valid simulated command state machine.",
+        visibility: "visible",
+        criterionIds: ["robot-mission-control-build"],
+        completionRequired: true,
+        aiRequired: false
+      },
+      {
+        id: "robot-mission-control-m1-behaviour",
+        statement: "A confirmed command moves the state machine from STOP and updates the chart and serial simulation with matching bounded telemetry.",
+        visibility: "visible",
+        criterionIds: [
+          "robot-mission-control-goal-one",
+          "robot-mission-control-goal-two",
+          "robot-mission-control-goal-three"
+        ],
+        completionRequired: true,
+        aiRequired: false
+      },
+      {
+        id: "robot-mission-control-m1-safe-private",
+        statement: "Without confirmation the simulator stays in STOP, exposes responsive text telemetry and never opens a real serial port or controls hardware.",
+        visibility: "visible",
+        criterionIds: ["robot-mission-control-safety"],
+        completionRequired: true,
+        aiRequired: false
+      }
+    ],
+    interactions: [
+      {
+        id: "robot-mission-control-m1-editor",
+        description: "Edit the five documented mission-control calls using keyboard or pointer controls.",
+        primaryMode: "keyboard",
+        alternativeIds: []
+      },
+      {
+        id: "robot-mission-control-m1-run",
+        description: "Activate the labelled action-icon Run control.",
+        primaryMode: "pointer",
+        alternativeIds: ["robot-mission-control-m1-keyboard-run"]
+      },
+      {
+        id: "robot-mission-control-m1-review",
+        description: "Review and accept or reject the exact labelled safety diff.",
+        primaryMode: "keyboard",
+        alternativeIds: []
+      }
+    ],
+    accessibilityAlternatives: [
+      {
+        id: "robot-mission-control-m1-keyboard-run",
+        description: "Focus the Run action button and press Enter or Space to produce the same controls, chart and text telemetry.",
+        modes: ["keyboard"],
+        equivalentOutcome: true
+      }
+    ],
+    evidenceRequirements: [
+      {
+        id: "robot-mission-control-m1-assessment",
+        goalIds: [
+          "robot-mission-control-m1-starts",
+          "robot-mission-control-m1-behaviour",
+          "robot-mission-control-m1-safe-private"
+        ],
+        kind: "assessment-result",
+        retention: "entitlement",
+        containsPersonalData: false
+      },
+      {
+        id: "robot-mission-control-m1-explanation",
+        goalIds: ["robot-mission-control-m1-safe-private"],
+        kind: "learner-explanation",
+        retention: "attempt",
+        containsPersonalData: false
+      }
+    ],
+    sideAdventures: [
+      {
+        id: "robot-mission-control-m1-remix",
+        prompt: "Choose another supplied command or chart mode and explain which confirmation and STOP evidence must remain.",
+        completionRequired: false
+      }
+    ],
+    rewardBindings: [
+      {
+        id: "robot-mission-control-m1-badge",
+        badgeId: "robot-mission-control-mission-complete",
+        goalIds: [
+          "robot-mission-control-m1-starts",
+          "robot-mission-control-m1-behaviour",
+          "robot-mission-control-m1-safe-private"
+        ],
+        deterministic: true,
+        random: false,
+        tokenConvertible: false
+      }
+    ],
+    functionReference: [
+      {
+        id: "robot-mission-control-function-command",
+        signature: "planCommand(command)",
+        summary: "Plans one supplied command for the simulated robot state machine.",
+        parameters: [{ name: "command", type: "text", description: "Use scan, hold-position or return-to-base." }],
+        effect: "Updates the planned-command panel but cannot leave STOP without confirmation.",
+        example: 'planCommand("scan");'
+      },
+      {
+        id: "robot-mission-control-function-confirmation",
+        signature: "setSafetyConfirmation(enabled)",
+        summary: "Controls whether the planned simulated command has explicit safety confirmation.",
+        parameters: [{ name: "enabled", type: "Boolean", description: "Use true only after checking the planned command." }],
+        effect: "Allows the simulator state machine to leave STOP; it never approves or controls physical hardware.",
+        example: "setSafetyConfirmation(true);"
+      },
+      {
+        id: "robot-mission-control-function-rate",
+        signature: "setTelemetryRate(samplesPerSecond)",
+        summary: "Sets a bounded simulated telemetry sampling rate.",
+        parameters: [{ name: "samplesPerSecond", type: "number", description: "Use 1, 2 or 4 simulated samples per second." }],
+        effect: "Changes bounded chart and text sample spacing without starting background work.",
+        example: "setTelemetryRate(2);"
+      },
+      {
+        id: "robot-mission-control-function-chart",
+        signature: "setChartMode(mode)",
+        summary: "Chooses one supplied responsive telemetry presentation.",
+        parameters: [{ name: "mode", type: "text", description: "Use line, bars or text-only." }],
+        effect: "Changes the preview chart while preserving equivalent labelled text telemetry.",
+        example: 'setChartMode("line");'
+      },
+      {
+        id: "robot-mission-control-function-serial",
+        signature: "simulateSerial(enabled)",
+        summary: "Turns the bounded serial-message simulator on or off.",
+        parameters: [{ name: "enabled", type: "Boolean", description: "Use true to show simulated messages." }],
+        effect: "Produces labelled local simulator messages; it never opens Web Serial or a physical connection.",
+        example: "simulateSerial(true);"
+      }
+    ],
+    boundedSuggestion: {
+      id: "robot-mission-control-m1-confirmation-diff",
+      source: "authored-fallback",
+      intent: "Confirm the supplied simulated command before the state machine leaves STOP.",
+      constraints: [
+        "Change exactly one documented safety-confirmation setting.",
+        "Preserve the supplied command, telemetry rate, chart mode, serial simulation and text telemetry.",
+        "Do not add Web Serial, network, external scripts, hardware control, personal data or automatic approval."
+      ],
+      permittedArtifactId: "robot-mission-control-m1-code",
+      originalSnippet: "setSafetyConfirmation(false);",
+      replacementSnippet: "setSafetyConfirmation(true);",
+      explanationPrompt: "Which state-machine transition became possible, and what keeps the exercise separate from physical hardware?",
+      aiOptional: false,
+      learnerApprovalRequired: true,
+      alternatives: ["accept", "reject"]
+    }
+  },
+  facilitator: {
+    artifacts: [
+      {
+        id: "robot-mission-control-m1-answer-key",
+        kind: "answer-key",
+        audience: "facilitator",
+        solutionBearing: true
+      },
+      {
+        id: "robot-mission-control-m1-protected-tests",
+        kind: "protected-test",
+        audience: "facilitator",
+        solutionBearing: true
+      },
+      {
+        id: "robot-mission-control-m1-safety-notes",
+        kind: "facilitator-note",
+        audience: "facilitator",
+        solutionBearing: true
+      }
+    ],
+    protectedGoals: [
+      {
+        id: "robot-mission-control-m1-protected-boundary",
+        statement: "The dashboard rejects arbitrary commands, invalid rates, scripts, network access, Web Serial, hardware control, personal data and any unconfirmed transition away from STOP.",
+        visibility: "protected",
+        criterionIds: [
+          "robot-mission-control-edge-one",
+          "robot-mission-control-edge-two"
+        ],
+        completionRequired: false,
+        aiRequired: false
+      }
+    ],
+    prompts: [
+      "Ask the learner to identify the planned command, current state, confirmation and equivalent text telemetry before suggesting a change.",
+      "Keep every command and message inside the simulator; the website never opens serial or controls hardware.",
+      "Reject must preserve source, and provider failure must never block deterministic completion."
+    ]
+  }
+};
 var ADVENTURE_MISSION_PLANNER_MISSION_ONE_AUTHORING_V1 = {
   version: MISSION_AUTHORING_CONTRACT_VERSION_V1,
   moduleId: "junior-coder.adventure-mission-planner",
@@ -6421,17 +6844,30 @@ ${summary}`);
   RESCUE_CREW_COMMANDER_MISSION_ONE_AUTHORING_V1,
   ROAD_HOPPER_RALLY_MISSION_ONE_AUTHORING_V1,
   ROBOT_MAZE_DASH_MISSION_ONE_AUTHORING_V1,
+  ROBOT_MISSION_CONTROL_MISSION_ONE_AUTHORING_V1,
   SERVO_CREATURE_MISSION_ONE_AUTHORING_V1,
   SKYWING_SPRINT_MISSION_ONE_AUTHORING_V1,
   STAR_DEFENDER_SQUADRON_MISSION_ONE_AUTHORING_V1,
+  STATIC_PROJECT_APPROVAL_STATEMENT_VERSION_V1,
+  STATIC_PROJECT_DEFAULT_LIFETIME_DAYS_V1,
+  STATIC_PROJECT_MAX_SOURCE_CHARACTERS_V1,
+  STATIC_PROJECT_PUBLISHING_CONTRACT_VERSION_V1,
+  STATIC_PROJECT_SAFETY_CHECK_IDS_V1,
+  STATIC_PROJECT_SCANNER_VERSION_V1,
   VIBE_BUG_DETECTIVE_MISSION_ONE_AUTHORING_V1,
   VIBE_GAME_REMIX_LAB_MISSION_ONE_AUTHORING_V1,
   VIBE_IDEA_STUDIO_MISSION_ONE_AUTHORING_V1,
   assertValidLearningPath,
   assertValidMissionAuthoringBundle,
+  assertValidStaticProjectGuardianApproval,
+  assertValidStaticProjectPublication,
+  assertValidStaticProjectSnapshot,
   calculateAssessment,
   validateAssessmentRubric,
   validateLearningPath,
-  validateMissionAuthoringBundle
+  validateMissionAuthoringBundle,
+  validateStaticProjectGuardianApproval,
+  validateStaticProjectPublication,
+  validateStaticProjectSnapshot
 });
 //# sourceMappingURL=index.cjs.map