learningfoundry 0.62.0__tar.gz → 0.62.2__tar.gz

{learningfoundry-0.62.0 → learningfoundry-0.62.2}/CHANGELOG.md

@@ -7,6 +7,26 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.62.2] - 2026-05-02
+
+### Fixed
+
+- **Dashboard "Start module →" CTA didn't reflect locked state** (Story I.aa.3). [ProgressDashboard.svelte](src/learningfoundry/sveltekit_template/src/lib/components/ProgressDashboard.svelte) rendered the same active-blue button for every non-complete module regardless of whether `locking.sequential` had locked it. Story I.aa.2 caught the click at the lesson route and rendered a placeholder, but the dashboard was still inviting the click. Same anti-pattern as I.aa.2: locking enforcement was in one place (sidebar) and missed at every other entry point. Fix: dashboard now derives `lockedModules` from the same `lockedModuleIds` helper the sidebar uses, and renders a `Locked` indicator (Lucide Lock icon + `text-gray-400` + `aria-disabled="true"`) instead of the action button when a module is locked. The module title also picks up the Lock icon for visual cohesion with the sidebar idiom.
+
+## [0.62.1] - 2026-05-02
+
+### Fixed
+
+- **Locking config silently disabled when `sequential: true` was mis-placed in the YAML** (Story I.aa.2). Repro: a curriculum YAML with `sequential: true` written one indent level too high (directly under `curriculum:` instead of nested under `curriculum.locking:`) silently parsed with `locking.sequential = false`, so every module was freely expandable, every lesson freely openable, and no lock icon appeared in the sidebar. Pydantic's default `extra='ignore'` ate the unknown field without any warning. Compounded by [+page.svelte](src/learningfoundry/sveltekit_template/src/routes/[module]/[lesson]/+page.svelte) having no locking guard at all — even with the schema fixed, typing or bookmarking a locked-lesson URL would have bypassed the sidebar's enforcement entirely.
+
+### Changed
+
+- **Curriculum schema is now strict.** New `StrictModel` base class in [schema_v1.py](src/learningfoundry/schema_v1.py) sets `model_config = ConfigDict(extra='forbid')`. Every schema model (`CurriculumDef`, `Module`, `Lesson`, `LockingConfig`, `CurriculumV1`, `*Block` types, `AssessmentRef`) inherits from it. A misplaced or typo'd field anywhere in the YAML now produces a `ValidationError` with a JSON-pointer path to the offending field — e.g. `curriculum.sequential — Extra inputs are not permitted`. Breaking change for any curriculum YAML that contained benign extra fields; the project ships only the test fixtures and one user's curriculum, none of which use extras.
+
+### Added
+
+- **Lesson-route locking failsafe** (Story I.aa.2). [+page.svelte](src/learningfoundry/sveltekit_template/src/routes/[module]/[lesson]/+page.svelte) now derives `isLocked` from the same `isModuleLocked` / `isLessonLocked` helpers the sidebar uses, and renders a new [LockedLessonPlaceholder.svelte](src/learningfoundry/sveltekit_template/src/lib/components/LockedLessonPlaceholder.svelte) (lock icon + module/lesson titles + "Complete X to unlock this lesson" + Return-to-dashboard CTA) when the requested URL points at a locked lesson. The `navigateTo` side-effect is guarded by `!isLocked` so a locked-URL load doesn't write `currentPosition` and therefore doesn't highlight the gated module in the sidebar.
+
 ## [0.62.0] - 2026-05-02
 
 ### Fixed

{learningfoundry-0.62.0 → learningfoundry-0.62.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: learningfoundry
-Version: 0.62.0
+Version: 0.62.2
 Summary: A curriculum engine that turns a YAML curriculum definition into a deployable SvelteKit learning application.
 Project-URL: Homepage, https://github.com/pointmatic/learningfoundry
 Project-URL: Repository, https://github.com/pointmatic/learningfoundry

{learningfoundry-0.62.0 → learningfoundry-0.62.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "learningfoundry"
-version = "0.62.0"
+version = "0.62.2"
 description = "A curriculum engine that turns a YAML curriculum definition into a deployable SvelteKit learning application."
 readme = "README.md"
 license = "Apache-2.0"

{learningfoundry-0.62.0 → learningfoundry-0.62.2}/src/learningfoundry/__init__.py

@@ -1,4 +1,4 @@
 # Copyright 2026 Pointmatic
 # SPDX-License-Identifier: Apache-2.0
 
-__version__ = "0.62.0"
+__version__ = "0.62.2"

{learningfoundry-0.62.0 → learningfoundry-0.62.2}/src/learningfoundry/schema_v1.py

@@ -5,7 +5,23 @@
 import re
 from typing import Annotated, Any, Literal, Self
 
-from pydantic import BaseModel, Field, field_validator, model_validator
+from pydantic import BaseModel, ConfigDict, Field, field_validator, model_validator
+
+
+class StrictModel(BaseModel):
+    """Base for every curriculum-schema model.
+
+    `extra='forbid'` makes Pydantic raise `ValidationError` on unknown
+    fields instead of silently dropping them — Story I.aa.2 root cause
+    was a `sequential: true` mis-placed at the curriculum top level
+    instead of nested under `locking:`. The unknown field was discarded
+    without a peep, the resolved curriculum.json shipped with
+    `locking.sequential = false`, and the entire module-locking feature
+    was silently disabled. Strict validation converts that class of typo
+    into a loud build-time error pointing at the offending field name.
+    """
+
+    model_config = ConfigDict(extra="forbid")
 
 _ID_RE = re.compile(r"^[a-z][a-z0-9]*(-[a-z0-9]+)*$")
 YOUTUBE_URL_RE = re.compile(
@@ -26,17 +42,17 @@ def _validate_id(v: str, field_name: str = "id") -> str:
     return v
 
 
-class AssessmentRef(BaseModel):
+class AssessmentRef(StrictModel):
     source: str
     ref: str
 
 
-class TextBlock(BaseModel):
+class TextBlock(StrictModel):
     type: Literal["text"]
     ref: str
 
 
-class VideoBlock(BaseModel):
+class VideoBlock(StrictModel):
     """Video embed. ``provider`` selects the player; ``extensions`` carries
     player-specific options (chapters, transcript refs, etc.) without
     forcing a one-size-fits-all schema across providers.
@@ -59,20 +75,20 @@ class VideoBlock(BaseModel):
         return self
 
 
-class QuizBlock(BaseModel):
+class QuizBlock(StrictModel):
     type: Literal["quiz"]
     source: str
     ref: str
     pass_threshold: float = Field(0.0, ge=0.0, le=1.0)
 
 
-class ExerciseBlock(BaseModel):
+class ExerciseBlock(StrictModel):
     type: Literal["exercise"]
     source: str
     ref: str
 
 
-class VisualizationBlock(BaseModel):
+class VisualizationBlock(StrictModel):
     type: Literal["visualization"]
     source: str
     ref: str
@@ -84,7 +100,7 @@ ContentBlock = Annotated[
 ]
 
 
-class Lesson(BaseModel):
+class Lesson(StrictModel):
     id: str
     title: str
     unlock_module_on_complete: bool = False
@@ -96,7 +112,7 @@ class Lesson(BaseModel):
         return _validate_id(v, "lesson id")
 
 
-class Module(BaseModel):
+class Module(StrictModel):
     id: str
     title: str
     description: str = ""
@@ -117,14 +133,14 @@ class Module(BaseModel):
         return self
 
 
-class LockingConfig(BaseModel):
+class LockingConfig(StrictModel):
     """Curriculum-level content locking configuration."""
 
     sequential: bool = False
     lesson_sequential: bool = False
 
 
-class CurriculumDef(BaseModel):
+class CurriculumDef(StrictModel):
     title: str
     description: str = ""
     locking: LockingConfig = Field(default_factory=LockingConfig)
@@ -158,6 +174,6 @@ class CurriculumDef(BaseModel):
         return self
 
 
-class CurriculumV1(BaseModel):
+class CurriculumV1(StrictModel):
     version: str
     curriculum: CurriculumDef

learningfoundry-0.62.2/src/learningfoundry/sveltekit_template/src/lib/components/LockedLessonPlaceholder.svelte

@@ -0,0 +1,39 @@
+<!-- Copyright 2026 Pointmatic — SPDX-License-Identifier: Apache-2.0 -->
+<script lang="ts">
+	import Lock from 'lucide-svelte/icons/lock';
+
+	interface Props {
+		moduleTitle: string;
+		lessonTitle: string;
+		blockedBy: string | null;
+	}
+	let { moduleTitle, lessonTitle, blockedBy }: Props = $props();
+</script>
+
+<section
+	class="mx-auto flex max-w-xl flex-col items-center gap-4 px-6 py-16 text-center"
+>
+	<div class="rounded-full bg-gray-100 p-4 text-gray-500">
+		<Lock size={32} aria-hidden="true" />
+	</div>
+	<h1 class="text-xl font-semibold text-gray-800">Lesson is locked</h1>
+	<p class="text-sm leading-relaxed text-gray-600">
+		<span class="font-medium">{moduleTitle}</span> &mdash;
+		<span>{lessonTitle}</span>
+	</p>
+	{#if blockedBy}
+		<p class="text-sm text-gray-600">
+			Complete <span class="font-medium">{blockedBy}</span> to unlock this lesson.
+		</p>
+	{:else}
+		<p class="text-sm text-gray-600">
+			This lesson is gated by the curriculum's locking rules.
+		</p>
+	{/if}
+	<a
+		href="/"
+		class="mt-2 inline-flex items-center rounded-md bg-blue-600 px-4 py-2 text-sm font-medium text-white hover:bg-blue-700"
+	>
+		Return to dashboard
+	</a>
+</section>

{learningfoundry-0.62.0 → learningfoundry-0.62.2}/src/learningfoundry/sveltekit_template/src/lib/components/ModuleList.test.ts

@@ -135,6 +135,28 @@ describe('ModuleList mount — locked vs unlocked modules', () => {
 		expect(unlockedItem.querySelector('ul')).not.toBeNull();
 	});
 
+	// Story I.aa.2 — visual regression guard. The lock icon + aria-disabled
+	// is covered above; this pins the rest of the locked-module styling
+	// (cursor-not-allowed on the button, gray-400 text) so a future
+	// refactor of the Tailwind classes can't silently regress the visual
+	// indicator that tells learners a module is gated.
+	it('locked module button carries cursor-not-allowed and gray-400 styling', () => {
+		const m1 = makeModule('mod-01', 'First');
+		const m2 = makeModule('mod-02', 'Locked');
+		const progress = {
+			'mod-01': emptyProgress(m1),
+			'mod-02': emptyProgress(m2)
+		};
+		const { container } = render(ModuleList, {
+			props: { modules: [m1, m2], progress, lockedModules: new Set(['mod-02']) }
+		});
+		const lockedBtn = (
+			container.querySelectorAll('nav > ul > li')[1] as HTMLElement
+		).querySelector('button') as HTMLButtonElement;
+		expect(lockedBtn.className).toContain('cursor-not-allowed');
+		expect(lockedBtn.className).toContain('text-gray-400');
+	});
+
 	// Story I.aa.1 — orthogonal coverage to Story I.y. The previous fix
 	// handled "active lesson present, click course title": the position
 	// transitioned from non-null → null and the auto-expand $effect's

{learningfoundry-0.62.0 → learningfoundry-0.62.2}/src/learningfoundry/sveltekit_template/src/lib/components/ProgressDashboard.svelte

@@ -2,9 +2,10 @@
 <script lang="ts">
 	import { goto } from '$app/navigation';
 	import type { Curriculum, Module, ModuleProgress, QuizScore } from '$lib/types/index.js';
-	import { getOptionalLessons } from '$lib/utils/locking.js';
+	import { getOptionalLessons, lockedModuleIds } from '$lib/utils/locking.js';
 	import { moduleStatus } from './progress-dashboard.helpers.js';
 	import ProgressBar from './ProgressBar.svelte';
+	import Lock from 'lucide-svelte/icons/lock';
 
 	interface Props {
 		modules: Module[];
@@ -57,6 +58,14 @@
 	const overallPct = $derived(
 		totalLessons === 0 ? 0 : Math.round((totalComplete / totalLessons) * 100)
 	);
+
+	// Story I.aa.3 — third entry-point closure for the locking model.
+	// The sidebar (Story I.i / I.j) and the lesson route (Story I.aa.2)
+	// already enforce locking. The dashboard CTA was the remaining
+	// invitation to a click that should not be available.
+	const lockedModules = $derived<Set<string>>(
+		curriculum ? lockedModuleIds(curriculum, progress) : new Set<string>()
+	);
 </script>
 
 <div class="space-y-6">
@@ -70,9 +79,19 @@
 	<div class="space-y-4">
 		{#each modules as mod (mod.id)}
 			{@const stats = moduleStats(mod)}
+			{@const locked = lockedModules.has(mod.id)}
 			<div class="rounded-lg border border-gray-200 bg-white p-4">
 				<div class="mb-2 flex items-center justify-between">
-					<h3 class="text-sm font-medium text-gray-800">{mod.title}</h3>
+					<h3
+						class="flex items-center gap-2 text-sm font-medium {locked
+							? 'text-gray-400'
+							: 'text-gray-800'}"
+					>
+						{#if locked}
+							<Lock size={14} aria-hidden="true" />
+						{/if}
+						{mod.title}
+					</h3>
 					<span class="text-xs text-gray-500">{stats.done}/{stats.total} lessons</span>
 				</div>
 				{#if mod.description}
@@ -93,7 +112,15 @@
 					</p>
 				{/if}
 
-				{#if stats.status !== 'complete'}
+				{#if locked}
+					<p
+						class="mt-3 inline-flex items-center gap-1 text-xs font-medium text-gray-400"
+						aria-disabled="true"
+					>
+						<Lock size={12} aria-hidden="true" />
+						Locked
+					</p>
+				{:else if stats.status !== 'complete'}
 					<button
 						onclick={() => resumeFirst(mod)}
 						class="mt-3 text-xs font-medium text-blue-600 hover:underline"

{learningfoundry-0.62.0 → learningfoundry-0.62.2}/src/learningfoundry/sveltekit_template/src/lib/components/ProgressDashboard.test.ts

@@ -313,3 +313,66 @@ describe('ProgressDashboard mount — per-module action vs ✓ Complete', () =>
 		expect(actionBtn!.textContent).toContain('Start module →');
 	});
 });
+
+// Story I.aa.3 — locked-module CTA. Story I.aa.2 added the lesson-route
+// failsafe so a learner who *deep-links* a locked URL gets the placeholder.
+// This story closes the third entry point: the dashboard's "Start module
+// →" button must reflect locked state, not invite the click in the first
+// place. Same fix shape as I.aa.2 — lock state is derived from the same
+// `lockedModuleIds` helper the sidebar uses; the CTA renders a disabled
+// "Locked" indicator instead of an action button.
+describe('ProgressDashboard mount — locked module CTA (Story I.aa.3)', () => {
+	let ProgressDashboard: typeof import('./ProgressDashboard.svelte').default;
+
+	beforeEach(async () => {
+		ProgressDashboard = (await import('./ProgressDashboard.svelte')).default;
+	});
+
+	afterEach(() => {
+		vi.clearAllMocks();
+	});
+
+	it('locked sequential module renders a "Locked" indicator and no Start-module button; unlocked sibling still renders the button', async () => {
+		const m1 = makeModule('mod-01', 2);
+		const m2 = makeModule('mod-02', 2);
+		const curriculum = {
+			version: '1.0.0',
+			title: 'T',
+			description: '',
+			locking: { sequential: true, lesson_sequential: false },
+			modules: [
+				{ ...m1, locked: null, pre_assessment: null, post_assessment: null },
+				{ ...m2, locked: null, pre_assessment: null, post_assessment: null }
+			]
+		};
+		const progress = {
+			'mod-01': makeProgress(m1, 0),  // not complete → m2 stays locked
+			'mod-02': makeProgress(m2, 0)
+		};
+
+		const { render } = await import('@testing-library/svelte');
+		const { container } = render(ProgressDashboard, {
+			// `curriculum` is required for lock derivation.
+			// eslint-disable-next-line @typescript-eslint/no-explicit-any
+			props: { modules: [m1, m2], progress, curriculum: curriculum as any }
+		});
+
+		const cards = container.querySelectorAll('div.rounded-lg.border');
+		expect(cards.length).toBe(2);
+		const unlockedCard = cards[0] as HTMLElement;
+		const lockedCard = cards[1] as HTMLElement;
+
+		// Unlocked module 1 still has the action button.
+		expect(unlockedCard.querySelector('button')?.textContent ?? '').toContain(
+			'Start module →'
+		);
+
+		// Locked module 2: no action button, "Locked" indicator visible,
+		// rendered with the same gray-400 styling as the sidebar's locked items.
+		expect(lockedCard.querySelector('button')).toBeNull();
+		expect(lockedCard.textContent ?? '').toMatch(/locked/i);
+		// Lucide Lock SVG carries the `lucide-lock` class — same idiom as
+		// the sidebar's locked-module rendering for visual consistency.
+		expect(lockedCard.querySelector('svg.lucide-lock')).not.toBeNull();
+	});
+});

learningfoundry-0.62.2/src/learningfoundry/sveltekit_template/src/routes/[module]/[lesson]/+page.svelte

@@ -0,0 +1,90 @@
+<!-- Copyright 2026 Pointmatic — SPDX-License-Identifier: Apache-2.0 -->
+<script lang="ts">
+	import { page } from '$app/state';
+	import { curriculum, navigateTo } from '$lib/stores/curriculum.js';
+	import { progressStore } from '$lib/stores/progress.js';
+	import type { Lesson, Module } from '$lib/types/index.js';
+	import { isLessonLocked, isModuleLocked } from '$lib/utils/locking.js';
+	import LessonView from '$lib/components/LessonView.svelte';
+	import LockedLessonPlaceholder from '$lib/components/LockedLessonPlaceholder.svelte';
+	import { onMount } from 'svelte';
+
+	const moduleId = $derived(page.params.module);
+	const lessonId = $derived(page.params.lesson);
+
+	const currentModule = $derived<Module | null>(
+		$curriculum?.modules.find((m) => m.id === moduleId) ?? null
+	);
+	const currentLesson = $derived<Lesson | null>(
+		currentModule?.lessons.find((l) => l.id === lessonId) ?? null
+	);
+
+	// Story I.aa.2 — locking failsafe. The sidebar already filters
+	// locked-module clicks (Story I.i / I.j), but a learner who types or
+	// bookmarks a locked-lesson URL would otherwise bypass the model
+	// entirely. Compute lock state here from the same helpers the
+	// sidebar uses, render a placeholder if locked, and skip the
+	// `navigateTo` side-effect so the sidebar doesn't highlight a module
+	// the learner can't actually access.
+	const moduleIndex = $derived<number>(
+		$curriculum?.modules.findIndex((m) => m.id === moduleId) ?? -1
+	);
+	const lessonIndex = $derived<number>(
+		currentModule?.lessons.findIndex((l) => l.id === lessonId) ?? -1
+	);
+	const isLocked = $derived<boolean>(
+		!!$curriculum &&
+			!!currentModule &&
+			!!currentLesson &&
+			(isModuleLocked(moduleIndex, $curriculum, $progressStore) ||
+				isLessonLocked(currentModule.id, lessonIndex, $curriculum, $progressStore))
+	);
+	const blockedByTitle = $derived<string | null>(
+		(() => {
+			if (!isLocked || !$curriculum || !currentModule) return null;
+			// `lesson_sequential` blocks on the previous lesson within the same module.
+			if (lessonIndex > 0 && $curriculum.locking?.lesson_sequential) {
+				return currentModule.lessons[lessonIndex - 1]?.title ?? null;
+			}
+			// Otherwise the block is module-level: name the previous module.
+			if (moduleIndex > 0) return $curriculum.modules[moduleIndex - 1]?.title ?? null;
+			return null;
+		})()
+	);
+
+	// Sync URL params into the curriculum store position — but only when
+	// the lesson is *accessible*. Navigating to a locked URL must not
+	// highlight the locked module in the sidebar; that would be visually
+	// inconsistent with "you can't go here."
+	onMount(() => {
+		if (moduleId && lessonId && !isLocked) navigateTo(moduleId, lessonId);
+	});
+
+	$effect(() => {
+		if (moduleId && lessonId && !isLocked) navigateTo(moduleId, lessonId);
+	});
+</script>
+
+<svelte:head>
+	<title>{currentLesson?.title ?? 'Lesson'} — {$curriculum?.title ?? 'LearningFoundry'}</title>
+</svelte:head>
+
+{#if currentLesson && currentModule && isLocked}
+	<LockedLessonPlaceholder
+		moduleTitle={currentModule.title}
+		lessonTitle={currentLesson.title}
+		blockedBy={blockedByTitle}
+	/>
+{:else if currentLesson && currentModule}
+	{#key `${currentModule.id}/${currentLesson.id}`}
+		<LessonView lesson={currentLesson} moduleId={currentModule.id} />
+	{/key}
+{:else if $curriculum}
+	<div class="flex h-full items-center justify-center">
+		<p class="text-gray-400">Lesson not found.</p>
+	</div>
+{:else}
+	<div class="flex h-full items-center justify-center">
+		<p class="text-gray-400">Loading…</p>
+	</div>
+{/if}

learningfoundry-0.62.2/src/learningfoundry/sveltekit_template/src/routes/[module]/[lesson]/page.test.ts

@@ -0,0 +1,146 @@
+// Copyright 2026 Pointmatic
+// SPDX-License-Identifier: Apache-2.0
+//
+// Story I.aa.2 — locking failsafe at the lesson route. The sidebar
+// already filters locked modules from clicks (Story I.i / I.j), but a
+// learner who types or bookmarks a locked-lesson URL would otherwise
+// land on the full LessonView, bypassing the locking model entirely.
+// The route must render a "locked" placeholder instead.
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { render } from '@testing-library/svelte';
+import { writable } from 'svelte/store';
+import type { Curriculum, ModuleProgress } from '$lib/types/index.js';
+
+const { pageState } = vi.hoisted(() => ({
+	pageState: { params: { module: 'mod-02', lesson: 'lesson-01' } }
+}));
+
+vi.mock('$app/state', () => ({ page: pageState }));
+vi.mock('$app/navigation', () => ({ goto: vi.fn() }));
+
+// Real writables so the page reactively reads the curriculum + progress.
+const curriculumStore = writable<Curriculum | null>(null);
+const progressStore = writable<Record<string, ModuleProgress>>({});
+
+vi.mock('$lib/stores/curriculum.js', async () => {
+	const actual = await vi.importActual<
+		typeof import('$lib/stores/curriculum.js')
+	>('$lib/stores/curriculum.js');
+	return {
+		...actual,
+		curriculum: curriculumStore,
+		navigateTo: vi.fn()
+	};
+});
+
+vi.mock('$lib/stores/progress.js', async () => {
+	const actual = await vi.importActual<
+		typeof import('$lib/stores/progress.js')
+	>('$lib/stores/progress.js');
+	return {
+		...actual,
+		progressStore,
+		invalidateProgress: vi.fn()
+	};
+});
+
+// LessonView's onMount writes through the SQLite repo on lesson open,
+// which would touch `localStorage` / IDB / the wasm fetch — none wired
+// up under this test. Stub the repo to no-op so we can assert purely on
+// the route's render decision.
+vi.mock('$lib/db/index.js', () => ({
+	progressRepo: {
+		markLessonOpened: vi.fn().mockResolvedValue(undefined),
+		markLessonInProgress: vi.fn().mockResolvedValue(undefined),
+		markLessonComplete: vi.fn().mockResolvedValue(undefined),
+		recordQuizScore: vi.fn().mockResolvedValue(undefined),
+		recordExerciseStatus: vi.fn().mockResolvedValue(undefined),
+		getLessonProgress: vi.fn().mockResolvedValue(null),
+		listAllProgress: vi.fn().mockResolvedValue([])
+	},
+	database: { getDb: vi.fn(), persist: vi.fn() }
+}));
+
+function makeCurriculum(): Curriculum {
+	return {
+		version: '1.0.0',
+		title: 'T',
+		description: '',
+		locking: { sequential: true, lesson_sequential: false },
+		modules: [
+			{
+				id: 'mod-01',
+				title: 'M1',
+				description: '',
+				locked: null,
+				pre_assessment: null,
+				post_assessment: null,
+				lessons: [
+					{
+						id: 'lesson-01',
+						title: 'L1',
+						unlock_module_on_complete: false,
+						content_blocks: []
+					}
+				]
+			},
+			{
+				id: 'mod-02',
+				title: 'M2',
+				description: '',
+				locked: null,
+				pre_assessment: null,
+				post_assessment: null,
+				lessons: [
+					{
+						id: 'lesson-01',
+						title: 'L1',
+						unlock_module_on_complete: false,
+						content_blocks: []
+					}
+				]
+			}
+		]
+	} as Curriculum;
+}
+
+describe('lesson route — locking failsafe (Story I.aa.2)', () => {
+	beforeEach(() => {
+		curriculumStore.set(null);
+		progressStore.set({});
+		pageState.params = { module: 'mod-02', lesson: 'lesson-01' };
+	});
+
+	afterEach(() => {
+		vi.clearAllMocks();
+	});
+
+	it('renders a Locked placeholder (not the LessonView) when navigating directly to a lesson in a sequentially-locked module', async () => {
+		curriculumStore.set(makeCurriculum());
+		progressStore.set({});  // Module 1 not complete → Module 2 locked.
+
+		const Page = (await import('./+page.svelte')).default;
+		const { container } = render(Page);
+
+		// LessonView mounts an <article> root; locked placeholder must not.
+		expect(container.querySelector('article')).toBeNull();
+		// Placeholder should announce the locked state.
+		expect(container.textContent).toMatch(/locked/i);
+		// And offer a return path to the dashboard.
+		const link = container.querySelector('a[href="/"]');
+		expect(link).not.toBeNull();
+	});
+
+	it('renders the LessonView when the requested lesson is in an unlocked module', async () => {
+		curriculumStore.set(makeCurriculum());
+		progressStore.set({});
+		pageState.params = { module: 'mod-01', lesson: 'lesson-01' };
+
+		const Page = (await import('./+page.svelte')).default;
+		const { container } = render(Page);
+
+		// Module 1 is the first sequential module → not locked.
+		expect(container.querySelector('article')).not.toBeNull();
+		expect(container.textContent ?? '').not.toMatch(/this lesson is locked/i);
+	});
+});

learningfoundry-0.62.0/src/learningfoundry/sveltekit_template/src/routes/[module]/[lesson]/+page.svelte

@@ -1,45 +0,0 @@
-<!-- Copyright 2026 Pointmatic — SPDX-License-Identifier: Apache-2.0 -->
-<script lang="ts">
-	import { page } from '$app/state';
-	import { curriculum, navigateTo } from '$lib/stores/curriculum.js';
-	import type { Lesson, Module } from '$lib/types/index.js';
-	import LessonView from '$lib/components/LessonView.svelte';
-	import { onMount } from 'svelte';
-
-	const moduleId = $derived(page.params.module);
-	const lessonId = $derived(page.params.lesson);
-
-	const currentModule = $derived<Module | null>(
-		$curriculum?.modules.find((m) => m.id === moduleId) ?? null
-	);
-	const currentLesson = $derived<Lesson | null>(
-		currentModule?.lessons.find((l) => l.id === lessonId) ?? null
-	);
-
-	// Sync URL params into the curriculum store position
-	onMount(() => {
-		if (moduleId && lessonId) navigateTo(moduleId, lessonId);
-	});
-
-	$effect(() => {
-		if (moduleId && lessonId) navigateTo(moduleId, lessonId);
-	});
-</script>
-
-<svelte:head>
-	<title>{currentLesson?.title ?? 'Lesson'} — {$curriculum?.title ?? 'LearningFoundry'}</title>
-</svelte:head>
-
-{#if currentLesson && currentModule}
-	{#key `${currentModule.id}/${currentLesson.id}`}
-		<LessonView lesson={currentLesson} moduleId={currentModule.id} />
-	{/key}
-{:else if $curriculum}
-	<div class="flex h-full items-center justify-center">
-		<p class="text-gray-400">Lesson not found.</p>
-	</div>
-{:else}
-	<div class="flex h-full items-center justify-center">
-		<p class="text-gray-400">Loading…</p>
-	</div>
-{/if}